/[escript]/trunk/escript/test/DataTestCase.cpp
ViewVC logotype

Diff of /trunk/escript/test/DataTestCase.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3596 by jfenwick, Thu Jan 28 02:03:15 2010 UTC revision 3597 by caltinay, Thu Sep 15 06:03:17 2011 UTC
# Line 12  Line 12 
12  *******************************************************/  *******************************************************/
13    
14    
15    #include "DataTestCase.h"
16    
17  #include <iostream>  #include <iostream>
18  #if defined (_WIN32) && defined (__INTEL_COMPILER)  #if defined (_WIN32) && defined (__INTEL_COMPILER)
19  #include <mathimf.h>  #include <mathimf.h>
# Line 19  Line 21 
21  #include <math.h>  #include <math.h>
22  #endif  #endif
23    
 #include "DataTestCase.h"  
   
 #include "escript/FunctionSpace.h"  
24  #include "esysUtils/EsysException.h"  #include "esysUtils/EsysException.h"
   
25  #include "escript/Data.h"  #include "escript/Data.h"
26  #include "escript/DataLazy.h"  #include "escript/DataLazy.h"
27  #include "escript/EscriptParams.h"  #include "escript/EscriptParams.h"
28    #include "escript/FunctionSpace.h"
29    
30    #include <cppunit/TestCaller.h>
31    
32  #define AUTOLAZYON setEscriptParamInt("AUTOLAZY",1);  #define AUTOLAZYON setEscriptParamInt("AUTOLAZY",1);
33  #define AUTOLAZYOFF setEscriptParamInt("AUTOLAZY",0);  #define AUTOLAZYOFF setEscriptParamInt("AUTOLAZY",0);
# Line 35  Line 36 
36  #define RESTORELAZYSTATE setEscriptParamInt("AUTOLAZY",LAZYSTATE);  #define RESTORELAZYSTATE setEscriptParamInt("AUTOLAZY",LAZYSTATE);
37    
38    
   
39  using namespace std;  using namespace std;
40  using namespace CppUnitTest;  using namespace CppUnit;
41  using namespace escript;  using namespace escript;
42  using namespace esysUtils;  using namespace esysUtils;
43  using namespace escript::DataTypes;  using namespace escript::DataTypes;
44    
 void DataTestCase::setUp() {  
   //  
   // This is called before each test is run  
 }  
   
 void DataTestCase::tearDown() {  
   //  
   // This is called after each test has been run  
 }  
   
   
45    
46  namespace  namespace
47  {  {
# Line 104  void DataTestCase::testCopyingWorker(boo Line 93  void DataTestCase::testCopyingWorker(boo
93      Data deep=d->copySelf();    // test self copy      Data deep=d->copySelf();    // test self copy
94      if (delayed)      if (delayed)
95      {      {
96        assert(deep.isLazy());        CPPUNIT_ASSERT(deep.isLazy());
97      }      }
98      for (int i=0;i<DataTypes::noValues(shape);++i)      for (int i=0;i<DataTypes::noValues(shape);++i)
99      {      {
100      if (d->getDataAtOffsetRO(i)!=deep.getDataAtOffsetRO(i))        CPPUNIT_ASSERT(d->getDataAtOffsetRO(i)==deep.getDataAtOffsetRO(i));
101          assert(false);      }
     }  
102      if (delayed)      if (delayed)
103      {      {
104         d->delaySelf();         d->delaySelf();
# Line 118  void DataTestCase::testCopyingWorker(boo Line 106  void DataTestCase::testCopyingWorker(boo
106      d->setToZero();      d->setToZero();
107      if (delayed)      if (delayed)
108      {      {
109        assert(d->isLazy());        CPPUNIT_ASSERT(d->isLazy());
110      }      }
111      for (int i=0;i<DataTypes::noValues(shape);++i)      for (int i=0;i<DataTypes::noValues(shape);++i)
112      {      {
113      if (d->getDataAtOffsetRO(i)==deep.getDataAtOffsetRO(i))        CPPUNIT_ASSERT(d->getDataAtOffsetRO(i)!=deep.getDataAtOffsetRO(i));
         assert(false);  
114      }      }
115          if (delayed)      if (delayed)
116      {      {
117         d->delaySelf();         d->delaySelf();
118         deep.delaySelf();         deep.delaySelf();
# Line 133  void DataTestCase::testCopyingWorker(boo Line 120  void DataTestCase::testCopyingWorker(boo
120      d->copy(deep);          // test copy from object      d->copy(deep);          // test copy from object
121      if (delayed)      if (delayed)
122      {      {
123        assert(d->isLazy());        CPPUNIT_ASSERT(d->isLazy());
124      }      }
125      for (int i=0;i<DataTypes::noValues(shape);++i)      for (int i=0;i<DataTypes::noValues(shape);++i)
126      {      {
127      if (d->getDataAtOffsetRO(i)!=deep.getDataAtOffsetRO(i))        CPPUNIT_ASSERT(d->getDataAtOffsetRO(i)==deep.getDataAtOffsetRO(i));
         assert(false);  
128      }      }
129      d->setToZero();      d->setToZero();
130      for (int i=0;i<DataTypes::noValues(shape);++i)      for (int i=0;i<DataTypes::noValues(shape);++i)
131      {      {
132      if (d->getDataAtOffsetRO(i)==deep.getDataAtOffsetRO(i))        CPPUNIT_ASSERT(d->getDataAtOffsetRO(i)!=deep.getDataAtOffsetRO(i));
         assert(false);  
133      }      }
134      delete dats[k];      delete dats[k];
135    }    }
   
   
   
   
   
   
136  }  }
137    
138    
# Line 196  void DataTestCase::testSlicingWorker(boo Line 175  void DataTestCase::testSlicingWorker(boo
175    
176          Data slice1(dats[k]->getSlice(region));          Data slice1(dats[k]->getSlice(region));
177    
178          if (tags[k]) {assert(slice1.isTagged());}          if (tags[k]) { CPPUNIT_ASSERT(slice1.isTagged()); }
179          assert(slice1.getDataPointRank()==0);          CPPUNIT_ASSERT(slice1.getDataPointRank()==0);
180          assert(slice1.getDataPointRO(0,0)==1.0);          CPPUNIT_ASSERT(slice1.getDataPointRO(0,0)==1.0);
181    
182      //      //
183      // create a rank 2 slice with one value      // create a rank 2 slice with one value
# Line 211  void DataTestCase::testSlicingWorker(boo Line 190  void DataTestCase::testSlicingWorker(boo
190            
191      //cout << slice2.toString() << endl;      //cout << slice2.toString() << endl;
192            
193      if (tags[k]) {assert(slice2.isTagged());}      if (tags[k]) {CPPUNIT_ASSERT(slice2.isTagged());}
194      assert(slice2.getDataPointRank()==2);      CPPUNIT_ASSERT(slice2.getDataPointRank()==2);
195            
196      assert(slice2.getDataAtOffsetRO(slice2.getDataOffset(0,0)+getRelIndex(slice2.getDataPointShape(),0,0))==1.0);      CPPUNIT_ASSERT(slice2.getDataAtOffsetRO(slice2.getDataOffset(0,0)+getRelIndex(slice2.getDataPointShape(),0,0))==1.0);
197    
198      //      //
199      // create a rank 2 slice with four values      // create a rank 2 slice with four values
# Line 227  void DataTestCase::testSlicingWorker(boo Line 206  void DataTestCase::testSlicingWorker(boo
206            
207      //cout << slice3.toString() << endl;      //cout << slice3.toString() << endl;
208            
209      if (tags[k]) {assert(slice3.isTagged());}      if (tags[k]) {CPPUNIT_ASSERT(slice3.isTagged());}
210      assert(slice3.getDataPointRank()==2);      CPPUNIT_ASSERT(slice3.getDataPointRank()==2);
211      assert(getRef(slice3,0,0,0,0)==1.0);      CPPUNIT_ASSERT(getRef(slice3,0,0,0,0)==1.0);
212      assert(getRef(slice3,0,0,0,1)==1.3);      CPPUNIT_ASSERT(getRef(slice3,0,0,0,1)==1.3);
213      assert(getRef(slice3,0,0,1,0)==1.3);      CPPUNIT_ASSERT(getRef(slice3,0,0,1,0)==1.3);
214      assert(getRef(slice3,0,0,1,1)==2.0);      CPPUNIT_ASSERT(getRef(slice3,0,0,1,1)==2.0);
215     }     }
216    
217     // now some extra tests for tagged data (dats[1])     // now some extra tests for tagged data (dats[1])
# Line 255  void DataTestCase::testSlicingWorker(boo Line 234  void DataTestCase::testSlicingWorker(boo
234    
235     Data slice4(dats[1]->getSlice(region));     Data slice4(dats[1]->getSlice(region));
236    
237     assert(slice4.isTagged());     CPPUNIT_ASSERT(slice4.isTagged());
238     assert(slice4.getDataPointRank()==2);     CPPUNIT_ASSERT(slice4.getDataPointRank()==2);
239     assert(getRef(slice4,0,0,0,0)==0);     CPPUNIT_ASSERT(getRef(slice4,0,0,0,0)==0);
240     assert(getRef(slice4,0,0,0,1)==2);     CPPUNIT_ASSERT(getRef(slice4,0,0,0,1)==2);
241     assert(getRef(slice4,0,0,0,2)==4);     CPPUNIT_ASSERT(getRef(slice4,0,0,0,2)==4);
242     assert(getRef(slice4,0,0,1,0)==1);     CPPUNIT_ASSERT(getRef(slice4,0,0,1,0)==1);
243     assert(getRef(slice4,0,0,1,1)==3);     CPPUNIT_ASSERT(getRef(slice4,0,0,1,1)==3);
244     assert(getRef(slice4,0,0,1,2)==5);     CPPUNIT_ASSERT(getRef(slice4,0,0,1,2)==5);
245    
246     for (int k=0;k<NUMDATS;++k)     for (int k=0;k<NUMDATS;++k)
247     {     {
# Line 312  void DataTestCase::testSlicingWorker(boo Line 291  void DataTestCase::testSlicingWorker(boo
291      region.push_back(DataTypes::RegionType::value_type(1,1));      region.push_back(DataTypes::RegionType::value_type(1,1));
292      region.push_back(DataTypes::RegionType::value_type(1,1));      region.push_back(DataTypes::RegionType::value_type(1,1));
293      target.setSlice(*(src[k]),region);      target.setSlice(*(src[k]),region);
294      assert(getRef(target,0,0,1,1)==src[k]->getDataPointRO(0,0));      CPPUNIT_ASSERT(getRef(target,0,0,1,1)==src[k]->getDataPointRO(0,0));
295    }    }
296        
297    // some extra tests on tagged data    // some extra tests on tagged data
# Line 340  void DataTestCase::testSlicingWorker(boo Line 319  void DataTestCase::testSlicingWorker(boo
319    
320    target.setSlice(*src[1],region);    target.setSlice(*src[1],region);
321    
322    assert(target.isTagged());    CPPUNIT_ASSERT(target.isTagged());
323    assert(target.getDataPointRank()==2);    CPPUNIT_ASSERT(target.getDataPointRank()==2);
324    assert(getRef(target,0,0,0,0)==0);    CPPUNIT_ASSERT(getRef(target,0,0,0,0)==0);
325    assert(getRef(target,0,0,0,1)==src[1]->getDataPointRO(0,0));    CPPUNIT_ASSERT(getRef(target,0,0,0,1)==src[1]->getDataPointRO(0,0));
326    assert(getRef(target,0,0,0,2)==4);    CPPUNIT_ASSERT(getRef(target,0,0,0,2)==4);
327    assert(getRef(target,0,0,1,0)==1);    CPPUNIT_ASSERT(getRef(target,0,0,1,0)==1);
328    assert(getRef(target,0,0,1,1)==3);    CPPUNIT_ASSERT(getRef(target,0,0,1,1)==3);
329    assert(getRef(target,0,0,1,2)==5);    CPPUNIT_ASSERT(getRef(target,0,0,1,2)==5);
330    
331    //    //
332    // add a value for tag "2" to source    // add a value for tag "2" to source
# Line 363  void DataTestCase::testSlicingWorker(boo Line 342  void DataTestCase::testSlicingWorker(boo
342    
343    target.setSlice(*src[1],region);    target.setSlice(*src[1],region);
344    
345    assert(target.isTagged());    CPPUNIT_ASSERT(target.isTagged());
346    assert(target.getDataPointRank()==2);    CPPUNIT_ASSERT(target.getDataPointRank()==2);
347    
348      // use a non-existant tag so we get a pointer to the default value      // use a non-existant tag so we get a pointer to the default value
349      // ie: the first element in the data array      // ie: the first element in the data array
350    DataAbstract::ValueType::value_type* targetData=target.getSampleDataByTag(9);    DataAbstract::ValueType::value_type* targetData=target.getSampleDataByTag(9);
351    for (int i=0; i<target.getLength(); i++) {    for (int i=0; i<target.getLength(); i++) {
352        assert(targetData[i]>=0);        CPPUNIT_ASSERT(targetData[i]>=0);
353    }    }
354    assert(targetData[0]==1.3);    CPPUNIT_ASSERT(targetData[0]==1.3);
355    assert(targetData[1]==1.3);    CPPUNIT_ASSERT(targetData[1]==1.3);
356    assert(targetData[2]==10);    CPPUNIT_ASSERT(targetData[2]==10);
357    assert(targetData[3]==1.3);    CPPUNIT_ASSERT(targetData[3]==1.3);
358    assert(targetData[4]==1.3);    CPPUNIT_ASSERT(targetData[4]==1.3);
359    assert(targetData[5]==1.3);    CPPUNIT_ASSERT(targetData[5]==1.3);
360    assert(targetData[6]==0);    CPPUNIT_ASSERT(targetData[6]==0);
361    assert(targetData[7]==1);    CPPUNIT_ASSERT(targetData[7]==1);
362    assert(targetData[8]==10);    CPPUNIT_ASSERT(targetData[8]==10);
363    assert(targetData[9]==3);    CPPUNIT_ASSERT(targetData[9]==3);
364    assert(targetData[10]==4);    CPPUNIT_ASSERT(targetData[10]==4);
365    assert(targetData[11]==5);    CPPUNIT_ASSERT(targetData[11]==5);
366    assert(targetData[12]==1.3);    CPPUNIT_ASSERT(targetData[12]==1.3);
367    assert(targetData[13]==1.3);    CPPUNIT_ASSERT(targetData[13]==1.3);
368    assert(targetData[14]==6);    CPPUNIT_ASSERT(targetData[14]==6);
369    assert(targetData[15]==1.3);    CPPUNIT_ASSERT(targetData[15]==1.3);
370    assert(targetData[16]==1.3);    CPPUNIT_ASSERT(targetData[16]==1.3);
371    assert(targetData[17]==1.3);    CPPUNIT_ASSERT(targetData[17]==1.3);
372    
373    
374    for (int k=0;k<NUMDATS;++k)    for (int k=0;k<NUMDATS;++k)
# Line 411  void DataTestCase::testCopying() Line 390  void DataTestCase::testCopying()
390    testCopyingWorker(true);    testCopyingWorker(true);
391  }  }
392    
393  void DataTestCase::testSlicing() {  void DataTestCase::testSlicing()
394    {
395    cout << "\n\tReadyData." << endl;    cout << "\n\tReadyData." << endl;
396    testSlicingWorker(false);    testSlicingWorker(false);
397    cout << "\n\tLazyData." << endl;    cout << "\n\tLazyData." << endl;
# Line 442  void DataTestCase::testSomeDriver(bool a Line 422  void DataTestCase::testSomeDriver(bool a
422    Data cData(viewData,viewShape);    Data cData(viewData,viewShape);
423    Data result;    Data result;
424    
425    assert(exData.isExpanded());    CPPUNIT_ASSERT(exData.isExpanded());
426    assert(cData.isConstant());    CPPUNIT_ASSERT(cData.isConstant());
427    assert(result.isEmpty());    CPPUNIT_ASSERT(result.isEmpty());
428    
429    cout << "\tTest some basic operations" << endl;    cout << "\tTest some basic operations" << endl;
430    result=exData*cData;    result=exData*cData;
431    cout << CHECKAUTOLAZY << " " << result.isLazy() << " " << result.isExpanded()<< endl;    cout << CHECKAUTOLAZY << " " << result.isLazy() << " " << result.isExpanded()<< endl;
432    assert(CHECKAUTOLAZY?result.isLazy():result.isExpanded());    CPPUNIT_ASSERT(CHECKAUTOLAZY?result.isLazy():result.isExpanded());
433    
434    assert(result.Lsup()==4);    CPPUNIT_ASSERT(result.Lsup()==4);
435    assert(result.sup()==4);    CPPUNIT_ASSERT(result.sup()==4);
436    assert(result.inf()==0);    CPPUNIT_ASSERT(result.inf()==0);
437    
438    result=exData+cData;    result=exData+cData;
439    result=exData-cData;    result=exData-cData;
440    result=exData/cData;    result=exData/cData;
441    
442    cout << "\tExercise wherePositive method" << endl;    cout << "\tExercise wherePositive method" << endl;
443    assert(!exData.wherePositive().isEmpty());    CPPUNIT_ASSERT(!exData.wherePositive().isEmpty());
444    
445    cout << "\tExercise copyWithMask method" << endl;    cout << "\tExercise copyWithMask method" << endl;
446    exData.copyWithMask(result, exData.wherePositive());    exData.copyWithMask(result, exData.wherePositive());
447    assert(!exData.wherePositive().isEmpty());    CPPUNIT_ASSERT(!exData.wherePositive().isEmpty());
448    RESTORELAZYSTATE    RESTORELAZYSTATE
449    
450  }  }
451    
452  void DataTestCase::testSome() {  void DataTestCase::testSome()
453    {
454    testSomeDriver(false);    testSomeDriver(false);
455    testSomeDriver(true);    testSomeDriver(true);
456  }  }
# Line 498  void DataTestCase::testResolveType() Line 479  void DataTestCase::testResolveType()
479    t1.delaySelf();    t1.delaySelf();
480    e1.delaySelf();    e1.delaySelf();
481    Data d1=c1+c1;    Data d1=c1+c1;
482    assert(d1.isLazy());    CPPUNIT_ASSERT(d1.isLazy());
483    assert((d1.resolve(),d1.isConstant()));    CPPUNIT_ASSERT((d1.resolve(),d1.isConstant()));
484    d1=c1+t1;    d1=c1+t1;
485    assert(d1.isLazy());    CPPUNIT_ASSERT(d1.isLazy());
486    assert((d1.resolve(),d1.isTagged()));    CPPUNIT_ASSERT((d1.resolve(),d1.isTagged()));
487    d1=t1+c1;    d1=t1+c1;
488    assert(d1.isLazy());    CPPUNIT_ASSERT(d1.isLazy());
489    assert((d1.resolve(),d1.isTagged()));    CPPUNIT_ASSERT((d1.resolve(),d1.isTagged()));
490    d1=t1+t1;    d1=t1+t1;
491    assert(d1.isLazy());    CPPUNIT_ASSERT(d1.isLazy());
492    assert((d1.resolve(),d1.isTagged()));    CPPUNIT_ASSERT((d1.resolve(),d1.isTagged()));
493    d1=c1+e1;    d1=c1+e1;
494    assert(d1.isLazy());    CPPUNIT_ASSERT(d1.isLazy());
495    assert((d1.resolve(),d1.isExpanded()));    CPPUNIT_ASSERT((d1.resolve(),d1.isExpanded()));
496    d1=e1+c1;    d1=e1+c1;
497    assert(d1.isLazy());    CPPUNIT_ASSERT(d1.isLazy());
498    assert((d1.resolve(),d1.isExpanded()));    CPPUNIT_ASSERT((d1.resolve(),d1.isExpanded()));
499    d1=e1+t1;    d1=e1+t1;
500    assert(d1.isLazy());    CPPUNIT_ASSERT(d1.isLazy());
501    assert((d1.resolve(),d1.isExpanded()));    CPPUNIT_ASSERT((d1.resolve(),d1.isExpanded()));
502    d1=t1+e1;    d1=t1+e1;
503    assert(d1.isLazy());    CPPUNIT_ASSERT(d1.isLazy());
504    assert((d1.resolve(),d1.isExpanded()));    CPPUNIT_ASSERT((d1.resolve(),d1.isExpanded()));
505    d1=e1+e1;    d1=e1+e1;
506    assert(d1.isLazy());    CPPUNIT_ASSERT(d1.isLazy());
507    assert((d1.resolve(),d1.isExpanded()));    CPPUNIT_ASSERT((d1.resolve(),d1.isExpanded()));
508    cout << "\tTesting tag()\n";    cout << "\tTesting tag()\n";
509    c1.tag();    c1.tag();
510    assert(c1.isTagged());    CPPUNIT_ASSERT(c1.isTagged());
511    t1.tag();    t1.tag();
512    assert(t1.isTagged());    CPPUNIT_ASSERT(t1.isTagged());
513    try    CPPUNIT_ASSERT_THROW(e1.tag(), DataException);
   {  
     e1.tag();  
     assert(false);      // this should have thrown  
   } catch(...) {}  
514    cout << "\tTesting expand()\n";    cout << "\tTesting expand()\n";
515    Data c2(viewData,viewShape);    Data c2(viewData,viewShape);
516    Data t2(viewData,viewShape);    Data t2(viewData,viewShape);
# Line 544  void DataTestCase::testResolveType() Line 521  void DataTestCase::testResolveType()
521    t2.delaySelf();    t2.delaySelf();
522    e2.delaySelf();    e2.delaySelf();
523    c2.expand();    c2.expand();
524    assert(c2.isExpanded());    CPPUNIT_ASSERT(c2.isExpanded());
525    t2.expand();    t2.expand();
526    assert(t2.isExpanded());    CPPUNIT_ASSERT(t2.isExpanded());
527    e2.expand();    e2.expand();
528    assert(e2.isExpanded());    CPPUNIT_ASSERT(e2.isExpanded());
529  }  }
530    
531  void DataTestCase::testDataConstant() {  void DataTestCase::testDataConstant()
532    {
533    cout << endl;    cout << endl;
   
534    cout << "\tCreate a DataConstant object." << endl;    cout << "\tCreate a DataConstant object." << endl;
535    
536    DataTypes::ShapeType viewShape;    DataTypes::ShapeType viewShape;
# Line 574  void DataTestCase::testDataConstant() { Line 550  void DataTestCase::testDataConstant() {
550    
551    result=left-right;    result=left-right;
552    
553    assert(left.isConstant());    CPPUNIT_ASSERT(left.isConstant());
554    assert(right.isConstant());    CPPUNIT_ASSERT(right.isConstant());
555    assert(result.isConstant());    CPPUNIT_ASSERT(result.isConstant());
556    
557    result=left+right;    result=left+right;
558    
559    assert(left.isConstant());    CPPUNIT_ASSERT(left.isConstant());
560    assert(right.isConstant());    CPPUNIT_ASSERT(right.isConstant());
561    assert(result.isConstant());    CPPUNIT_ASSERT(result.isConstant());
562    
563    assert(!result.isExpanded());    CPPUNIT_ASSERT(!result.isExpanded());
564    assert(!result.isTagged());    CPPUNIT_ASSERT(!result.isTagged());
565    
566  }  }
567    
568  void DataTestCase::testDataTagged() {  void DataTestCase::testDataTagged()
569    {
570    cout << endl;    cout << endl;
571    
572    {    {
# Line 608  void DataTestCase::testDataTagged() { Line 584  void DataTestCase::testDataTagged() {
584      DataTagged* dt=new DataTagged(FunctionSpace(),viewShape,arr,viewData);      DataTagged* dt=new DataTagged(FunctionSpace(),viewShape,arr,viewData);
585      Data myData(dt);      Data myData(dt);
586    
587      assert(!myData.isEmpty());      CPPUNIT_ASSERT(!myData.isEmpty());
588      assert(myData.isTagged());      CPPUNIT_ASSERT(myData.isTagged());
589      assert(myData.getTagNumber(0)==1);      CPPUNIT_ASSERT(myData.getTagNumber(0)==1);
590      assert(myData.getDataPointRank()==1);      CPPUNIT_ASSERT(myData.getDataPointRank()==1);
591      assert(myData.getLength()==3);      CPPUNIT_ASSERT(myData.getLength()==3);
592            
593      assert(myData.getNoValues()==3);      CPPUNIT_ASSERT(myData.getNoValues()==3);
594      assert(myData.getDataAtOffsetRO(0)==0.0);      CPPUNIT_ASSERT(myData.getDataAtOffsetRO(0)==0.0);
595      assert(myData.getDataAtOffsetRO(1)==1.0);      CPPUNIT_ASSERT(myData.getDataAtOffsetRO(1)==1.0);
596      assert(myData.getDataAtOffsetRO(2)==2.0);      CPPUNIT_ASSERT(myData.getDataAtOffsetRO(2)==2.0);
597    
598      double* sampleData=myData.getSampleDataRW(0);      double* sampleData=myData.getSampleDataRW(0);
599      for (int i=0; i<myData.getNoValues(); i++) {      for (int i=0; i<myData.getNoValues(); i++) {
600        assert(sampleData[i]==i);        CPPUNIT_ASSERT(sampleData[i]==i);
601      }      }
602      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
603      // the first element of the data array      // the first element of the data array
604      sampleData=myData.getSampleDataByTag(9);      sampleData=myData.getSampleDataByTag(9);
605      for (int i=0; i<myData.getLength(); i++) {      for (int i=0; i<myData.getLength(); i++) {
606        assert(sampleData[i]==i);        CPPUNIT_ASSERT(sampleData[i]==i);
607      }      }
608    
609      cout << "\tTest setting of a tag and associated value." << endl;      cout << "\tTest setting of a tag and associated value." << endl;
# Line 641  void DataTestCase::testDataTagged() { Line 617  void DataTestCase::testDataTagged() {
617    
618      myData.setTaggedValueFromCPP(1,viewShape, eTwoData);      myData.setTaggedValueFromCPP(1,viewShape, eTwoData);
619    
620      assert(myData.getLength()==6);      CPPUNIT_ASSERT(myData.getLength()==6);
621    
622      int offset=myData.getDataOffset(0,0);      int offset=myData.getDataOffset(0,0);
623      assert(offset==3);      CPPUNIT_ASSERT(offset==3);
624      assert(myData.getDataPointRank()==1);      CPPUNIT_ASSERT(myData.getDataPointRank()==1);
625      assert(myData.getNoValues()==3);      CPPUNIT_ASSERT(myData.getNoValues()==3);
626    
627      assert(myData.getDataAtOffsetRO(offset+0)==2);      CPPUNIT_ASSERT(myData.getDataAtOffsetRO(offset+0)==2);
628      assert(myData.getDataAtOffsetRO(offset+1)==3);      CPPUNIT_ASSERT(myData.getDataAtOffsetRO(offset+1)==3);
629      assert(myData.getDataAtOffsetRO(offset+2)==4);      CPPUNIT_ASSERT(myData.getDataAtOffsetRO(offset+2)==4);
630    
631      sampleData=myData.getSampleDataByTag(1);      sampleData=myData.getSampleDataByTag(1);
632      for (int i=0; i<myData.getNoValues(); i++) {      for (int i=0; i<myData.getNoValues(); i++) {
633        assert(sampleData[i]==i+2);        CPPUNIT_ASSERT(sampleData[i]==i+2);
634      }      }
635    
636    }    }
# Line 669  void DataTestCase::testDataTagged() { Line 645  void DataTestCase::testDataTagged() {
645      Data myData(1.3,viewShape,FunctionSpace(),false);      Data myData(1.3,viewShape,FunctionSpace(),false);
646      myData.tag();      myData.tag();
647    
648      assert(!myData.isEmpty());      CPPUNIT_ASSERT(!myData.isEmpty());
649      assert(myData.isTagged());      CPPUNIT_ASSERT(myData.isTagged());
650      assert(myData.getTagNumber(0)==1);      CPPUNIT_ASSERT(myData.getTagNumber(0)==1);
651      assert(myData.getDataPointRank()==2);      CPPUNIT_ASSERT(myData.getDataPointRank()==2);
652      assert(myData.getLength()==6);      CPPUNIT_ASSERT(myData.getLength()==6);
653    
654      // check default value      // check default value
655      assert(!myData.isEmpty());      CPPUNIT_ASSERT(!myData.isEmpty());
656      assert(myData.getDataPointRank()==2);      CPPUNIT_ASSERT(myData.getDataPointRank()==2);
657      assert(myData.getNoValues()==6);      CPPUNIT_ASSERT(myData.getNoValues()==6);
658      assert(myData.getDataPointShape().size()==2);      CPPUNIT_ASSERT(myData.getDataPointShape().size()==2);
659      assert(getRef(myData,0,0)==1.3);      CPPUNIT_ASSERT(getRef(myData,0,0)==1.3);
660      assert(getRef(myData,0,1)==1.3);      CPPUNIT_ASSERT(getRef(myData,0,1)==1.3);
661      assert(getRef(myData,0,2)==1.3);      CPPUNIT_ASSERT(getRef(myData,0,2)==1.3);
662      assert(getRef(myData,1,0)==1.3);      CPPUNIT_ASSERT(getRef(myData,1,0)==1.3);
663      assert(getRef(myData,1,1)==1.3);      CPPUNIT_ASSERT(getRef(myData,1,1)==1.3);
664      assert(getRef(myData,1,2)==1.3);      CPPUNIT_ASSERT(getRef(myData,1,2)==1.3);
665    
666      // check value for data-point (0,0).      // check value for data-point (0,0).
667  //     myDataView = myData.getDataPoint(0,0);  //     myDataView = myData.getDataPoint(0,0);
668      assert(!myData.isEmpty());      CPPUNIT_ASSERT(!myData.isEmpty());
669  //     assert(myDataView.getOffset()==0);  //     CPPUNIT_ASSERT(myDataView.getOffset()==0);
670      assert(myData.getDataPointRank()==2);      CPPUNIT_ASSERT(myData.getDataPointRank()==2);
671      assert(myData.getNoValues()==6);      CPPUNIT_ASSERT(myData.getNoValues()==6);
672      assert(myData.getDataPointShape().size()==2);      CPPUNIT_ASSERT(myData.getDataPointShape().size()==2);
673      assert(getRef(myData,0,0)==1.3);      CPPUNIT_ASSERT(getRef(myData,0,0)==1.3);
674      assert(getRef(myData,0,1)==1.3);      CPPUNIT_ASSERT(getRef(myData,0,1)==1.3);
675      assert(getRef(myData,0,2)==1.3);      CPPUNIT_ASSERT(getRef(myData,0,2)==1.3);
676      assert(getRef(myData,1,0)==1.3);      CPPUNIT_ASSERT(getRef(myData,1,0)==1.3);
677      assert(getRef(myData,1,1)==1.3);      CPPUNIT_ASSERT(getRef(myData,1,1)==1.3);
678      assert(getRef(myData,1,2)==1.3);      CPPUNIT_ASSERT(getRef(myData,1,2)==1.3);
679    
680    }    }
681    
682  }  }
683    
684  void DataTestCase::testDataTaggedExceptions() {  void DataTestCase::testDataTaggedExceptions()
685    {
686    cout << endl;    cout << endl;
   
687    cout << "\tTest DataTagged exceptions." << endl;    cout << "\tTest DataTagged exceptions." << endl;
688    
689    Data myData;    Data myData;
690    
691    try {    CPPUNIT_ASSERT_THROW(myData.getSampleDataByTag(0), EsysException);
692        myData.getSampleDataByTag(0);;    CPPUNIT_ASSERT_THROW(myData.setTaggedValueFromCPP(0,DataTypes::ShapeType(), DataTypes::ValueType()), EsysException);
       assert(false);  
   }  
   catch (EsysException&) {  
       //cout << e.what() << endl;  
       assert(true);  
   }  
   
   try {  
       myData.setTaggedValueFromCPP(0,DataTypes::ShapeType(), DataTypes::ValueType());;  
       assert(false);  
   }  
   catch (EsysException&) {  
       //cout << e.what() << endl;  
       assert(true);  
   }  
   
693  }  }
694    
695  void DataTestCase::testConstructors() {  void DataTestCase::testConstructors()
696    {
697    cout << endl;    cout << endl;
698    
699    DataTypes::ShapeType viewShape;    DataTypes::ShapeType viewShape;
# Line 790  void DataTestCase::testMoreOperations() Line 749  void DataTestCase::testMoreOperations()
749    dats[4].delaySelf();    dats[4].delaySelf();
750    dats[5].delaySelf();    dats[5].delaySelf();
751    
752    assert(baseEx.isExpanded());    CPPUNIT_ASSERT(baseEx.isExpanded());
753    assert(baseCon.isConstant());    CPPUNIT_ASSERT(baseCon.isConstant());
754    assert(baseTag.isTagged());    CPPUNIT_ASSERT(baseTag.isTagged());
755    
756    Data results[NUMDATS];    Data results[NUMDATS];
757    double tmp;    double tmp;
# Line 808  void DataTestCase::testMoreOperations() Line 767  void DataTestCase::testMoreOperations()
767      {      {
768         tmp+=getRef(dats[z],i,i);         tmp+=getRef(dats[z],i,i);
769      }      }
770      assert(std::abs(results[z].getDataAtOffsetRO(0) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(results[z].getDataAtOffsetRO(0) - tmp) <= REL_TOL*std::abs(tmp));
771    }    }
772    
773    
# Line 857  void DataTestCase::testOperations() Line 816  void DataTestCase::testOperations()
816    dats[4].delaySelf();    dats[4].delaySelf();
817    dats[5].delaySelf();    dats[5].delaySelf();
818    
819    assert(baseEx.isExpanded());    CPPUNIT_ASSERT(baseEx.isExpanded());
820    assert(baseCon.isConstant());    CPPUNIT_ASSERT(baseCon.isConstant());
821    assert(baseTag.isTagged());    CPPUNIT_ASSERT(baseTag.isTagged());
822    
823    Data results[NUMDATS];    Data results[NUMDATS];
824  //   Data& resultEx=results[0];  //   Data& resultEx=results[0];
# Line 900  void DataTestCase::testOperations() Line 859  void DataTestCase::testOperations()
859      results[z].copy(dats[z].powD(power));      results[z].copy(dats[z].powD(power));
860      if (z>=LAZY)      if (z>=LAZY)
861      {      {
862      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
863      }      }
864    }    }
865    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 908  void DataTestCase::testOperations() Line 867  void DataTestCase::testOperations()
867        tmp=pow((double)data[getRelIndex(shape,i,j)],(double)3.0);        tmp=pow((double)data[getRelIndex(shape,i,j)],(double)3.0);
868        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
869        {        {
870      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
871        }        }
872      }      }
873    }    }
# Line 919  void DataTestCase::testOperations() Line 878  void DataTestCase::testOperations()
878      results[z].copy(dats[z].sin());      results[z].copy(dats[z].sin());
879      if (z>=LAZY)      if (z>=LAZY)
880      {      {
881      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
882      }      }
883    }    }
884    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 927  void DataTestCase::testOperations() Line 886  void DataTestCase::testOperations()
886        tmp=sin((double)data[getRelIndex(shape,i,j)]);        tmp=sin((double)data[getRelIndex(shape,i,j)]);
887        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
888        {        {
889      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
890        }        }
891      }      }
892    }    }
# Line 938  void DataTestCase::testOperations() Line 897  void DataTestCase::testOperations()
897      results[z].copy(dats[z].cos());      results[z].copy(dats[z].cos());
898      if (z>=LAZY)      if (z>=LAZY)
899      {      {
900      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
901      }      }
902    }    }
903    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 946  void DataTestCase::testOperations() Line 905  void DataTestCase::testOperations()
905        tmp=cos((double)data[getRelIndex(shape,i,j)]);        tmp=cos((double)data[getRelIndex(shape,i,j)]);
906        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
907        {        {
908      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
909        }        }
910      }      }
911    }    }
# Line 957  void DataTestCase::testOperations() Line 916  void DataTestCase::testOperations()
916      results[z].copy(dats[z].tan());      results[z].copy(dats[z].tan());
917      if (z>=LAZY)      if (z>=LAZY)
918      {      {
919      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
920      }      }
921    }    }
922    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 965  void DataTestCase::testOperations() Line 924  void DataTestCase::testOperations()
924        tmp=tan((double)data[getRelIndex(shape,i,j)]);        tmp=tan((double)data[getRelIndex(shape,i,j)]);
925        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
926        {        {
927      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
928        }        }
929      }      }
930    }    }
# Line 976  void DataTestCase::testOperations() Line 935  void DataTestCase::testOperations()
935      results[z].copy(sdats[z].asin());      results[z].copy(sdats[z].asin());
936      if (z>=LAZY)      if (z>=LAZY)
937      {      {
938      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
939      }      }
940    }    }
941    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 984  void DataTestCase::testOperations() Line 943  void DataTestCase::testOperations()
943        tmp=asin((double)smalldata[getRelIndex(shape,i,j)]);        tmp=asin((double)smalldata[getRelIndex(shape,i,j)]);
944        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
945        {        {
946      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
947        }        }
948      }      }
949    }    }
# Line 995  void DataTestCase::testOperations() Line 954  void DataTestCase::testOperations()
954      results[z].copy(sdats[z].acos());      results[z].copy(sdats[z].acos());
955      if (z>=LAZY)      if (z>=LAZY)
956      {      {
957      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
958      }      }
959    }    }
960    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1003  void DataTestCase::testOperations() Line 962  void DataTestCase::testOperations()
962        tmp=acos((double)smalldata[getRelIndex(shape,i,j)]);        tmp=acos((double)smalldata[getRelIndex(shape,i,j)]);
963        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
964        {        {
965      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
966        }        }
967      }      }
968    }    }
# Line 1014  void DataTestCase::testOperations() Line 973  void DataTestCase::testOperations()
973      results[z].copy(sdats[z].atan());      results[z].copy(sdats[z].atan());
974      if (z>=LAZY)      if (z>=LAZY)
975      {      {
976      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
977      }      }
978    }    }
979    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1022  void DataTestCase::testOperations() Line 981  void DataTestCase::testOperations()
981        tmp=atan((double)smalldata[getRelIndex(shape,i,j)]);        tmp=atan((double)smalldata[getRelIndex(shape,i,j)]);
982        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
983        {        {
984      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
985        }        }
986      }      }
987    }    }
# Line 1033  void DataTestCase::testOperations() Line 992  void DataTestCase::testOperations()
992      results[z].copy(dats[z].sinh());      results[z].copy(dats[z].sinh());
993      if (z>=LAZY)      if (z>=LAZY)
994      {      {
995      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
996      }      }
997    }    }
998    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1041  void DataTestCase::testOperations() Line 1000  void DataTestCase::testOperations()
1000        tmp=sinh((double)data[getRelIndex(shape,i,j)]);        tmp=sinh((double)data[getRelIndex(shape,i,j)]);
1001        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1002        {        {
1003      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1004        }        }
1005      }      }
1006    }    }
# Line 1052  void DataTestCase::testOperations() Line 1011  void DataTestCase::testOperations()
1011      results[z].copy(dats[z].cosh());      results[z].copy(dats[z].cosh());
1012      if (z>=LAZY)      if (z>=LAZY)
1013      {      {
1014      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1015      }      }
1016    }    }
1017    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1060  void DataTestCase::testOperations() Line 1019  void DataTestCase::testOperations()
1019        tmp=cosh((double)data[getRelIndex(shape,i,j)]);        tmp=cosh((double)data[getRelIndex(shape,i,j)]);
1020        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1021        {        {
1022      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1023        }        }
1024      }      }
1025    }    }
# Line 1071  void DataTestCase::testOperations() Line 1030  void DataTestCase::testOperations()
1030      results[z].copy(dats[z].tanh());      results[z].copy(dats[z].tanh());
1031      if (z>=LAZY)      if (z>=LAZY)
1032      {      {
1033      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1034      }      }
1035    }    }
1036    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1079  void DataTestCase::testOperations() Line 1038  void DataTestCase::testOperations()
1038        tmp=tanh((double)data[getRelIndex(shape,i,j)]);        tmp=tanh((double)data[getRelIndex(shape,i,j)]);
1039        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1040        {        {
1041      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1042        }        }
1043      }      }
1044    }    }
# Line 1091  void DataTestCase::testOperations() Line 1050  void DataTestCase::testOperations()
1050      results[z].copy(dats[z].asinh().sinh());      results[z].copy(dats[z].asinh().sinh());
1051      if (z>=LAZY)      if (z>=LAZY)
1052      {      {
1053      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1054      }      }
1055    }    }
1056    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1099  void DataTestCase::testOperations() Line 1058  void DataTestCase::testOperations()
1058        tmp=data[getRelIndex(shape,i,j)];        tmp=data[getRelIndex(shape,i,j)];
1059        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1060        {        {
1061      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1062        }        }
1063      }      }
1064    }    }
# Line 1110  void DataTestCase::testOperations() Line 1069  void DataTestCase::testOperations()
1069      results[z].copy(dats[z].acosh().cosh());      results[z].copy(dats[z].acosh().cosh());
1070      if (z>=LAZY)      if (z>=LAZY)
1071      {      {
1072      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1073      }      }
1074    }    }
1075    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1119  void DataTestCase::testOperations() Line 1078  void DataTestCase::testOperations()
1078        tmp=data[getRelIndex(shape,i,j)];        tmp=data[getRelIndex(shape,i,j)];
1079        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1080        {        {
1081      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1082        }        }
1083      }      }
1084    }    }
# Line 1130  void DataTestCase::testOperations() Line 1089  void DataTestCase::testOperations()
1089      results[z].copy(dats[z].tanh().atanh());        // if these are the other way around the results are      results[z].copy(dats[z].tanh().atanh());        // if these are the other way around the results are
1090      if (z>=LAZY)                    // undefined      if (z>=LAZY)                    // undefined
1091      {      {
1092      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1093      }      }
1094    }    }
1095    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1138  void DataTestCase::testOperations() Line 1097  void DataTestCase::testOperations()
1097        tmp=data[getRelIndex(shape,i,j)];        tmp=data[getRelIndex(shape,i,j)];
1098        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1099        {        {
1100      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1101        }        }
1102      }      }
1103    }    }
# Line 1149  void DataTestCase::testOperations() Line 1108  void DataTestCase::testOperations()
1108      results[z].copy(dats[z].log());      results[z].copy(dats[z].log());
1109      if (z>=LAZY)      if (z>=LAZY)
1110      {      {
1111      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1112      }      }
1113    }    }
1114    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1158  void DataTestCase::testOperations() Line 1117  void DataTestCase::testOperations()
1117        tmp=log((double)data[getRelIndex(shape,i,j)]);        tmp=log((double)data[getRelIndex(shape,i,j)]);
1118        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1119        {        {
1120      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1121        }        }
1122      }      }
1123    }    }
# Line 1169  void DataTestCase::testOperations() Line 1128  void DataTestCase::testOperations()
1128      results[z].copy(dats[z].log10());      results[z].copy(dats[z].log10());
1129      if (z>=LAZY)      if (z>=LAZY)
1130      {      {
1131      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1132      }      }
1133    }    }
1134    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1178  void DataTestCase::testOperations() Line 1137  void DataTestCase::testOperations()
1137        tmp=log10((double)data[getRelIndex(shape,i,j)]);        tmp=log10((double)data[getRelIndex(shape,i,j)]);
1138        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1139        {        {
1140      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1141        }        }
1142      }      }
1143    }    }
# Line 1191  void DataTestCase::testOperations() Line 1150  void DataTestCase::testOperations()
1150      results[z].copy(dats[z].erf());      results[z].copy(dats[z].erf());
1151      if (z>=LAZY)      if (z>=LAZY)
1152      {      {
1153      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1154      }      }
1155    }    }
1156    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1200  void DataTestCase::testOperations() Line 1159  void DataTestCase::testOperations()
1159        tmp=erf((double)data[getRelIndex(shape,i,j)]);        tmp=erf((double)data[getRelIndex(shape,i,j)]);
1160        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1161        {        {
1162      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1163        }        }
1164      }      }
1165    }    }
# Line 1213  void DataTestCase::testOperations() Line 1172  void DataTestCase::testOperations()
1172      results[z].copy(dats[z].abs());      results[z].copy(dats[z].abs());
1173      if (z>=LAZY)      if (z>=LAZY)
1174      {      {
1175      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1176      }      }
1177    }    }
1178    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1221  void DataTestCase::testOperations() Line 1180  void DataTestCase::testOperations()
1180        tmp=abs((double)data[getRelIndex(shape,i,j)]);        tmp=abs((double)data[getRelIndex(shape,i,j)]);
1181        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1182        {        {
1183      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1184        }        }
1185      }      }
1186    }    }
# Line 1232  void DataTestCase::testOperations() Line 1191  void DataTestCase::testOperations()
1191      results[z].copy(dats[z].sign());      results[z].copy(dats[z].sign());
1192      if (z>=LAZY)      if (z>=LAZY)
1193      {      {
1194      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1195      }      }
1196    }    }
1197    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1240  void DataTestCase::testOperations() Line 1199  void DataTestCase::testOperations()
1199        tmp=(i==0 && j==0)?0:1;        tmp=(i==0 && j==0)?0:1;
1200        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1201        {        {
1202      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1203        }        }
1204      }      }
1205    }    }
# Line 1251  void DataTestCase::testOperations() Line 1210  void DataTestCase::testOperations()
1210      results[z].copy(dats[z].neg().sign());      results[z].copy(dats[z].neg().sign());
1211      if (z>=LAZY)      if (z>=LAZY)
1212      {      {
1213      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1214      }      }
1215    }    }
1216    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1259  void DataTestCase::testOperations() Line 1218  void DataTestCase::testOperations()
1218        tmp=(i==0 && j==0)?0:-1;        tmp=(i==0 && j==0)?0:-1;
1219        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1220        {        {
1221      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1222        }        }
1223      }      }
1224    }    }
# Line 1271  void DataTestCase::testOperations() Line 1230  void DataTestCase::testOperations()
1230      results[z].copy(dats[z].exp());      results[z].copy(dats[z].exp());
1231      if (z>=LAZY)      if (z>=LAZY)
1232      {      {
1233      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1234      }      }
1235    }    }
1236    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1279  void DataTestCase::testOperations() Line 1238  void DataTestCase::testOperations()
1238        tmp=exp((double)data[getRelIndex(shape,i,j)]);        tmp=exp((double)data[getRelIndex(shape,i,j)]);
1239        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1240        {        {
1241      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1242        }        }
1243      }      }
1244    }    }
# Line 1290  void DataTestCase::testOperations() Line 1249  void DataTestCase::testOperations()
1249      results[z].copy(dats[z].sqrt());      results[z].copy(dats[z].sqrt());
1250      if (z>=LAZY)      if (z>=LAZY)
1251      {      {
1252      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1253      }      }
1254    }    }
1255    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1298  void DataTestCase::testOperations() Line 1257  void DataTestCase::testOperations()
1257        tmp=sqrt((double)data[getRelIndex(shape,i,j)]);        tmp=sqrt((double)data[getRelIndex(shape,i,j)]);
1258        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1259        {        {
1260      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1261        }        }
1262      }      }
1263    }    }
# Line 1309  void DataTestCase::testOperations() Line 1268  void DataTestCase::testOperations()
1268      results[z].copy(dats[z].neg());      results[z].copy(dats[z].neg());
1269      if (z>=LAZY)      if (z>=LAZY)
1270      {      {
1271      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1272      }      }
1273    }    }
1274    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
# Line 1317  void DataTestCase::testOperations() Line 1276  void DataTestCase::testOperations()
1276        tmp=-data[getRelIndex(shape,i,j)];        tmp=-data[getRelIndex(shape,i,j)];
1277        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1278        {        {
1279      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1280        }        }
1281      }      }
1282    }    }
# Line 1328  void DataTestCase::testOperations() Line 1287  void DataTestCase::testOperations()
1287      results[z].copy(dats[z].pos());      results[z].copy(dats[z].pos());
1288      if (z>=LAZY)      if (z>=LAZY)
1289      {      {
1290      assert(results[z].isLazy());      CPPUNIT_ASSERT(results[z].isLazy());
1291      }      }
1292    }    }
1293    for (int i=0;i<shape[0];i++) {    for (int i=0;i<shape[0];i++) {
1294      for (int j=0;j<shape[1];j++) {      for (int j=0;j<shape[1];j++) {
1295        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1296        {        {
1297      assert(std::abs(getRef(results[z],i,j) - getRelIndex(shape,i,j)) <= REL_TOL*std::abs(data[getRelIndex(shape,i,j)]));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - getRelIndex(shape,i,j)) <= REL_TOL*std::abs(data[getRelIndex(shape,i,j)]));
1298        }        }
1299      }      }
1300    }    }
# Line 1345  void DataTestCase::testOperations() Line 1304  void DataTestCase::testOperations()
1304    cout << "\tTest Data::Lsup." << endl;    cout << "\tTest Data::Lsup." << endl;
1305    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1306    {    {
1307      assert(std::abs(dats[z].Lsup() - 5) <= REL_TOL*5);      CPPUNIT_ASSERT(std::abs(dats[z].Lsup() - 5) <= REL_TOL*5);
1308    }    }
1309    
1310    cout << "\tTest Data::sup." << endl;    cout << "\tTest Data::sup." << endl;
1311    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1312    {    {
1313      assert(std::abs(dats[z].sup() - 5) <= REL_TOL*5);      CPPUNIT_ASSERT(std::abs(dats[z].sup() - 5) <= REL_TOL*5);
1314    }    }
1315    
1316    cout << "\tTest Data::inf." << endl;    cout << "\tTest Data::inf." << endl;
1317    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1318    {    {
1319      assert(std::abs(dats[z].inf() - 0) <= REL_TOL*0);      CPPUNIT_ASSERT(std::abs(dats[z].inf() - 0) <= REL_TOL*0);
1320    }    }
1321    
1322    // test data-point reduction operations    // test data-point reduction operations
# Line 1369  void DataTestCase::testOperations() Line 1328  void DataTestCase::testOperations()
1328    }    }
1329    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1330    {    {
1331      assert(std::abs(results[z].getDataAtOffsetRO(0) - 0) <= REL_TOL*0);      CPPUNIT_ASSERT(std::abs(results[z].getDataAtOffsetRO(0) - 0) <= REL_TOL*0);
1332    }    }
1333        
1334    
# Line 1380  void DataTestCase::testOperations() Line 1339  void DataTestCase::testOperations()
1339    }    }
1340    for (int z=0;z<NUMDATS;++z)    for (int z=0;z<NUMDATS;++z)
1341    {    {
1342      assert(std::abs(results[z].getDataAtOffsetRO(0) - 5) <= REL_TOL*5);      CPPUNIT_ASSERT(std::abs(results[z].getDataAtOffsetRO(0) - 5) <= REL_TOL*5);
1343    }    }
1344    
1345    cout << "\tTest Data::whereZero." << endl;    cout << "\tTest Data::whereZero." << endl;
# Line 1393  void DataTestCase::testOperations() Line 1352  void DataTestCase::testOperations()
1352        tmp=(getRelIndex(shape,i,j)<=2);        tmp=(getRelIndex(shape,i,j)<=2);
1353        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1354        {        {
1355      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1356        }        }
1357      }      }
1358    }    }
# Line 1408  void DataTestCase::testOperations() Line 1367  void DataTestCase::testOperations()
1367        tmp=!(getRelIndex(shape,i,j)<=2);        tmp=!(getRelIndex(shape,i,j)<=2);
1368        for (int z=0;z<NUMDATS;++z)        for (int z=0;z<NUMDATS;++z)
1369        {        {
1370      assert(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],i,j) - tmp) <= REL_TOL*std::abs(tmp));
1371        }        }
1372      }      }
1373    }    }
# Line 1423  void DataTestCase::testOperations() Line 1382  void DataTestCase::testOperations()
1382       for (int z=0;z<NUMDATS;++z)       for (int z=0;z<NUMDATS;++z)
1383       {       {
1384          tmp=getRef(dats[z],i,j);          tmp=getRef(dats[z],i,j);
1385      assert(std::abs(getRef(results[z],j,i) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],j,i) - tmp) <= REL_TOL*std::abs(tmp));
1386       }       }
1387      }      }
1388    }    }
# Line 1438  void DataTestCase::testOperations() Line 1397  void DataTestCase::testOperations()
1397       for (int z=0;z<NUMDATS;++z)       for (int z=0;z<NUMDATS;++z)
1398       {       {
1399          tmp=getRef(dats[z],i,j);          tmp=getRef(dats[z],i,j);
1400      assert(std::abs(getRef(results[z],j,i) - tmp) <= REL_TOL*std::abs(tmp));      CPPUNIT_ASSERT(std::abs(getRef(results[z],j,i) - tmp) <= REL_TOL*std::abs(tmp));
1401       }       }
1402      }      }
1403    }    }
# Line 1491  void DataTestCase::testBinary() Line 1450  void DataTestCase::testBinary()
1450      Data r4=a.powD(a);      // matrix power      Data r4=a.powD(a);      // matrix power
1451      if (z>LAZY)      if (z>LAZY)
1452      {      {
1453        assert(r1.isLazy() && r2.isLazy() && r3.isLazy() && r4.isLazy());        CPPUNIT_ASSERT(r1.isLazy() && r2.isLazy() && r3.isLazy() && r4.isLazy());
1454      }      }
1455      for (int i=0;i<DataTypes::noValues(shape);++i)      for (int i=0;i<DataTypes::noValues(shape);++i)
1456      {      {
1457        assert(std::abs(r1.getDataAtOffsetRO(i)-data[i]) <= REL_TOL*data[i]);        CPPUNIT_ASSERT(std::abs(r1.getDataAtOffsetRO(i)-data[i]) <= REL_TOL*data[i]);
1458        assert(std::abs(r2.getDataAtOffsetRO(i)-data[i]) <= REL_TOL*data[i]);        CPPUNIT_ASSERT(std::abs(r2.getDataAtOffsetRO(i)-data[i]) <= REL_TOL*data[i]);
1459        assert(std::abs(r3.getDataAtOffsetRO(i)-data[i]) <= REL_TOL*data[i]);        CPPUNIT_ASSERT(std::abs(r3.getDataAtOffsetRO(i)-data[i]) <= REL_TOL*data[i]);
1460        assert(std::abs(r4.getDataAtOffsetRO(i)-pow(data[i],i)) <=REL_TOL*pow(data[i],i));        CPPUNIT_ASSERT(std::abs(r4.getDataAtOffsetRO(i)-pow(data[i],i)) <=REL_TOL*pow(data[i],i));
1461      }      }
1462    }    }
1463  }  }
1464    
1465    
1466  void DataTestCase::testMemAlloc() {  void DataTestCase::testMemAlloc()
1467    {
1468    //    //
1469    // Simple little sanity check for the memory allocator    // Simple little sanity check for the memory allocator
1470    
   cout << endl;  
   
1471    Data *testData;    Data *testData;
1472    for (int i=0; i<1000; i++) {    for (int i=0; i<1000; i++) {
1473      testData = new Data(0.0, DataTypes::ShapeType(), FunctionSpace(), true);      testData = new Data(0.0, DataTypes::ShapeType(), FunctionSpace(), true);
# Line 1532  void DataTestCase::testMemAlloc() { Line 1489  void DataTestCase::testMemAlloc() {
1489    
1490  }  }
1491    
1492  TestSuite* DataTestCase::suite ()  TestSuite* DataTestCase::suite()
1493  {  {
   //  
1494    // create the suite of tests to perform.    // create the suite of tests to perform.
1495    TestSuite *testSuite = new TestSuite ("DataTestCase");    TestSuite *testSuite = new TestSuite("DataTestCase");
1496    testSuite->addTest (new TestCaller< DataTestCase>("testCopying",&DataTestCase::testCopying));    testSuite->addTest(new TestCaller<DataTestCase>(
1497    testSuite->addTest (new TestCaller< DataTestCase>("testSome",&DataTestCase::testSome));                "testCopying",&DataTestCase::testCopying));
1498    testSuite->addTest (new TestCaller< DataTestCase>("testDataConstant",&DataTestCase::testDataConstant));    testSuite->addTest(new TestCaller<DataTestCase>(
1499    testSuite->addTest (new TestCaller< DataTestCase>("testDataTagged",&DataTestCase::testDataTagged));                "testSome",&DataTestCase::testSome));
1500    testSuite->addTest (new TestCaller< DataTestCase>("testDataTaggedExceptions",&DataTestCase::testDataTaggedExceptions));    testSuite->addTest(new TestCaller<DataTestCase>(
1501    testSuite->addTest (new TestCaller< DataTestCase>("testConstructors",&DataTestCase::testConstructors));                "testDataConstant",&DataTestCase::testDataConstant));
1502    testSuite->addTest (new TestCaller< DataTestCase>("testSlicing",&DataTestCase::testSlicing));    testSuite->addTest(new TestCaller<DataTestCase>(
1503    testSuite->addTest (new TestCaller< DataTestCase>("testOperations",&DataTestCase::testOperations));                "testDataTagged",&DataTestCase::testDataTagged));
1504    testSuite->addTest (new TestCaller< DataTestCase>("testMoreOperations",&DataTestCase::testMoreOperations));    testSuite->addTest(new TestCaller<DataTestCase>(
1505    testSuite->addTest (new TestCaller< DataTestCase>("testMemAlloc",&DataTestCase::testMemAlloc));                "testDataTaggedExceptions",&DataTestCase::testDataTaggedExceptions));
1506    testSuite->addTest (new TestCaller< DataTestCase>("Resolving",&DataTestCase::testResolveType));    testSuite->addTest(new TestCaller<DataTestCase>(
1507                  "testConstructors",&DataTestCase::testConstructors));
1508      testSuite->addTest(new TestCaller<DataTestCase>(
1509                  "testSlicing",&DataTestCase::testSlicing));
1510      testSuite->addTest(new TestCaller<DataTestCase>(
1511                  "testOperations",&DataTestCase::testOperations));
1512      testSuite->addTest(new TestCaller<DataTestCase>(
1513                  "testMoreOperations",&DataTestCase::testMoreOperations));
1514      testSuite->addTest(new TestCaller<DataTestCase>(
1515                  "testMemAlloc",&DataTestCase::testMemAlloc));
1516      testSuite->addTest(new TestCaller<DataTestCase>(
1517                  "Resolving",&DataTestCase::testResolveType));
1518        
1519    return testSuite;    return testSuite;
1520  }  }
1521    

Legend:
Removed from v.3596  
changed lines
  Added in v.3597

  ViewVC Help
Powered by ViewVC 1.1.26