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

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

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

trunk/escript/test/DataTagged/DataTaggedTestCase.cpp revision 514 by jgs, Mon Feb 13 04:47:47 2006 UTC branches/ROBW_XPLATFORM/escript/test/DataTagged/DataTaggedTestCase.cpp revision 622 by robwdcock, Wed Mar 22 14:00:08 2006 UTC
# Line 1  Line 1 
1  // $Id$  // $Id$
2    
3  /*  /*
4   *****************************************************************************   *****************************************************************************
5   *                                                                           *   *                                                                           *
# Line 569  void DataTaggedTestCase::testOperations( Line 570  void DataTaggedTestCase::testOperations(
570      DataTagged myData;      DataTagged myData;
571      DataTagged right;      DataTagged right;
572    
573      DataArray vOne(1.0);      // it's important that default values are different, as we need to be able to
574      DataArray vTwo(2.0);      // verify that the tag values in each object are being added to the correct
575        // default values - since the tag lists don't match, the default values will
576        // be used for missing tags in each object
577        myData.getDefaultValue()()=1.0;
578        right.getDefaultValue()()=2.0;
579    
580        DataArray vOne(3.0);
581        DataArray vTwo(4.0);
582      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
583      right.addTaggedValue(2,vTwo.getView());      right.addTaggedValue(2,vTwo.getView());
584    
585        //cout << myData.toString() << endl;
586        //cout << right.toString() << endl;
587    
588      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
589    
590        //cout << myData.toString() << endl;
591    
592      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
593      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
594    
# Line 603  void DataTaggedTestCase::testOperations( Line 616  void DataTaggedTestCase::testOperations(
616      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
617      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
618      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
619      assert(myDataView()==1.0);      assert(myDataView()==5.0);
620    
621      // check result value for tag "2"      // check result value for tag "2"
622      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 612  void DataTaggedTestCase::testOperations( Line 625  void DataTaggedTestCase::testOperations(
625      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
626      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
627      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
628      assert(myDataView()==2.0);      assert(myDataView()==5.0);
629    
630      // check result for default value      // check result for default value
631      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 621  void DataTaggedTestCase::testOperations( Line 634  void DataTaggedTestCase::testOperations(
634      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
635      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
636      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
637      assert(myDataView()==0.0);      assert(myDataView()==3.0);
638    
639      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
640      // the first element of the data array      // the first element of the data array
641      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
642      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==3);
643        assert(sampleData[i]==i);      assert(sampleData[1]==5);
644      }      assert(sampleData[2]==5);
645    
646    }    }
647    
# Line 638  void DataTaggedTestCase::testOperations( Line 651  void DataTaggedTestCase::testOperations(
651      DataTagged myData;      DataTagged myData;
652      DataTagged right;      DataTagged right;
653    
654        // it's important that default values are different, as we need to be able to
655        // verify that the tag values in each object are being added to the correct
656        // default values - since the tag lists don't match, the default values will
657        // be used for missing tags in each object
658        myData.getDefaultValue()()=2.0;
659        right.getDefaultValue()()=3.0;
660    
661      DataArray vOne(1.0);      DataArray vOne(1.0);
662      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
663      myData.addTaggedValue(2,vOne.getView());      myData.addTaggedValue(2,vOne.getView());
664      right.addTaggedValue(2,vOne.getView());      right.addTaggedValue(2,vOne.getView());
665      right.addTaggedValue(3,vOne.getView());      right.addTaggedValue(3,vOne.getView());
666    
667        //cout << myData.toString() << endl;
668        //cout << right.toString() << endl;
669    
670      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
671    
672        //cout << myData.toString() << endl;
673    
674      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
675      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
676    
# Line 674  void DataTaggedTestCase::testOperations( Line 699  void DataTaggedTestCase::testOperations(
699      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
700      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
701      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
702      assert(myDataView()==1.0);      assert(myDataView()==4.0);
703    
704      // check result value for tag "2"      // check result value for tag "2"
705      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 692  void DataTaggedTestCase::testOperations( Line 717  void DataTaggedTestCase::testOperations(
717      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
718      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
719      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
720      assert(myDataView()==1.0);      assert(myDataView()==3.0);
721    
722      // check result for default value      // check result for default value
723      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 701  void DataTaggedTestCase::testOperations( Line 726  void DataTaggedTestCase::testOperations(
726      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
727      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
728      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
729      assert(myDataView()==0.0);      assert(myDataView()==5.0);
730    
731      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
732      // the first element of the data array      // the first element of the data array
733      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
734      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==5);
735        if (i<3) {      assert(sampleData[1]==4);
736          assert(sampleData[i]==i);      assert(sampleData[2]==2);
737        } else {      assert(sampleData[3]==3);
         assert(sampleData[i]==i-2);  
       }  
     }  
738    
739    }    }
740    
# Line 778  void DataTaggedTestCase::testOperations( Line 800  void DataTaggedTestCase::testOperations(
800    }    }
801    
802    {    {
803    
804        cout << "\tTest binaryOp multiplication of DataTagged object with a scalar." << endl;
805    
806        DataTagged myData;
807    
808        DataArray vOne(1.0);
809        DataArray vTwo(2.0);
810        myData.addTaggedValue(1,vOne.getView());
811        myData.addTaggedValue(2,vTwo.getView());
812    
813        DataArray vThree(3.0);
814        DataArrayView right=vThree.getView();
815    
816        //cout << myData.toString() << endl;
817        //cout << right.toString() << endl;
818    
819        binaryOp(myData,right,multiplies<double>());
820    
821        //cout << myData.toString() << endl;
822    
823        assert(myData.getNumSamples()==1);
824        assert(myData.getNumDPPSample()==1);
825    
826        assert(myData.validSamplePointNo(0));
827        assert(myData.validSampleNo(0));
828        assert(!myData.validSamplePointNo(1));
829        assert(!myData.validSampleNo(1));
830    
831        // data-point 0 has tag number 1 by default
832        assert(myData.getTagNumber(0)==1);
833    
834        assert(myData.isCurrentTag(1));
835        assert(myData.isCurrentTag(2));
836    
837        assert(myData.getTagLookup().size()==2);
838    
839        assert(myData.getLength()==3);
840    
841        assert(myData.getPointOffset(0,0)==1);
842    
843        // check result value for tag "1"
844        DataArrayView myDataView = myData.getDataPointByTag(1);
845        assert(!myDataView.isEmpty());
846        assert(myDataView.getOffset()==1);
847        assert(myDataView.getRank()==0);
848        assert(myDataView.noValues()==1);
849        assert(myDataView.getShape().size()==0);
850        assert(myDataView()==3.0);
851    
852        // check result value for tag "2"
853        myDataView = myData.getDataPointByTag(2);
854        assert(!myDataView.isEmpty());
855        assert(myDataView.getOffset()==2);
856        assert(myDataView.getRank()==0);
857        assert(myDataView.noValues()==1);
858        assert(myDataView.getShape().size()==0);
859        assert(myDataView()==6.0);
860    
861        // check result for default value
862        myDataView = myData.getDefaultValue();
863        assert(!myDataView.isEmpty());
864        assert(myDataView.getOffset()==0);
865        assert(myDataView.getRank()==0);
866        assert(myDataView.noValues()==1);
867        assert(myDataView.getShape().size()==0);
868        assert(myDataView()==0.0);
869    
870        // use a non-existent tag so we get a pointer to
871        // the first element of the data array
872        double* sampleData=myData.getSampleDataByTag(9);
873        assert(sampleData[0]==0);
874        assert(sampleData[1]==3);
875        assert(sampleData[2]==6);
876    
877      }
878    
879      {
880      cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;      cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
881    
882      DataTagged myData;      DataTagged myData;
883      DataTagged right;      DataTagged right;
884    
885        // it's important that default values are different, as we need to be able to
886        // verify that the tag values in each object are being added to the correct
887        // default values - since the tag lists don't match, the default values will
888        // be used for missing tags in each object
889        myData.getDefaultValue()()=2.0;
890        right.getDefaultValue()()=3.0;
891    
892      DataArray vOne(1.0);      DataArray vOne(1.0);
893      DataArray vTwo(2.0);      DataArray vTwo(2.0);
894      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
# Line 790  void DataTaggedTestCase::testOperations( Line 896  void DataTaggedTestCase::testOperations(
896      right.addTaggedValue(2,vTwo.getView());      right.addTaggedValue(2,vTwo.getView());
897      right.addTaggedValue(3,vTwo.getView());      right.addTaggedValue(3,vTwo.getView());
898    
899        //cout << myData.toString() << endl;
900        //cout << right.toString() << endl;
901    
902      binaryOp(myData,right,multiplies<double>());      binaryOp(myData,right,multiplies<double>());
903    
904        //cout << myData.toString() << endl;
905    
906      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
907      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
908    
# Line 820  void DataTaggedTestCase::testOperations( Line 931  void DataTaggedTestCase::testOperations(
931      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
932      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
933      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
934      assert(myDataView()==0.0);      assert(myDataView()==3.0);
935    
936      // check result value for tag "2"      // check result value for tag "2"
937      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 838  void DataTaggedTestCase::testOperations( Line 949  void DataTaggedTestCase::testOperations(
949      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
950      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
951      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
952      assert(myDataView()==0.0);      assert(myDataView()==4.0);
953    
954      // check result for default value      // check result for default value
955      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 847  void DataTaggedTestCase::testOperations( Line 958  void DataTaggedTestCase::testOperations(
958      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
959      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
960      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
961      assert(myDataView()==0.0);      assert(myDataView()==6.0);
962    
963      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
964      // the first element of the data array      // the first element of the data array
965      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
966      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==6);
967        if (i==2) {      assert(sampleData[1]==3);
968          assert(sampleData[i]==2);      assert(sampleData[2]==2);
969        } else {      assert(sampleData[3]==4);
         assert(sampleData[i]==0);  
       }  
     }  
970    
971    }    }
972    
# Line 2951  void DataTaggedTestCase::testCopyConstru Line 3059  void DataTaggedTestCase::testCopyConstru
3059    
3060  }  }
3061    
3062  void DataTaggedTestCase::testSlicing() {  void DataTaggedTestCase::testGetSlice() {
3063    
3064    cout << endl;    cout << endl;
3065    
# Line 3164  void DataTaggedTestCase::testSlicing() { Line 3272  void DataTaggedTestCase::testSlicing() {
3272    
3273    }    }
3274    
3275      {
3276    
3277        cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
3278    
3279        DataTagged::TagListType keys;
3280        keys.push_back(1);
3281    
3282        DataTagged::ValueListType values;
3283    
3284        DataArrayView::ShapeType viewShape;
3285    
3286        // default value
3287        DataArrayView::ValueType viewData(1);
3288        viewData[0]=0.0;
3289        DataArrayView myView(viewData,viewShape);
3290    
3291        // value for tag "1"
3292        DataArray eOne(myView);
3293        eOne.getView()()=1.0;
3294        values.push_back(eOne.getView());
3295    
3296        DataTagged myData(keys,values,myView,FunctionSpace());
3297    
3298        //cout << myData.toString() << endl;
3299    
3300        // full slice
3301    
3302        DataArrayView::RegionType region;
3303    
3304        DataAbstract* slicedDefault = myData.getSlice(region);
3305    
3306        //cout << slicedDefault->toString() << endl;
3307    
3308        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3309    
3310        assert(myDataSliced->getTagLookup().size()==1);
3311    
3312        assert(myDataSliced->getLength()==2);
3313    
3314        DataArrayView myDataView = myDataSliced->getDefaultValue();
3315        assert(!myDataView.isEmpty());
3316        assert(myDataView.getOffset()==0);
3317        assert(myDataView.getRank()==0);
3318        assert(myDataView.noValues()==1);
3319        assert(myDataView.getShape().size()==0);
3320        assert(myDataView()==0);
3321    
3322        myDataView = myDataSliced->getDataPointByTag(1);
3323        assert(!myDataView.isEmpty());
3324        assert(myDataView.getOffset()==1);
3325        assert(myDataView.getRank()==0);
3326        assert(myDataView.noValues()==1);
3327        assert(myDataView.getShape().size()==0);
3328        assert(myDataView()==1);
3329    
3330      }
3331    
3332      {
3333    
3334        cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
3335    
3336        DataArrayView::ShapeType viewShape;
3337        viewShape.push_back(3);
3338    
3339        DataTagged::TagListType keys;
3340        keys.push_back(1);
3341    
3342        DataTagged::ValueListType values;
3343    
3344        // default value
3345        DataArrayView::ValueType viewData(3);
3346        for (int i=0;i<viewShape[0];i++) {
3347          viewData[i]=i;
3348        }
3349        DataArrayView myView(viewData,viewShape);
3350    
3351        // value for tag "1"
3352        DataArray eOne(myView);
3353        for (int i=0;i<eOne.getView().getShape()[0];i++) {
3354          eOne.getView()(i)=i+3.0;
3355        }
3356        values.push_back(eOne.getView());
3357    
3358        DataTagged myData(keys,values,myView,FunctionSpace());
3359    
3360        //cout << myData.toString() << endl;
3361    
3362        // full slice
3363    
3364        std::pair<int, int> region_element;
3365        region_element.first=0;
3366        region_element.second=3;
3367        DataArrayView::RegionType region;
3368        region.push_back(region_element);
3369    
3370        DataAbstract* slicedDefault = myData.getSlice(region);
3371    
3372        //cout << slicedDefault->toString() << endl;
3373    
3374        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3375    
3376        assert(myDataSliced->getTagLookup().size()==1);
3377    
3378        assert(myDataSliced->getLength()==6);
3379    
3380        DataArrayView myDataView = myDataSliced->getDefaultValue();
3381        assert(!myDataView.isEmpty());
3382        assert(myDataView.getOffset()==0);
3383        assert(myDataView.getRank()==1);
3384        assert(myDataView.noValues()==3);
3385        assert(myDataView.getShape().size()==1);
3386        assert(myDataView(0)==0);
3387        assert(myDataView(1)==1);
3388        assert(myDataView(2)==2);
3389    
3390        myDataView = myDataSliced->getDataPointByTag(1);
3391        assert(!myDataView.isEmpty());
3392        assert(myDataView.getOffset()==3);
3393        assert(myDataView.getRank()==1);
3394        assert(myDataView.noValues()==3);
3395        assert(myDataView.getShape().size()==1);
3396        assert(myDataView(0)==3);
3397        assert(myDataView(1)==4);
3398        assert(myDataView(2)==5);
3399    
3400        // scalar slice
3401    
3402        region_element.first=1;
3403        region_element.second=1;
3404        region.clear();
3405        region.push_back(region_element);
3406    
3407        slicedDefault = myData.getSlice(region);
3408    
3409        //cout << slicedDefault->toString() << endl;
3410    
3411        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3412    
3413        assert(myDataSliced->getTagLookup().size()==1);
3414    
3415        assert(myDataSliced->getLength()==2);
3416    
3417        myDataView = myDataSliced->getDefaultValue();
3418        assert(!myDataView.isEmpty());
3419        assert(myDataView.getOffset()==0);
3420        assert(myDataView.getRank()==0);
3421        assert(myDataView.noValues()==1);
3422        assert(myDataView.getShape().size()==0);
3423        assert(myDataView()==1);
3424    
3425        myDataView = myDataSliced->getDataPointByTag(1);
3426        assert(!myDataView.isEmpty());
3427        assert(myDataView.getOffset()==1);
3428        assert(myDataView.getRank()==0);
3429        assert(myDataView.noValues()==1);
3430        assert(myDataView.getShape().size()==0);
3431        assert(myDataView()==4);
3432    
3433      }
3434    
3435      {
3436    
3437        cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
3438    
3439        DataArrayView::ShapeType viewShape;
3440        viewShape.push_back(3);
3441        viewShape.push_back(3);
3442        viewShape.push_back(3);
3443    
3444        DataTagged::TagListType keys;
3445        keys.push_back(1);
3446    
3447        DataTagged::ValueListType values;
3448    
3449        // default value
3450        DataArrayView::ValueType viewData(27);
3451        for (int i=0;i<viewData.size();i++) {
3452          viewData[i]=i;
3453        }
3454        DataArrayView myView(viewData,viewShape);
3455    
3456        // value for tag "1"
3457        DataArrayView::ValueType viewData1(27);
3458        for (int i=0;i<viewData1.size();i++) {
3459          viewData1[i]=i+27.0;
3460        }
3461        DataArrayView myView1(viewData1,viewShape);
3462        values.push_back(myView1);
3463    
3464        DataTagged myData(keys,values,myView,FunctionSpace());
3465    
3466        //cout << myData.toString() << endl;
3467    
3468        // full slice
3469    
3470        std::pair<int, int> region_element;
3471        region_element.first=0;
3472        region_element.second=3;
3473        DataArrayView::RegionType region;
3474        region.push_back(region_element);
3475        region.push_back(region_element);
3476        region.push_back(region_element);
3477    
3478        DataAbstract* slicedDefault = myData.getSlice(region);
3479    
3480        //cout << slicedDefault->toString() << endl;
3481    
3482        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3483    
3484        assert(myDataSliced->getTagLookup().size()==1);
3485    
3486        assert(myDataSliced->getLength()==54);
3487    
3488        DataArrayView myDataView = myDataSliced->getDefaultValue();
3489        assert(!myDataView.isEmpty());
3490        assert(myDataView.getOffset()==0);
3491        assert(myDataView.getRank()==3);
3492        assert(myDataView.noValues()==27);
3493        assert(myDataView.getShape().size()==3);
3494    
3495        myDataView = myDataSliced->getDataPointByTag(1);
3496        assert(!myDataView.isEmpty());
3497        assert(myDataView.getOffset()==27);
3498        assert(myDataView.getRank()==3);
3499        assert(myDataView.noValues()==27);
3500        assert(myDataView.getShape().size()==3);
3501    
3502        // rank 1 slice
3503    
3504        region.clear();
3505        region.push_back(region_element);
3506        region_element.second=0;
3507        region.push_back(region_element);
3508        region.push_back(region_element);
3509    
3510        slicedDefault = myData.getSlice(region);
3511    
3512        //cout << slicedDefault->toString() << endl;
3513    
3514        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3515    
3516        assert(myDataSliced->getTagLookup().size()==1);
3517    
3518        assert(myDataSliced->getLength()==6);
3519    
3520        myDataView = myDataSliced->getDefaultValue();
3521        assert(!myDataView.isEmpty());
3522        assert(myDataView.getOffset()==0);
3523        assert(myDataView.getRank()==1);
3524        assert(myDataView.noValues()==3);
3525        assert(myDataView.getShape().size()==1);
3526        assert(myDataView(0)==0);
3527        assert(myDataView(1)==1);
3528        assert(myDataView(2)==2);
3529    
3530        myDataView = myDataSliced->getDataPointByTag(1);
3531        assert(!myDataView.isEmpty());
3532        assert(myDataView.getOffset()==3);
3533        assert(myDataView.getRank()==1);
3534        assert(myDataView.noValues()==3);
3535        assert(myDataView.getShape().size()==1);
3536        assert(myDataView(0)==27);
3537        assert(myDataView(1)==28);
3538        assert(myDataView(2)==29);
3539    
3540        // scalar slice
3541    
3542        region_element.first=1;
3543        region_element.second=1;
3544        region.clear();
3545        region.push_back(region_element);
3546        region.push_back(region_element);
3547        region.push_back(region_element);
3548    
3549        slicedDefault = myData.getSlice(region);
3550    
3551        //cout << slicedDefault->toString() << endl;
3552    
3553        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3554    
3555        assert(myDataSliced->getTagLookup().size()==1);
3556    
3557        assert(myDataSliced->getLength()==2);
3558    
3559        myDataView = myDataSliced->getDefaultValue();
3560        assert(!myDataView.isEmpty());
3561        assert(myDataView.getOffset()==0);
3562        assert(myDataView.getRank()==0);
3563        assert(myDataView.noValues()==1);
3564        assert(myDataView.getShape().size()==0);
3565        assert(myDataView()==13);
3566    
3567        myDataView = myDataSliced->getDataPointByTag(1);
3568        assert(!myDataView.isEmpty());
3569        assert(myDataView.getOffset()==1);
3570        assert(myDataView.getRank()==0);
3571        assert(myDataView.noValues()==1);
3572        assert(myDataView.getShape().size()==0);
3573        assert(myDataView()==40);
3574    
3575      }
3576    
3577      {
3578    
3579        cout << "\tTest slicing DataTagged with scalar values and three tags." << endl;
3580    
3581        DataTagged::TagListType keys;
3582        keys.push_back(1);
3583        keys.push_back(2);
3584        keys.push_back(3);
3585    
3586        DataTagged::ValueListType values;
3587    
3588        DataArrayView::ShapeType viewShape;
3589    
3590        // default value
3591        DataArrayView::ValueType viewData(1);
3592        viewData[0]=0.0;
3593        DataArrayView myView(viewData,viewShape);
3594    
3595        // value for tag "1"
3596        DataArray eOne(myView);
3597        eOne.getView()()=1.0;
3598        values.push_back(eOne.getView());
3599    
3600        // value for tag "2"
3601        DataArray eTwo(myView);
3602        eTwo.getView()()=2.0;
3603        values.push_back(eTwo.getView());
3604    
3605        // value for tag "3"
3606        DataArray eThree(myView);
3607        eThree.getView()()=3.0;
3608        values.push_back(eThree.getView());
3609    
3610        DataTagged myData(keys,values,myView,FunctionSpace());
3611    
3612        // cout << myData.toString() << endl;
3613    
3614        // full slice
3615    
3616        DataArrayView::RegionType region;
3617    
3618        DataAbstract* slicedDefault = myData.getSlice(region);
3619    
3620        //cout << slicedDefault->toString() << endl;
3621    
3622        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3623    
3624        assert(myDataSliced->getTagLookup().size()==3);
3625    
3626        assert(myDataSliced->getLength()==4);
3627    
3628        DataArrayView myDataView = myDataSliced->getDefaultValue();
3629        assert(!myDataView.isEmpty());
3630        assert(myDataView.getOffset()==0);
3631        assert(myDataView.getRank()==0);
3632        assert(myDataView.noValues()==1);
3633        assert(myDataView.getShape().size()==0);
3634        assert(myDataView()==0);
3635    
3636        myDataView = myDataSliced->getDataPointByTag(1);
3637        assert(!myDataView.isEmpty());
3638        assert(myDataView.getOffset()==1);
3639        assert(myDataView.getRank()==0);
3640        assert(myDataView.noValues()==1);
3641        assert(myDataView.getShape().size()==0);
3642        assert(myDataView()==1);
3643    
3644        myDataView = myDataSliced->getDataPointByTag(2);
3645        assert(!myDataView.isEmpty());
3646        assert(myDataView.getOffset()==2);
3647        assert(myDataView.getRank()==0);
3648        assert(myDataView.noValues()==1);
3649        assert(myDataView.getShape().size()==0);
3650        assert(myDataView()==2);
3651    
3652        myDataView = myDataSliced->getDataPointByTag(3);
3653        assert(!myDataView.isEmpty());
3654        assert(myDataView.getOffset()==3);
3655        assert(myDataView.getRank()==0);
3656        assert(myDataView.noValues()==1);
3657        assert(myDataView.getShape().size()==0);
3658        assert(myDataView()==3);
3659    
3660      }
3661    
3662      {
3663    
3664        cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;
3665    
3666        DataArrayView::ShapeType viewShape;
3667        viewShape.push_back(3);
3668    
3669        DataTagged::TagListType keys;
3670        keys.push_back(1);
3671        keys.push_back(2);
3672        keys.push_back(3);
3673    
3674        DataTagged::ValueListType values;
3675    
3676        // default value
3677        DataArrayView::ValueType viewData(3);
3678        for (int i=0;i<viewShape[0];i++) {
3679          viewData[i]=i;
3680        }
3681        DataArrayView myView(viewData,viewShape);
3682    
3683        // value for tag "1"
3684        DataArray eOne(myView);
3685        for (int i=0;i<eOne.getView().getShape()[0];i++) {
3686          eOne.getView()(i)=i+3.0;
3687        }
3688        values.push_back(eOne.getView());
3689    
3690        // value for tag "2"
3691        DataArray eTwo(myView);
3692        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
3693          eTwo.getView()(i)=i+6.0;
3694        }
3695        values.push_back(eTwo.getView());
3696    
3697        // value for tag "3"
3698        DataArray eThree(myView);
3699        for (int i=0;i<eThree.getView().getShape()[0];i++) {
3700          eThree.getView()(i)=i+9.0;
3701        }
3702        values.push_back(eThree.getView());
3703    
3704        DataTagged myData(keys,values,myView,FunctionSpace());
3705    
3706        //cout << myData.toString() << endl;
3707    
3708        // full slice
3709    
3710        std::pair<int, int> region_element;
3711        region_element.first=0;
3712        region_element.second=3;
3713        DataArrayView::RegionType region;
3714        region.push_back(region_element);
3715    
3716        DataAbstract* slicedDefault = myData.getSlice(region);
3717    
3718        //cout << slicedDefault->toString() << endl;
3719    
3720        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3721    
3722        assert(myDataSliced->getTagLookup().size()==3);
3723    
3724        assert(myDataSliced->getLength()==12);
3725    
3726        DataArrayView myDataView = myDataSliced->getDefaultValue();
3727        assert(!myDataView.isEmpty());
3728        assert(myDataView.getOffset()==0);
3729        assert(myDataView.getRank()==1);
3730        assert(myDataView.noValues()==3);
3731        assert(myDataView.getShape().size()==1);
3732        assert(myDataView(0)==0);
3733        assert(myDataView(1)==1);
3734        assert(myDataView(2)==2);
3735    
3736        myDataView = myDataSliced->getDataPointByTag(1);
3737        assert(!myDataView.isEmpty());
3738        assert(myDataView.getOffset()==3);
3739        assert(myDataView.getRank()==1);
3740        assert(myDataView.noValues()==3);
3741        assert(myDataView.getShape().size()==1);
3742        assert(myDataView(0)==3);
3743        assert(myDataView(1)==4);
3744        assert(myDataView(2)==5);
3745    
3746        myDataView = myDataSliced->getDataPointByTag(2);
3747        assert(!myDataView.isEmpty());
3748        assert(myDataView.getOffset()==6);
3749        assert(myDataView.getRank()==1);
3750        assert(myDataView.noValues()==3);
3751        assert(myDataView.getShape().size()==1);
3752        assert(myDataView(0)==6);
3753        assert(myDataView(1)==7);
3754        assert(myDataView(2)==8);
3755    
3756        myDataView = myDataSliced->getDataPointByTag(3);
3757        assert(!myDataView.isEmpty());
3758        assert(myDataView.getOffset()==9);
3759        assert(myDataView.getRank()==1);
3760        assert(myDataView.noValues()==3);
3761        assert(myDataView.getShape().size()==1);
3762        assert(myDataView(0)==9);
3763        assert(myDataView(1)==10);
3764        assert(myDataView(2)==11);
3765    
3766        // scalar slice
3767    
3768        region.clear();
3769        region_element.first=1;
3770        region_element.second=1;
3771        region.push_back(region_element);
3772    
3773        slicedDefault = myData.getSlice(region);
3774    
3775        //cout << slicedDefault->toString() << endl;
3776    
3777        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3778    
3779        assert(myDataSliced->getTagLookup().size()==3);
3780    
3781        assert(myDataSliced->getLength()==4);
3782    
3783        myDataView = myDataSliced->getDefaultValue();
3784        assert(!myDataView.isEmpty());
3785        assert(myDataView.getOffset()==0);
3786        assert(myDataView.getRank()==0);
3787        assert(myDataView.noValues()==1);
3788        assert(myDataView.getShape().size()==0);
3789        assert(myDataView()==1);
3790    
3791        myDataView = myDataSliced->getDataPointByTag(1);
3792        assert(!myDataView.isEmpty());
3793        assert(myDataView.getOffset()==1);
3794        assert(myDataView.getRank()==0);
3795        assert(myDataView.noValues()==1);
3796        assert(myDataView.getShape().size()==0);
3797        assert(myDataView()==4);
3798    
3799        myDataView = myDataSliced->getDataPointByTag(2);
3800        assert(!myDataView.isEmpty());
3801        assert(myDataView.getOffset()==2);
3802        assert(myDataView.getRank()==0);
3803        assert(myDataView.noValues()==1);
3804        assert(myDataView.getShape().size()==0);
3805        assert(myDataView()==7);
3806    
3807        myDataView = myDataSliced->getDataPointByTag(3);
3808        assert(!myDataView.isEmpty());
3809        assert(myDataView.getOffset()==3);
3810        assert(myDataView.getRank()==0);
3811        assert(myDataView.noValues()==1);
3812        assert(myDataView.getShape().size()==0);
3813        assert(myDataView()==10);
3814    
3815      }
3816    
3817      {
3818    
3819        cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl;
3820    
3821        DataArrayView::ShapeType viewShape;
3822        viewShape.push_back(3);
3823        viewShape.push_back(3);
3824        viewShape.push_back(3);
3825    
3826        DataTagged::TagListType keys;
3827        keys.push_back(1);
3828        keys.push_back(2);
3829        keys.push_back(3);
3830    
3831        DataTagged::ValueListType values;
3832    
3833        // default value
3834        DataArrayView::ValueType viewData(27);
3835        for (int i=0;i<viewData.size();i++) {
3836          viewData[i]=i;
3837        }
3838        DataArrayView myView(viewData,viewShape);
3839    
3840        // value for tag "1"
3841        DataArrayView::ValueType viewData1(27);
3842        for (int i=0;i<viewData1.size();i++) {
3843          viewData1[i]=i+27.0;
3844        }
3845        DataArrayView myView1(viewData1,viewShape);
3846        values.push_back(myView1);
3847    
3848        // value for tag "2"
3849        DataArrayView::ValueType viewData2(27);
3850        for (int i=0;i<viewData2.size();i++) {
3851          viewData2[i]=i+54.0;
3852        }
3853        DataArrayView myView2(viewData2,viewShape);
3854        values.push_back(myView2);
3855    
3856        // value for tag "3"
3857        DataArrayView::ValueType viewData3(27);
3858        for (int i=0;i<viewData3.size();i++) {
3859          viewData3[i]=i+81.0;
3860        }
3861        DataArrayView myView3(viewData3,viewShape);
3862        values.push_back(myView3);
3863    
3864        DataTagged myData(keys,values,myView,FunctionSpace());
3865    
3866        //cout << myData.toString() << endl;
3867    
3868        // full slice
3869    
3870        std::pair<int, int> region_element;
3871        region_element.first=0;
3872        region_element.second=3;
3873        DataArrayView::RegionType region;
3874        region.push_back(region_element);
3875        region.push_back(region_element);
3876        region.push_back(region_element);
3877    
3878        DataAbstract* slicedDefault = myData.getSlice(region);
3879    
3880        //cout << slicedDefault->toString() << endl;
3881    
3882        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3883    
3884        assert(myDataSliced->getTagLookup().size()==3);
3885    
3886        assert(myDataSliced->getLength()==108);
3887    
3888        DataArrayView myDataView = myDataSliced->getDefaultValue();
3889        assert(!myDataView.isEmpty());
3890        assert(myDataView.getOffset()==0);
3891        assert(myDataView.getRank()==3);
3892        assert(myDataView.noValues()==27);
3893        assert(myDataView.getShape().size()==3);
3894    
3895        myDataView = myDataSliced->getDataPointByTag(1);
3896        assert(!myDataView.isEmpty());
3897        assert(myDataView.getOffset()==27);
3898        assert(myDataView.getRank()==3);
3899        assert(myDataView.noValues()==27);
3900        assert(myDataView.getShape().size()==3);
3901    
3902        myDataView = myDataSliced->getDataPointByTag(2);
3903        assert(!myDataView.isEmpty());
3904        assert(myDataView.getOffset()==54);
3905        assert(myDataView.getRank()==3);
3906        assert(myDataView.noValues()==27);
3907        assert(myDataView.getShape().size()==3);
3908    
3909        myDataView = myDataSliced->getDataPointByTag(3);
3910        assert(!myDataView.isEmpty());
3911        assert(myDataView.getOffset()==81);
3912        assert(myDataView.getRank()==3);
3913        assert(myDataView.noValues()==27);
3914        assert(myDataView.getShape().size()==3);
3915    
3916        // rank 1 slice
3917    
3918        region.clear();
3919        region.push_back(region_element);
3920        region_element.second=0;
3921        region.push_back(region_element);
3922        region.push_back(region_element);
3923    
3924        slicedDefault = myData.getSlice(region);
3925    
3926        // cout << slicedDefault->toString() << endl;
3927    
3928        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3929    
3930        assert(myDataSliced->getTagLookup().size()==3);
3931    
3932        assert(myDataSliced->getLength()==12);
3933    
3934        myDataView = myDataSliced->getDefaultValue();
3935        assert(!myDataView.isEmpty());
3936        assert(myDataView.getOffset()==0);
3937        assert(myDataView.getRank()==1);
3938        assert(myDataView.noValues()==3);
3939        assert(myDataView.getShape().size()==1);
3940        assert(myDataView(0)==0);
3941        assert(myDataView(1)==1);
3942        assert(myDataView(2)==2);
3943    
3944        myDataView = myDataSliced->getDataPointByTag(1);
3945        assert(!myDataView.isEmpty());
3946        assert(myDataView.getOffset()==3);
3947        assert(myDataView.getRank()==1);
3948        assert(myDataView.noValues()==3);
3949        assert(myDataView.getShape().size()==1);
3950        assert(myDataView(0)==27);
3951        assert(myDataView(1)==28);
3952        assert(myDataView(2)==29);
3953    
3954        myDataView = myDataSliced->getDataPointByTag(2);
3955        assert(!myDataView.isEmpty());
3956        assert(myDataView.getOffset()==6);
3957        assert(myDataView.getRank()==1);
3958        assert(myDataView.noValues()==3);
3959        assert(myDataView.getShape().size()==1);
3960        assert(myDataView(0)==54);
3961        assert(myDataView(1)==55);
3962        assert(myDataView(2)==56);
3963    
3964        myDataView = myDataSliced->getDataPointByTag(3);
3965        assert(!myDataView.isEmpty());
3966        assert(myDataView.getOffset()==9);
3967        assert(myDataView.getRank()==1);
3968        assert(myDataView.noValues()==3);
3969        assert(myDataView.getShape().size()==1);
3970        assert(myDataView(0)==81);
3971        assert(myDataView(1)==82);
3972        assert(myDataView(2)==83);
3973    
3974        // scalar slice
3975    
3976        region_element.first=1;
3977        region_element.second=1;
3978        region.clear();
3979        region.push_back(region_element);
3980        region.push_back(region_element);
3981        region.push_back(region_element);
3982    
3983        slicedDefault = myData.getSlice(region);
3984    
3985        //cout << slicedDefault->toString() << endl;
3986    
3987        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3988    
3989        assert(myDataSliced->getTagLookup().size()==3);
3990    
3991        assert(myDataSliced->getLength()==4);
3992    
3993        myDataView = myDataSliced->getDefaultValue();
3994        assert(!myDataView.isEmpty());
3995        assert(myDataView.getOffset()==0);
3996        assert(myDataView.getRank()==0);
3997        assert(myDataView.noValues()==1);
3998        assert(myDataView.getShape().size()==0);
3999        assert(myDataView()==13);
4000    
4001        myDataView = myDataSliced->getDataPointByTag(1);
4002        assert(!myDataView.isEmpty());
4003        assert(myDataView.getOffset()==1);
4004        assert(myDataView.getRank()==0);
4005        assert(myDataView.noValues()==1);
4006        assert(myDataView.getShape().size()==0);
4007        assert(myDataView()==40);
4008    
4009        myDataView = myDataSliced->getDataPointByTag(2);
4010        assert(!myDataView.isEmpty());
4011        assert(myDataView.getOffset()==2);
4012        assert(myDataView.getRank()==0);
4013        assert(myDataView.noValues()==1);
4014        assert(myDataView.getShape().size()==0);
4015        assert(myDataView()==67);
4016    
4017        myDataView = myDataSliced->getDataPointByTag(3);
4018        assert(!myDataView.isEmpty());
4019        assert(myDataView.getOffset()==3);
4020        assert(myDataView.getRank()==0);
4021        assert(myDataView.noValues()==1);
4022        assert(myDataView.getShape().size()==0);
4023        assert(myDataView()==94);
4024    
4025      }
4026    
4027    }
4028    
4029    void DataTaggedTestCase::testSetSlice() {
4030    
4031      cout << endl;
4032    
4033      {
4034    
4035        cout << "\tTest slicing default DataTagged." << endl;
4036    
4037        DataTagged myData1;
4038        DataTagged myData2;
4039    
4040        DataArrayView::RegionType region;
4041    
4042        myData2.getDefaultValue()()=1.0;
4043    
4044        myData1.setSlice(&myData2, region);
4045    
4046        //cout << myData1.toString() << endl;
4047    
4048        assert(myData1.getTagLookup().size()==0);
4049    
4050        assert(myData1.getLength()==1);
4051    
4052        DataArrayView myDataView = myData1.getDefaultValue();
4053        assert(!myDataView.isEmpty());
4054        assert(myDataView.getOffset()==0);
4055        assert(myDataView.getRank()==0);
4056        assert(myDataView.noValues()==1);
4057        assert(myDataView.getShape().size()==0);
4058        assert(myDataView()==1.0);
4059    
4060      }
4061    
4062      {
4063    
4064        cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
4065    
4066        DataTagged::TagListType keys;
4067    
4068        DataTagged::ValueListType values;
4069    
4070        DataArrayView::ShapeType viewShape;
4071        viewShape.push_back(3);
4072    
4073        DataArrayView::ValueType viewData1(3);
4074        for (int i=0;i<viewShape[0];i++) {
4075          viewData1[i]=i;
4076        }
4077        DataArrayView myView1(viewData1,viewShape);
4078        DataTagged myData1(keys,values,myView1,FunctionSpace());
4079    
4080        DataArrayView::ValueType viewData2(3);
4081        for (int i=0;i<viewShape[0];i++) {
4082          viewData2[i]=i+3;
4083        }
4084        DataArrayView myView2(viewData2,viewShape);
4085        DataTagged myData2(keys,values,myView2,FunctionSpace());
4086    
4087        // full slice
4088    
4089        std::pair<int, int> region_element;
4090        region_element.first=0;
4091        region_element.second=3;
4092        DataArrayView::RegionType region;
4093        region.push_back(region_element);
4094    
4095        myData1.setSlice(&myData2, region);
4096    
4097        //cout << myData1.toString() << endl;
4098    
4099        assert(myData1.getTagLookup().size()==0);
4100    
4101        assert(myData1.getLength()==3);
4102    
4103        DataArrayView myDataView = myData1.getDefaultValue();
4104        assert(!myDataView.isEmpty());
4105        assert(myDataView.getOffset()==0);
4106        assert(myDataView.getRank()==1);
4107        assert(myDataView.noValues()==3);
4108        assert(myDataView.getShape().size()==1);
4109        assert(myDataView(0)==3.0);
4110        assert(myDataView(1)==4.0);
4111        assert(myDataView(2)==5.0);
4112    
4113        // rank 1 slice
4114    
4115        viewShape.clear();
4116        viewShape.push_back(1);
4117    
4118        DataArrayView::ValueType viewData3(1);
4119        viewData3[0]=6.0;
4120        DataArrayView myView3(viewData3,viewShape);
4121        DataTagged myData3(keys,values,myView3,FunctionSpace());
4122    
4123        region.clear();
4124        region_element.first=1;
4125        region_element.second=2;
4126        region.push_back(region_element);
4127    
4128        myData1.setSlice(&myData3, region);
4129    
4130        //cout << myData1.toString() << endl;
4131    
4132        assert(myData1.getTagLookup().size()==0);
4133    
4134        assert(myData1.getLength()==3);
4135    
4136        myDataView = myData1.getDefaultValue();
4137        assert(!myDataView.isEmpty());
4138        assert(myDataView.getOffset()==0);
4139        assert(myDataView.getRank()==1);
4140        assert(myDataView.noValues()==3);
4141        assert(myDataView.getShape().size()==1);
4142        assert(myDataView(0)==3.0);
4143        assert(myDataView(1)==6.0);
4144        assert(myDataView(2)==5.0);
4145    
4146        // scalar slice
4147    
4148        region.clear();
4149        region_element.first=0;
4150        region_element.second=0;
4151        region.push_back(region_element);
4152    
4153        DataTagged myData4;
4154        myData4.getDefaultValue()()=7.0;
4155    
4156        myData1.setSlice(&myData4, region);
4157    
4158        //cout << myData3.toString() << endl;
4159    
4160        assert(myData1.getTagLookup().size()==0);
4161    
4162        assert(myData1.getLength()==3);
4163    
4164        myDataView = myData1.getDefaultValue();
4165        assert(!myDataView.isEmpty());
4166        assert(myDataView.getOffset()==0);
4167        assert(myDataView.getRank()==1);
4168        assert(myDataView.noValues()==3);
4169        assert(myDataView.getShape().size()==1);
4170        assert(myDataView(0)==7.0);
4171        assert(myDataView(1)==6.0);
4172        assert(myDataView(2)==5.0);
4173    
4174      }
4175    
4176      {
4177    
4178        cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
4179    
4180        DataTagged::TagListType keys;
4181    
4182        DataTagged::ValueListType values;
4183    
4184        DataArrayView::ShapeType viewShape;
4185        viewShape.push_back(3);
4186        viewShape.push_back(3);
4187        viewShape.push_back(3);
4188    
4189        DataArrayView::ValueType viewData1(27);
4190        for (int i=0;i<viewData1.size();i++) {
4191          viewData1[i]=i;
4192        }
4193        DataArrayView myView1(viewData1,viewShape);
4194        DataTagged myData1(keys,values,myView1,FunctionSpace());
4195    
4196        DataArrayView::ValueType viewData2(27);
4197        for (int i=0;i<viewData2.size();i++) {
4198          viewData2[i]=i+27;
4199        }
4200        DataArrayView myView2(viewData2,viewShape);
4201        DataTagged myData2(keys,values,myView2,FunctionSpace());
4202    
4203        // full slice
4204    
4205        std::pair<int, int> region_element;
4206        region_element.first=0;
4207        region_element.second=3;
4208        DataArrayView::RegionType region;
4209        region.push_back(region_element);
4210        region.push_back(region_element);
4211        region.push_back(region_element);
4212    
4213        myData1.setSlice(&myData2, region);
4214    
4215        //cout << myData1.toString() << endl;
4216    
4217        assert(myData1.getTagLookup().size()==0);
4218    
4219        assert(myData1.getLength()==27);
4220    
4221        DataArrayView myDataView = myData1.getDefaultValue();
4222        assert(!myDataView.isEmpty());
4223        assert(myDataView.getOffset()==0);
4224        assert(myDataView.getRank()==3);
4225        assert(myDataView.noValues()==27);
4226        assert(myDataView.getShape().size()==3);
4227    
4228        // rank 1 slice
4229    
4230        viewShape.clear();
4231        viewShape.push_back(3);
4232    
4233        DataArrayView::ValueType viewData3(3);
4234        for (int i=0;i<viewData3.size();i++) {
4235          viewData3[i]=i+60;
4236        }
4237        DataArrayView myView3(viewData3,viewShape);
4238        DataTagged myData3(keys,values,myView3,FunctionSpace());
4239    
4240        region.clear();
4241        region.push_back(region_element);
4242        region_element.first=0;
4243        region_element.second=0;
4244        region.push_back(region_element);
4245        region.push_back(region_element);
4246    
4247        myData1.setSlice(&myData3, region);
4248    
4249        //cout << myData1.toString() << endl;
4250    
4251        assert(myData1.getTagLookup().size()==0);
4252    
4253        assert(myData1.getLength()==27);
4254    
4255        myDataView = myData1.getDefaultValue();
4256        assert(!myDataView.isEmpty());
4257        assert(myDataView.getOffset()==0);
4258        assert(myDataView.getRank()==3);
4259        assert(myDataView.noValues()==27);
4260        assert(myDataView.getShape().size()==3);
4261        assert(myDataView(0,0,0)==60.0);
4262        assert(myDataView(1,0,0)==61.0);
4263        assert(myDataView(2,0,0)==62.0);
4264    
4265        // scalar slice
4266    
4267        region.clear();
4268        region_element.first=0;
4269        region_element.second=0;
4270        region.push_back(region_element);
4271        region.push_back(region_element);
4272        region.push_back(region_element);
4273    
4274        DataTagged myData4;
4275        myData4.getDefaultValue()()=70.0;
4276    
4277        myData1.setSlice(&myData4, region);
4278    
4279        //cout << myData1.toString() << endl;
4280    
4281        assert(myData1.getTagLookup().size()==0);
4282    
4283        assert(myData1.getLength()==27);
4284    
4285        myDataView = myData1.getDefaultValue();
4286        assert(!myDataView.isEmpty());
4287        assert(myDataView.getOffset()==0);
4288        assert(myDataView.getRank()==3);
4289        assert(myDataView.noValues()==27);
4290        assert(myDataView.getShape().size()==3);
4291        assert(myDataView(0,0,0)==70.0);
4292    
4293      }
4294    
4295      {
4296    
4297        cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
4298    
4299        DataTagged::TagListType keys;
4300        keys.push_back(1);
4301    
4302        DataTagged::ValueListType values;
4303    
4304        DataArrayView::ShapeType viewShape;
4305    
4306        // default value for Data1
4307        DataArrayView::ValueType viewData1(1);
4308        viewData1[0]=0.0;
4309        DataArrayView myView1(viewData1,viewShape);
4310    
4311        // value for tag "1" for Data1
4312        DataArrayView::ValueType viewData2(1);
4313        viewData2[0]=0.0;
4314        DataArrayView myView2(viewData2,viewShape);
4315        values.push_back(myView2);
4316    
4317        DataTagged myData1(keys,values,myView1,FunctionSpace());
4318    
4319        values.clear();
4320    
4321        // default value for Data2
4322        DataArrayView::ValueType viewData3(1);
4323        viewData3[0]=1.0;
4324        DataArrayView myView3(viewData3,viewShape);
4325    
4326        // value for tag "1" for Data2
4327        DataArrayView::ValueType viewData4(1);
4328        viewData4[0]=2.0;
4329        DataArrayView myView4(viewData4,viewShape);
4330        values.push_back(myView4);
4331    
4332        DataTagged myData2(keys,values,myView3,FunctionSpace());
4333    
4334        // full slice
4335    
4336        DataArrayView::RegionType region;
4337    
4338        myData1.setSlice(&myData2, region);
4339    
4340        //cout << myData1.toString() << endl;
4341    
4342        assert(myData1.getTagLookup().size()==1);
4343    
4344        assert(myData1.getLength()==2);
4345    
4346        DataArrayView myDataView = myData1.getDefaultValue();
4347        assert(!myDataView.isEmpty());
4348        assert(myDataView.getOffset()==0);
4349        assert(myDataView.getRank()==0);
4350        assert(myDataView.noValues()==1);
4351        assert(myDataView.getShape().size()==0);
4352        assert(myDataView()==1.0);
4353    
4354        myDataView = myData1.getDataPointByTag(1);
4355        assert(!myDataView.isEmpty());
4356        assert(myDataView.getOffset()==1);
4357        assert(myDataView.getRank()==0);
4358        assert(myDataView.noValues()==1);
4359        assert(myDataView.getShape().size()==0);
4360        assert(myDataView()==2.0);
4361    
4362      }
4363    
4364      {
4365    
4366        cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
4367    
4368        DataTagged::TagListType keys;
4369        keys.push_back(1);
4370    
4371        DataTagged::ValueListType values;
4372    
4373        DataArrayView::ShapeType viewShape;
4374        viewShape.push_back(3);
4375    
4376        // default value for Data1
4377        DataArrayView::ValueType viewData1(3);
4378        for (int i=0;i<viewData1.size();i++) {
4379          viewData1[i]=0.0;
4380        }
4381        DataArrayView myView1(viewData1,viewShape);
4382    
4383        // value for tag "1" for Data1
4384        DataArrayView::ValueType viewData2(3);
4385        for (int i=0;i<viewData2.size();i++) {
4386          viewData2[i]=0.0;
4387        }
4388        DataArrayView myView2(viewData2,viewShape);
4389        values.push_back(myView2);
4390    
4391        DataTagged myData1(keys,values,myView1,FunctionSpace());
4392    
4393        values.clear();
4394    
4395        // default value for Data2
4396        DataArrayView::ValueType viewData3(3);
4397        for (int i=0;i<viewData3.size();i++) {
4398          viewData3[i]=1.0;
4399        }
4400        DataArrayView myView3(viewData3,viewShape);
4401    
4402        // value for tag "1" for Data2
4403        DataArrayView::ValueType viewData4(3);
4404        for (int i=0;i<viewData4.size();i++) {
4405          viewData4[i]=2.0;
4406        }
4407        DataArrayView myView4(viewData4,viewShape);
4408        values.push_back(myView4);
4409    
4410        DataTagged myData2(keys,values,myView3,FunctionSpace());
4411    
4412        // full slice
4413    
4414        std::pair<int, int> region_element;
4415        region_element.first=0;
4416        region_element.second=3;
4417        DataArrayView::RegionType region;
4418        region.push_back(region_element);
4419    
4420        myData1.setSlice(&myData2, region);
4421    
4422        //cout << myData1.toString() << endl;
4423    
4424        assert(myData1.getTagLookup().size()==1);
4425    
4426        assert(myData1.getLength()==6);
4427    
4428        DataArrayView myDataView = myData1.getDefaultValue();
4429        assert(!myDataView.isEmpty());
4430        assert(myDataView.getOffset()==0);
4431        assert(myDataView.getRank()==1);
4432        assert(myDataView.noValues()==3);
4433        assert(myDataView.getShape().size()==1);
4434        assert(myDataView(0)==1.0);
4435        assert(myDataView(1)==1.0);
4436        assert(myDataView(2)==1.0);
4437    
4438        myDataView = myData1.getDataPointByTag(1);
4439        assert(!myDataView.isEmpty());
4440        assert(myDataView.getOffset()==3);
4441        assert(myDataView.getRank()==1);
4442        assert(myDataView.noValues()==3);
4443        assert(myDataView.getShape().size()==1);
4444        assert(myDataView(0)==2.0);
4445        assert(myDataView(1)==2.0);
4446        assert(myDataView(2)==2.0);
4447    
4448        // rank 1 slice
4449    
4450        viewShape.clear();
4451        viewShape.push_back(1);
4452    
4453        DataArrayView::ValueType viewData5(1);
4454        viewData5[0]=3.0;
4455        DataArrayView myView5(viewData5,viewShape);
4456    
4457        values.clear();
4458    
4459        DataArrayView::ValueType viewData6(1);
4460        viewData6[0]=4.0;
4461        DataArrayView myView6(viewData6,viewShape);
4462        values.push_back(myView6);
4463    
4464        DataTagged myData3(keys,values,myView5,FunctionSpace());
4465    
4466        region.clear();
4467        region_element.first=1;
4468        region_element.second=2;
4469        region.push_back(region_element);
4470    
4471        myData1.setSlice(&myData3, region);
4472    
4473        //cout << myData1.toString() << endl;
4474    
4475        assert(myData1.getTagLookup().size()==1);
4476    
4477        assert(myData1.getLength()==6);
4478    
4479        myDataView = myData1.getDefaultValue();
4480        assert(!myDataView.isEmpty());
4481        assert(myDataView.getOffset()==0);
4482        assert(myDataView.getRank()==1);
4483        assert(myDataView.noValues()==3);
4484        assert(myDataView.getShape().size()==1);
4485        assert(myDataView(0)==1.0);
4486        assert(myDataView(1)==3.0);
4487        assert(myDataView(2)==1.0);
4488    
4489        myDataView = myData1.getDataPointByTag(1);
4490        assert(!myDataView.isEmpty());
4491        assert(myDataView.getOffset()==3);
4492        assert(myDataView.getRank()==1);
4493        assert(myDataView.noValues()==3);
4494        assert(myDataView.getShape().size()==1);
4495        assert(myDataView(0)==2.0);
4496        assert(myDataView(1)==4.0);
4497        assert(myDataView(2)==2.0);
4498    
4499        // scalar slice
4500    
4501        viewShape.clear();
4502    
4503        DataArrayView::ValueType viewData7(1);
4504        viewData7[0]=5.0;
4505        DataArrayView myView7(viewData7,viewShape);
4506    
4507        values.clear();
4508    
4509        DataArrayView::ValueType viewData8(1);
4510        viewData8[0]=6.0;
4511        DataArrayView myView8(viewData8,viewShape);
4512        values.push_back(myView8);
4513    
4514        DataTagged myData4(keys,values,myView7,FunctionSpace());
4515    
4516        region.clear();
4517        region_element.first=0;
4518        region_element.second=0;
4519        region.push_back(region_element);
4520    
4521        myData1.setSlice(&myData4, region);
4522    
4523        //cout << myData1.toString() << endl;
4524    
4525        myDataView = myData1.getDefaultValue();
4526        assert(!myDataView.isEmpty());
4527        assert(myDataView.getOffset()==0);
4528        assert(myDataView.getRank()==1);
4529        assert(myDataView.noValues()==3);
4530        assert(myDataView.getShape().size()==1);
4531        assert(myDataView(0)==5.0);
4532        assert(myDataView(1)==3.0);
4533        assert(myDataView(2)==1.0);
4534    
4535        myDataView = myData1.getDataPointByTag(1);
4536        assert(!myDataView.isEmpty());
4537        assert(myDataView.getOffset()==3);
4538        assert(myDataView.getRank()==1);
4539        assert(myDataView.noValues()==3);
4540        assert(myDataView.getShape().size()==1);
4541        assert(myDataView(0)==6.0);
4542        assert(myDataView(1)==4.0);
4543        assert(myDataView(2)==2.0);
4544    
4545      }
4546    
4547      {
4548    
4549        cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
4550    
4551        DataTagged::TagListType keys;
4552        keys.push_back(1);
4553    
4554        DataTagged::ValueListType values;
4555    
4556        DataArrayView::ShapeType viewShape;
4557        viewShape.push_back(3);
4558        viewShape.push_back(3);
4559        viewShape.push_back(3);
4560    
4561        // default value for Data1
4562        DataArrayView::ValueType viewData1(27);
4563        for (int i=0;i<viewData1.size();i++) {
4564          viewData1[i]=0.0;
4565        }
4566        DataArrayView myView1(viewData1,viewShape);
4567    
4568        // value for tag "1" for Data1
4569        DataArrayView::ValueType viewData2(27);
4570        for (int i=0;i<viewData2.size();i++) {
4571          viewData2[i]=0.0;
4572        }
4573        DataArrayView myView2(viewData2,viewShape);
4574        values.push_back(myView2);
4575    
4576        DataTagged myData1(keys,values,myView1,FunctionSpace());
4577    
4578        values.clear();
4579    
4580        // default value for Data2
4581        DataArrayView::ValueType viewData3(27);
4582        for (int i=0;i<viewData3.size();i++) {
4583          viewData3[i]=1.0;
4584        }
4585        DataArrayView myView3(viewData3,viewShape);
4586    
4587        // value for tag "1" for Data2
4588        DataArrayView::ValueType viewData4(27);
4589        for (int i=0;i<viewData4.size();i++) {
4590          viewData4[i]=2.0;
4591        }
4592        DataArrayView myView4(viewData4,viewShape);
4593        values.push_back(myView4);
4594    
4595        DataTagged myData2(keys,values,myView3,FunctionSpace());
4596    
4597        // full slice
4598    
4599        std::pair<int, int> region_element;
4600        region_element.first=0;
4601        region_element.second=3;
4602        DataArrayView::RegionType region;
4603        region.push_back(region_element);
4604        region.push_back(region_element);
4605        region.push_back(region_element);
4606    
4607        myData1.setSlice(&myData2, region);
4608    
4609        //cout << myData1.toString() << endl;
4610    
4611        assert(myData1.getTagLookup().size()==1);
4612    
4613        assert(myData1.getLength()==54);
4614    
4615        DataArrayView myDataView = myData1.getDefaultValue();
4616        assert(!myDataView.isEmpty());
4617        assert(myDataView.getOffset()==0);
4618        assert(myDataView.getRank()==3);
4619        assert(myDataView.noValues()==27);
4620        assert(myDataView.getShape().size()==3);
4621        assert(myDataView(0,0,0)==1.0);
4622        assert(myDataView(1,1,1)==1.0);
4623        assert(myDataView(2,2,2)==1.0);
4624    
4625        myDataView = myData1.getDataPointByTag(1);
4626        assert(!myDataView.isEmpty());
4627        assert(myDataView.getOffset()==27);
4628        assert(myDataView.getRank()==3);
4629        assert(myDataView.noValues()==27);
4630        assert(myDataView.getShape().size()==3);
4631        assert(myDataView(0,0,0)==2.0);
4632        assert(myDataView(1,1,1)==2.0);
4633        assert(myDataView(2,2,2)==2.0);
4634    
4635        // rank 1 slice
4636    
4637        viewShape.clear();
4638        viewShape.push_back(3);
4639    
4640        DataArrayView::ValueType viewData5(3);
4641        for (int i=0;i<viewData5.size();i++) {
4642          viewData5[i]=3.0;
4643        }
4644        DataArrayView myView5(viewData5,viewShape);
4645    
4646        values.clear();
4647    
4648        DataArrayView::ValueType viewData6(3);
4649        for (int i=0;i<viewData6.size();i++) {
4650          viewData6[i]=4.0;
4651        }
4652        DataArrayView myView6(viewData6,viewShape);
4653        values.push_back(myView6);
4654    
4655        DataTagged myData3(keys,values,myView5,FunctionSpace());
4656    
4657        region.clear();
4658        region.push_back(region_element);
4659        region_element.first=0;
4660        region_element.second=0;
4661        region.push_back(region_element);
4662        region.push_back(region_element);
4663    
4664        myData1.setSlice(&myData3, region);
4665    
4666        //cout << myData1.toString() << endl;
4667    
4668        assert(myData1.getTagLookup().size()==1);
4669    
4670        assert(myData1.getLength()==54);
4671    
4672        myDataView = myData1.getDefaultValue();
4673        assert(!myDataView.isEmpty());
4674        assert(myDataView.getOffset()==0);
4675        assert(myDataView.getRank()==3);
4676        assert(myDataView.noValues()==27);
4677        assert(myDataView.getShape().size()==3);
4678        assert(myDataView(0,0,0)==3.0);
4679        assert(myDataView(1,0,0)==3.0);
4680        assert(myDataView(2,0,0)==3.0);
4681    
4682        myDataView = myData1.getDataPointByTag(1);
4683        assert(!myDataView.isEmpty());
4684        assert(myDataView.getOffset()==27);
4685        assert(myDataView.getRank()==3);
4686        assert(myDataView.noValues()==27);
4687        assert(myDataView.getShape().size()==3);
4688        assert(myDataView(0,0,0)==4.0);
4689        assert(myDataView(1,0,0)==4.0);
4690        assert(myDataView(2,0,0)==4.0);
4691    
4692        // scalar slice
4693    
4694        viewShape.clear();
4695    
4696        DataArrayView::ValueType viewData7(1);
4697        viewData7[0]=5.0;
4698        DataArrayView myView7(viewData7,viewShape);
4699    
4700        values.clear();
4701    
4702        DataArrayView::ValueType viewData8(1);
4703        viewData8[0]=6.0;
4704        DataArrayView myView8(viewData8,viewShape);
4705        values.push_back(myView8);
4706    
4707        DataTagged myData4(keys,values,myView7,FunctionSpace());
4708    
4709        region.clear();
4710        region_element.first=0;
4711        region_element.second=0;
4712        region.push_back(region_element);
4713        region.push_back(region_element);
4714        region.push_back(region_element);
4715    
4716        myData1.setSlice(&myData4, region);
4717    
4718        //cout << myData1.toString() << endl;
4719    
4720        myDataView = myData1.getDefaultValue();
4721        assert(!myDataView.isEmpty());
4722        assert(myDataView.getOffset()==0);
4723        assert(myDataView.getRank()==3);
4724        assert(myDataView.noValues()==27);
4725        assert(myDataView.getShape().size()==3);
4726        assert(myDataView(0,0,0)==5.0);
4727    
4728        myDataView = myData1.getDataPointByTag(1);
4729        assert(!myDataView.isEmpty());
4730        assert(myDataView.getOffset()==27);
4731        assert(myDataView.getRank()==3);
4732        assert(myDataView.noValues()==27);
4733        assert(myDataView.getShape().size()==3);
4734        assert(myDataView(0,0,0)==6.0);
4735    
4736      }
4737    
4738      {
4739    
4740        cout << "\tTest slicing DataTagged with scalar values and three tags." << endl;
4741    
4742        DataTagged::TagListType keys;
4743        keys.push_back(1);
4744        keys.push_back(2);
4745        keys.push_back(3);
4746    
4747        DataTagged::ValueListType values;
4748    
4749        DataArrayView::ShapeType viewShape;
4750    
4751        // default value for Data1
4752        DataArrayView::ValueType viewData1(1);
4753        viewData1[0]=0.0;
4754        DataArrayView myView1(viewData1,viewShape);
4755    
4756        // value for tag "1" for Data1
4757        DataArrayView::ValueType viewData2(1);
4758        viewData2[0]=0.0;
4759        DataArrayView myView2(viewData2,viewShape);
4760        values.push_back(myView2);
4761    
4762        // value for tag "2" for Data1
4763        DataArrayView::ValueType viewData5(1);
4764        viewData5[0]=0.0;
4765        DataArrayView myView5(viewData5,viewShape);
4766        values.push_back(myView5);
4767    
4768        // value for tag "3" for Data1
4769        DataArrayView::ValueType viewData6(1);
4770        viewData6[0]=0.0;
4771        DataArrayView myView6(viewData6,viewShape);
4772        values.push_back(myView6);
4773    
4774        DataTagged myData1(keys,values,myView1,FunctionSpace());
4775    
4776        values.clear();
4777    
4778        // default value for Data2
4779        DataArrayView::ValueType viewData3(1);
4780        viewData3[0]=1.0;
4781        DataArrayView myView3(viewData3,viewShape);
4782    
4783        // value for tag "1" for Data2
4784        DataArrayView::ValueType viewData4(1);
4785        viewData4[0]=2.0;
4786        DataArrayView myView4(viewData4,viewShape);
4787        values.push_back(myView4);
4788    
4789        // value for tag "2" for Data2
4790        DataArrayView::ValueType viewData7(1);
4791        viewData7[0]=3.0;
4792        DataArrayView myView7(viewData7,viewShape);
4793        values.push_back(myView7);
4794    
4795        // value for tag "3" for Data2
4796        DataArrayView::ValueType viewData8(1);
4797        viewData8[0]=4.0;
4798        DataArrayView myView8(viewData8,viewShape);
4799        values.push_back(myView8);
4800    
4801        DataTagged myData2(keys,values,myView3,FunctionSpace());
4802    
4803        // full slice
4804    
4805        DataArrayView::RegionType region;
4806    
4807        myData1.setSlice(&myData2, region);
4808    
4809        //cout << myData1.toString() << endl;
4810    
4811        assert(myData1.getTagLookup().size()==3);
4812    
4813        assert(myData1.getLength()==4);
4814    
4815        DataArrayView myDataView = myData1.getDefaultValue();
4816        assert(!myDataView.isEmpty());
4817        assert(myDataView.getOffset()==0);
4818        assert(myDataView.getRank()==0);
4819        assert(myDataView.noValues()==1);
4820        assert(myDataView.getShape().size()==0);
4821        assert(myDataView()==1.0);
4822    
4823        myDataView = myData1.getDataPointByTag(1);
4824        assert(!myDataView.isEmpty());
4825        assert(myDataView.getOffset()==1);
4826        assert(myDataView.getRank()==0);
4827        assert(myDataView.noValues()==1);
4828        assert(myDataView.getShape().size()==0);
4829        assert(myDataView()==2.0);
4830    
4831        myDataView = myData1.getDataPointByTag(2);
4832        assert(!myDataView.isEmpty());
4833        assert(myDataView.getOffset()==2);
4834        assert(myDataView.getRank()==0);
4835        assert(myDataView.noValues()==1);
4836        assert(myDataView.getShape().size()==0);
4837        assert(myDataView()==3.0);
4838    
4839        myDataView = myData1.getDataPointByTag(3);
4840        assert(!myDataView.isEmpty());
4841        assert(myDataView.getOffset()==3);
4842        assert(myDataView.getRank()==0);
4843        assert(myDataView.noValues()==1);
4844        assert(myDataView.getShape().size()==0);
4845        assert(myDataView()==4.0);
4846    
4847      }
4848    
4849      {
4850    
4851        cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;
4852    
4853        DataTagged::TagListType keys;
4854        keys.push_back(1);
4855        keys.push_back(2);
4856        keys.push_back(3);
4857    
4858        DataTagged::ValueListType values;
4859    
4860        DataArrayView::ShapeType viewShape;
4861        viewShape.push_back(3);
4862    
4863        // default value for Data1
4864        DataArrayView::ValueType viewData1(3);
4865        for (int i=0;i<viewData1.size();i++) {
4866          viewData1[i]=0.0;
4867        }
4868        DataArrayView myView1(viewData1,viewShape);
4869    
4870        // value for tag "1" for Data1
4871        DataArrayView::ValueType viewData2(3);
4872        for (int i=0;i<viewData2.size();i++) {
4873          viewData2[i]=0.0;
4874        }
4875        DataArrayView myView2(viewData2,viewShape);
4876        values.push_back(myView2);
4877    
4878        // value for tag "2" for Data1
4879        DataArrayView::ValueType viewData3(3);
4880        for (int i=0;i<viewData3.size();i++) {
4881          viewData3[i]=0.0;
4882        }
4883        DataArrayView myView3(viewData3,viewShape);
4884        values.push_back(myView3);
4885    
4886        // value for tag "3" for Data1
4887        DataArrayView::ValueType viewData4(3);
4888        for (int i=0;i<viewData4.size();i++) {
4889          viewData4[i]=0.0;
4890        }
4891        DataArrayView myView4(viewData4,viewShape);
4892        values.push_back(myView4);
4893    
4894        DataTagged myData1(keys,values,myView1,FunctionSpace());
4895    
4896        values.clear();
4897    
4898        // default value for Data2
4899        DataArrayView::ValueType viewData5(3);
4900        for (int i=0;i<viewData5.size();i++) {
4901          viewData5[i]=1.0;
4902        }
4903        DataArrayView myView5(viewData5,viewShape);
4904    
4905        // value for tag "1" for Data2
4906        DataArrayView::ValueType viewData6(3);
4907        for (int i=0;i<viewData6.size();i++) {
4908          viewData6[i]=2.0;
4909        }
4910        DataArrayView myView6(viewData6,viewShape);
4911        values.push_back(myView6);
4912    
4913        // value for tag "2" for Data2
4914        DataArrayView::ValueType viewData7(3);
4915        for (int i=0;i<viewData7.size();i++) {
4916          viewData7[i]=3.0;
4917        }
4918        DataArrayView myView7(viewData7,viewShape);
4919        values.push_back(myView7);
4920    
4921        // value for tag "3" for Data2
4922        DataArrayView::ValueType viewData8(3);
4923        for (int i=0;i<viewData8.size();i++) {
4924          viewData8[i]=4.0;
4925        }
4926        DataArrayView myView8(viewData8,viewShape);
4927        values.push_back(myView8);
4928    
4929        DataTagged myData2(keys,values,myView5,FunctionSpace());
4930    
4931        // full slice
4932    
4933        std::pair<int, int> region_element;
4934        region_element.first=0;
4935        region_element.second=3;
4936        DataArrayView::RegionType region;
4937        region.push_back(region_element);
4938    
4939        myData1.setSlice(&myData2, region);
4940    
4941        //cout << myData1.toString() << endl;
4942    
4943        assert(myData1.getTagLookup().size()==3);
4944    
4945        assert(myData1.getLength()==12);
4946    
4947        DataArrayView myDataView = myData1.getDefaultValue();
4948        assert(!myDataView.isEmpty());
4949        assert(myDataView.getOffset()==0);
4950        assert(myDataView.getRank()==1);
4951        assert(myDataView.noValues()==3);
4952        assert(myDataView.getShape().size()==1);
4953        assert(myDataView(0)==1.0);
4954        assert(myDataView(1)==1.0);
4955        assert(myDataView(2)==1.0);
4956    
4957        myDataView = myData1.getDataPointByTag(1);
4958        assert(!myDataView.isEmpty());
4959        assert(myDataView.getOffset()==3);
4960        assert(myDataView.getRank()==1);
4961        assert(myDataView.noValues()==3);
4962        assert(myDataView.getShape().size()==1);
4963        assert(myDataView(0)==2.0);
4964        assert(myDataView(1)==2.0);
4965        assert(myDataView(2)==2.0);
4966    
4967        myDataView = myData1.getDataPointByTag(2);
4968        assert(!myDataView.isEmpty());
4969        assert(myDataView.getOffset()==6);
4970        assert(myDataView.getRank()==1);
4971        assert(myDataView.noValues()==3);
4972        assert(myDataView.getShape().size()==1);
4973        assert(myDataView(0)==3.0);
4974        assert(myDataView(1)==3.0);
4975        assert(myDataView(2)==3.0);
4976    
4977        myDataView = myData1.getDataPointByTag(3);
4978        assert(!myDataView.isEmpty());
4979        assert(myDataView.getOffset()==9);
4980        assert(myDataView.getRank()==1);
4981        assert(myDataView.noValues()==3);
4982        assert(myDataView.getShape().size()==1);
4983        assert(myDataView(0)==4.0);
4984        assert(myDataView(1)==4.0);
4985        assert(myDataView(2)==4.0);
4986    
4987        // rank 1 slice
4988    
4989        viewShape.clear();
4990        viewShape.push_back(1);
4991    
4992        DataArrayView::ValueType viewData9(1);
4993        viewData9[0]=6.0;
4994        DataArrayView myView9(viewData9,viewShape);
4995    
4996        values.clear();
4997    
4998        DataArrayView::ValueType viewData10(1);
4999        viewData10[0]=7.0;
5000        DataArrayView myView10(viewData10,viewShape);
5001        values.push_back(myView10);
5002    
5003        DataArrayView::ValueType viewData11(1);
5004        viewData11[0]=8.0;
5005        DataArrayView myView11(viewData11,viewShape);
5006        values.push_back(myView11);
5007    
5008        DataArrayView::ValueType viewData12(1);
5009        viewData12[0]=9.0;
5010        DataArrayView myView12(viewData12,viewShape);
5011        values.push_back(myView12);
5012    
5013        DataTagged myData3(keys,values,myView9,FunctionSpace());
5014    
5015        region.clear();
5016        region_element.first=1;
5017        region_element.second=2;
5018        region.push_back(region_element);
5019    
5020        myData1.setSlice(&myData3, region);
5021    
5022        //cout << myData1.toString() << endl;
5023    
5024        assert(myData1.getTagLookup().size()==3);
5025    
5026        assert(myData1.getLength()==12);
5027    
5028        myDataView = myData1.getDefaultValue();
5029        assert(!myDataView.isEmpty());
5030        assert(myDataView.getOffset()==0);
5031        assert(myDataView.getRank()==1);
5032        assert(myDataView.noValues()==3);
5033        assert(myDataView.getShape().size()==1);
5034        assert(myDataView(0)==1.0);
5035        assert(myDataView(1)==6.0);
5036        assert(myDataView(2)==1.0);
5037    
5038        myDataView = myData1.getDataPointByTag(1);
5039        assert(!myDataView.isEmpty());
5040        assert(myDataView.getOffset()==3);
5041        assert(myDataView.getRank()==1);
5042        assert(myDataView.noValues()==3);
5043        assert(myDataView.getShape().size()==1);
5044        assert(myDataView(0)==2.0);
5045        assert(myDataView(1)==7.0);
5046        assert(myDataView(2)==2.0);
5047    
5048        myDataView = myData1.getDataPointByTag(2);
5049        assert(!myDataView.isEmpty());
5050        assert(myDataView.getOffset()==6);
5051        assert(myDataView.getRank()==1);
5052        assert(myDataView.noValues()==3);
5053        assert(myDataView.getShape().size()==1);
5054        assert(myDataView(0)==3.0);
5055        assert(myDataView(1)==8.0);
5056        assert(myDataView(2)==3.0);
5057    
5058        myDataView = myData1.getDataPointByTag(3);
5059        assert(!myDataView.isEmpty());
5060        assert(myDataView.getOffset()==9);
5061        assert(myDataView.getRank()==1);
5062        assert(myDataView.noValues()==3);
5063        assert(myDataView.getShape().size()==1);
5064        assert(myDataView(0)==4.0);
5065        assert(myDataView(1)==9.0);
5066        assert(myDataView(2)==4.0);
5067    
5068        // scalar slice
5069    
5070        viewShape.clear();
5071    
5072        DataArrayView::ValueType viewData13(1);
5073        viewData13[0]=10.0;
5074        DataArrayView myView13(viewData13,viewShape);
5075    
5076        values.clear();
5077    
5078        DataArrayView::ValueType viewData14(1);
5079        viewData14[0]=11.0;
5080        DataArrayView myView14(viewData14,viewShape);
5081        values.push_back(myView14);
5082    
5083        DataArrayView::ValueType viewData15(2);
5084        viewData15[0]=12.0;
5085        DataArrayView myView15(viewData15,viewShape);
5086        values.push_back(myView15);
5087    
5088        DataArrayView::ValueType viewData16(3);
5089        viewData16[0]=13.0;
5090        DataArrayView myView16(viewData16,viewShape);
5091        values.push_back(myView16);
5092    
5093        DataTagged myData4(keys,values,myView13,FunctionSpace());
5094    
5095        region.clear();
5096        region_element.first=0;
5097        region_element.second=0;
5098        region.push_back(region_element);
5099    
5100        myData1.setSlice(&myData4, region);
5101    
5102        //cout << myData1.toString() << endl;
5103    
5104        myDataView = myData1.getDefaultValue();
5105        assert(!myDataView.isEmpty());
5106        assert(myDataView.getOffset()==0);
5107        assert(myDataView.getRank()==1);
5108        assert(myDataView.noValues()==3);
5109        assert(myDataView.getShape().size()==1);
5110        assert(myDataView(0)==10.0);
5111        assert(myDataView(1)==6.0);
5112        assert(myDataView(2)==1.0);
5113    
5114        myDataView = myData1.getDataPointByTag(1);
5115        assert(!myDataView.isEmpty());
5116        assert(myDataView.getOffset()==3);
5117        assert(myDataView.getRank()==1);
5118        assert(myDataView.noValues()==3);
5119        assert(myDataView.getShape().size()==1);
5120        assert(myDataView(0)==11.0);
5121        assert(myDataView(1)==7.0);
5122        assert(myDataView(2)==2.0);
5123    
5124        myDataView = myData1.getDataPointByTag(2);
5125        assert(!myDataView.isEmpty());
5126        assert(myDataView.getOffset()==6);
5127        assert(myDataView.getRank()==1);
5128        assert(myDataView.noValues()==3);
5129        assert(myDataView.getShape().size()==1);
5130        assert(myDataView(0)==12.0);
5131        assert(myDataView(1)==8.0);
5132        assert(myDataView(2)==3.0);
5133    
5134        myDataView = myData1.getDataPointByTag(3);
5135        assert(!myDataView.isEmpty());
5136        assert(myDataView.getOffset()==9);
5137        assert(myDataView.getRank()==1);
5138        assert(myDataView.noValues()==3);
5139        assert(myDataView.getShape().size()==1);
5140        assert(myDataView(0)==13.0);
5141        assert(myDataView(1)==9.0);
5142        assert(myDataView(2)==4.0);
5143    
5144      }
5145    
5146      {
5147    
5148        cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl;
5149    
5150        DataTagged::TagListType keys;
5151        keys.push_back(1);
5152        keys.push_back(2);
5153        keys.push_back(3);
5154    
5155        DataTagged::ValueListType values;
5156    
5157        DataArrayView::ShapeType viewShape;
5158        viewShape.push_back(3);
5159        viewShape.push_back(3);
5160        viewShape.push_back(3);
5161    
5162        // default value for Data1
5163        DataArrayView::ValueType viewData1(27);
5164        for (int i=0;i<viewData1.size();i++) {
5165          viewData1[i]=0.0;
5166        }
5167        DataArrayView myView1(viewData1,viewShape);
5168    
5169        // value for tag "1" for Data1
5170        DataArrayView::ValueType viewData2(27);
5171        for (int i=0;i<viewData2.size();i++) {
5172          viewData2[i]=0.0;
5173        }
5174        DataArrayView myView2(viewData2,viewShape);
5175        values.push_back(myView2);
5176    
5177        // value for tag "2" for Data1
5178        DataArrayView::ValueType viewData3(27);
5179        for (int i=0;i<viewData3.size();i++) {
5180          viewData3[i]=0.0;
5181        }
5182        DataArrayView myView3(viewData3,viewShape);
5183        values.push_back(myView3);
5184    
5185        // value for tag "3" for Data1
5186        DataArrayView::ValueType viewData4(27);
5187        for (int i=0;i<viewData4.size();i++) {
5188          viewData4[i]=0.0;
5189        }
5190        DataArrayView myView4(viewData4,viewShape);
5191        values.push_back(myView4);
5192    
5193        DataTagged myData1(keys,values,myView1,FunctionSpace());
5194    
5195        values.clear();
5196    
5197        // default value for Data2
5198        DataArrayView::ValueType viewData5(27);
5199        for (int i=0;i<viewData5.size();i++) {
5200          viewData5[i]=1.0;
5201        }
5202        DataArrayView myView5(viewData5,viewShape);
5203    
5204        // value for tag "1" for Data2
5205        DataArrayView::ValueType viewData6(27);
5206        for (int i=0;i<viewData6.size();i++) {
5207          viewData6[i]=2.0;
5208        }
5209        DataArrayView myView6(viewData6,viewShape);
5210        values.push_back(myView6);
5211    
5212        // value for tag "2" for Data2
5213        DataArrayView::ValueType viewData7(27);
5214        for (int i=0;i<viewData7.size();i++) {
5215          viewData7[i]=3.0;
5216        }
5217        DataArrayView myView7(viewData7,viewShape);
5218        values.push_back(myView7);
5219    
5220        // value for tag "3" for Data2
5221        DataArrayView::ValueType viewData8(27);
5222        for (int i=0;i<viewData8.size();i++) {
5223          viewData8[i]=4.0;
5224        }
5225        DataArrayView myView8(viewData8,viewShape);
5226        values.push_back(myView8);
5227    
5228        DataTagged myData2(keys,values,myView5,FunctionSpace());
5229    
5230        // full slice
5231    
5232        std::pair<int, int> region_element;
5233        region_element.first=0;
5234        region_element.second=3;
5235        DataArrayView::RegionType region;
5236        region.push_back(region_element);
5237        region.push_back(region_element);
5238        region.push_back(region_element);
5239    
5240        myData1.setSlice(&myData2, region);
5241    
5242        //cout << myData1.toString() << endl;
5243    
5244        assert(myData1.getTagLookup().size()==3);
5245    
5246        assert(myData1.getLength()==108);
5247    
5248        DataArrayView myDataView = myData1.getDefaultValue();
5249        assert(!myDataView.isEmpty());
5250        assert(myDataView.getOffset()==0);
5251        assert(myDataView.getRank()==3);
5252        assert(myDataView.noValues()==27);
5253        assert(myDataView.getShape().size()==3);
5254        assert(myDataView(0,0,0)==1.0);
5255        assert(myDataView(1,0,0)==1.0);
5256        assert(myDataView(2,0,0)==1.0);
5257    
5258        myDataView = myData1.getDataPointByTag(1);
5259        assert(!myDataView.isEmpty());
5260        assert(myDataView.getOffset()==27);
5261        assert(myDataView.getRank()==3);
5262        assert(myDataView.noValues()==27);
5263        assert(myDataView.getShape().size()==3);
5264        assert(myDataView(0,0,0)==2.0);
5265        assert(myDataView(1,0,0)==2.0);
5266        assert(myDataView(2,0,0)==2.0);
5267    
5268        myDataView = myData1.getDataPointByTag(2);
5269        assert(!myDataView.isEmpty());
5270        assert(myDataView.getOffset()==54);
5271        assert(myDataView.getRank()==3);
5272        assert(myDataView.noValues()==27);
5273        assert(myDataView.getShape().size()==3);
5274        assert(myDataView(0,0,0)==3.0);
5275        assert(myDataView(1,0,0)==3.0);
5276        assert(myDataView(2,0,0)==3.0);
5277    
5278        myDataView = myData1.getDataPointByTag(3);
5279        assert(!myDataView.isEmpty());
5280        assert(myDataView.getOffset()==81);
5281        assert(myDataView.getRank()==3);
5282        assert(myDataView.noValues()==27);
5283        assert(myDataView.getShape().size()==3);
5284        assert(myDataView(0,0,0)==4.0);
5285        assert(myDataView(1,0,0)==4.0);
5286        assert(myDataView(2,0,0)==4.0);
5287    
5288        // rank 1 slice
5289    
5290        viewShape.clear();
5291        viewShape.push_back(3);
5292    
5293        DataArrayView::ValueType viewData9(3);
5294        for (int i=0;i<viewData9.size();i++) {
5295          viewData9[i]=6.0;
5296        }
5297        DataArrayView myView9(viewData9,viewShape);
5298    
5299        values.clear();
5300    
5301        DataArrayView::ValueType viewData10(3);
5302        for (int i=0;i<viewData10.size();i++) {
5303          viewData10[i]=7.0;
5304        }
5305        DataArrayView myView10(viewData10,viewShape);
5306        values.push_back(myView10);
5307    
5308        DataArrayView::ValueType viewData11(3);
5309        for (int i=0;i<viewData11.size();i++) {
5310          viewData11[i]=8.0;
5311        }
5312        DataArrayView myView11(viewData11,viewShape);
5313        values.push_back(myView11);
5314    
5315        DataArrayView::ValueType viewData12(3);
5316        for (int i=0;i<viewData12.size();i++) {
5317          viewData12[i]=9.0;
5318        }
5319        DataArrayView myView12(viewData12,viewShape);
5320        values.push_back(myView12);
5321    
5322        DataTagged myData3(keys,values,myView9,FunctionSpace());
5323    
5324        region.clear();
5325        region_element.first=0;
5326        region_element.second=3;
5327        region.push_back(region_element);
5328        region_element.second=0;
5329        region.push_back(region_element);
5330        region.push_back(region_element);
5331    
5332        myData1.setSlice(&myData3, region);
5333    
5334        //cout << myData1.toString() << endl;
5335    
5336        assert(myData1.getTagLookup().size()==3);
5337    
5338        assert(myData1.getLength()==108);
5339    
5340        myDataView = myData1.getDefaultValue();
5341        assert(!myDataView.isEmpty());
5342        assert(myDataView.getOffset()==0);
5343        assert(myDataView.getRank()==3);
5344        assert(myDataView.noValues()==27);
5345        assert(myDataView.getShape().size()==3);
5346        assert(myDataView(0,0,0)==6.0);
5347        assert(myDataView(1,0,0)==6.0);
5348        assert(myDataView(2,0,0)==6.0);
5349    
5350        myDataView = myData1.getDataPointByTag(1);
5351        assert(!myDataView.isEmpty());
5352        assert(myDataView.getOffset()==27);
5353        assert(myDataView.getRank()==3);
5354        assert(myDataView.noValues()==27);
5355        assert(myDataView.getShape().size()==3);
5356        assert(myDataView(0,0,0)==7.0);
5357        assert(myDataView(1,0,0)==7.0);
5358        assert(myDataView(2,0,0)==7.0);
5359    
5360        myDataView = myData1.getDataPointByTag(2);
5361        assert(!myDataView.isEmpty());
5362        assert(myDataView.getOffset()==54);
5363        assert(myDataView.getRank()==3);
5364        assert(myDataView.noValues()==27);
5365        assert(myDataView.getShape().size()==3);
5366        assert(myDataView(0,0,0)==8.0);
5367        assert(myDataView(1,0,0)==8.0);
5368        assert(myDataView(2,0,0)==8.0);
5369    
5370        myDataView = myData1.getDataPointByTag(3);
5371        assert(!myDataView.isEmpty());
5372        assert(myDataView.getOffset()==81);
5373        assert(myDataView.getRank()==3);
5374        assert(myDataView.noValues()==27);
5375        assert(myDataView.getShape().size()==3);
5376        assert(myDataView(0,0,0)==9.0);
5377        assert(myDataView(1,0,0)==9.0);
5378        assert(myDataView(2,0,0)==9.0);
5379    
5380        // scalar slice
5381    
5382        viewShape.clear();
5383    
5384        DataArrayView::ValueType viewData13(1);
5385        viewData13[0]=10.0;
5386        DataArrayView myView13(viewData13,viewShape);
5387    
5388        values.clear();
5389    
5390        DataArrayView::ValueType viewData14(1);
5391        viewData14[0]=11.0;
5392        DataArrayView myView14(viewData14,viewShape);
5393        values.push_back(myView14);
5394    
5395        DataArrayView::ValueType viewData15(2);
5396        viewData15[0]=12.0;
5397        DataArrayView myView15(viewData15,viewShape);
5398        values.push_back(myView15);
5399    
5400        DataArrayView::ValueType viewData16(3);
5401        viewData16[0]=13.0;
5402        DataArrayView myView16(viewData16,viewShape);
5403        values.push_back(myView16);
5404    
5405        DataTagged myData4(keys,values,myView13,FunctionSpace());
5406    
5407        region.clear();
5408        region_element.first=0;
5409        region_element.second=0;
5410        region.push_back(region_element);
5411        region.push_back(region_element);
5412        region.push_back(region_element);
5413    
5414        myData1.setSlice(&myData4, region);
5415    
5416        //cout << myData1.toString() << endl;
5417    
5418        myDataView = myData1.getDefaultValue();
5419        assert(!myDataView.isEmpty());
5420        assert(myDataView.getOffset()==0);
5421        assert(myDataView.getRank()==3);
5422        assert(myDataView.noValues()==27);
5423        assert(myDataView.getShape().size()==3);
5424        assert(myDataView(0,0,0)==10.0);
5425    
5426        myDataView = myData1.getDataPointByTag(1);
5427        assert(!myDataView.isEmpty());
5428        assert(myDataView.getOffset()==27);
5429        assert(myDataView.getRank()==3);
5430        assert(myDataView.noValues()==27);
5431        assert(myDataView.getShape().size()==3);
5432        assert(myDataView(0,0,0)==11.0);
5433    
5434        myDataView = myData1.getDataPointByTag(2);
5435        assert(!myDataView.isEmpty());
5436        assert(myDataView.getOffset()==54);
5437        assert(myDataView.getRank()==3);
5438        assert(myDataView.noValues()==27);
5439        assert(myDataView.getShape().size()==3);
5440        assert(myDataView(0,0,0)==12.0);
5441    
5442        myDataView = myData1.getDataPointByTag(3);
5443        assert(!myDataView.isEmpty());
5444        assert(myDataView.getOffset()==81);
5445        assert(myDataView.getRank()==3);
5446        assert(myDataView.noValues()==27);
5447        assert(myDataView.getShape().size()==3);
5448        assert(myDataView(0,0,0)==13.0);
5449    
5450      }
5451    
5452      {
5453    
5454        cout << "\tTest slicing DataTagged with scalar values and three *mismatched* tags." << endl;
5455    
5456        DataTagged::TagListType keys1;
5457        keys1.push_back(1);
5458        keys1.push_back(2);
5459        keys1.push_back(3);
5460    
5461        DataTagged::TagListType keys2;
5462        keys2.push_back(3);
5463        keys2.push_back(4);
5464        keys2.push_back(5);
5465    
5466        DataTagged::ValueListType values;
5467    
5468        DataArrayView::ShapeType viewShape;
5469    
5470        // default value for Data1
5471        DataArrayView::ValueType viewData1(1);
5472        viewData1[0]=0.0;
5473        DataArrayView myView1(viewData1,viewShape);
5474    
5475        // value for tag "1" for Data1
5476        DataArrayView::ValueType viewData2(1);
5477        viewData2[0]=0.0;
5478        DataArrayView myView2(viewData2,viewShape);
5479        values.push_back(myView2);
5480    
5481        // value for tag "2" for Data1
5482        DataArrayView::ValueType viewData5(1);
5483        viewData5[0]=0.0;
5484        DataArrayView myView5(viewData5,viewShape);
5485        values.push_back(myView5);
5486    
5487        // value for tag "3" for Data1
5488        DataArrayView::ValueType viewData6(1);
5489        viewData6[0]=0.0;
5490        DataArrayView myView6(viewData6,viewShape);
5491        values.push_back(myView6);
5492    
5493        DataTagged myData1(keys1,values,myView1,FunctionSpace());
5494    
5495        values.clear();
5496    
5497        // default value for Data2
5498        DataArrayView::ValueType viewData3(1);
5499        viewData3[0]=1.0;
5500        DataArrayView myView3(viewData3,viewShape);
5501    
5502        // value for tag "3" for Data2
5503        DataArrayView::ValueType viewData4(1);
5504        viewData4[0]=2.0;
5505        DataArrayView myView4(viewData4,viewShape);
5506        values.push_back(myView4);
5507    
5508        // value for tag "4" for Data2
5509        DataArrayView::ValueType viewData7(1);
5510        viewData7[0]=3.0;
5511        DataArrayView myView7(viewData7,viewShape);
5512        values.push_back(myView7);
5513    
5514        // value for tag "5" for Data2
5515        DataArrayView::ValueType viewData8(1);
5516        viewData8[0]=4.0;
5517        DataArrayView myView8(viewData8,viewShape);
5518        values.push_back(myView8);
5519    
5520        DataTagged myData2(keys2,values,myView3,FunctionSpace());
5521    
5522        //cout << myData1.toString() << endl;
5523        //cout << myData2.toString() << endl;
5524    
5525        // full slice
5526    
5527        DataArrayView::RegionType region;
5528    
5529        myData1.setSlice(&myData2, region);
5530    
5531        //cout << myData1.toString() << endl;
5532    
5533        assert(myData1.getTagLookup().size()==5);
5534    
5535        assert(myData1.getLength()==6);
5536    
5537        DataArrayView myDataView = myData1.getDefaultValue();
5538        assert(!myDataView.isEmpty());
5539        assert(myDataView.getOffset()==0);
5540        assert(myDataView.getRank()==0);
5541        assert(myDataView.noValues()==1);
5542        assert(myDataView.getShape().size()==0);
5543        assert(myDataView()==1.0);
5544    
5545        myDataView = myData1.getDataPointByTag(1);
5546        assert(!myDataView.isEmpty());
5547        assert(myDataView.getOffset()==1);
5548        assert(myDataView.getRank()==0);
5549        assert(myDataView.noValues()==1);
5550        assert(myDataView.getShape().size()==0);
5551        assert(myDataView()==1.0);
5552    
5553        myDataView = myData1.getDataPointByTag(2);
5554        assert(!myDataView.isEmpty());
5555        assert(myDataView.getOffset()==2);
5556        assert(myDataView.getRank()==0);
5557        assert(myDataView.noValues()==1);
5558        assert(myDataView.getShape().size()==0);
5559        assert(myDataView()==1.0);
5560    
5561        myDataView = myData1.getDataPointByTag(3);
5562        assert(!myDataView.isEmpty());
5563        assert(myDataView.getOffset()==3);
5564        assert(myDataView.getRank()==0);
5565        assert(myDataView.noValues()==1);
5566        assert(myDataView.getShape().size()==0);
5567        assert(myDataView()==2.0);
5568    
5569        myDataView = myData1.getDataPointByTag(4);
5570        assert(!myDataView.isEmpty());
5571        assert(myDataView.getOffset()==4);
5572        assert(myDataView.getRank()==0);
5573        assert(myDataView.noValues()==1);
5574        assert(myDataView.getShape().size()==0);
5575        assert(myDataView()==3.0);
5576    
5577        myDataView = myData1.getDataPointByTag(5);
5578        assert(!myDataView.isEmpty());
5579        assert(myDataView.getOffset()==5);
5580        assert(myDataView.getRank()==0);
5581        assert(myDataView.noValues()==1);
5582        assert(myDataView.getShape().size()==0);
5583        assert(myDataView()==4.0);
5584    
5585      }
5586    
5587  }  }
5588    
5589  TestSuite* DataTaggedTestCase::suite ()  TestSuite* DataTaggedTestCase::suite ()
# Line 3177  TestSuite* DataTaggedTestCase::suite () Line 5597  TestSuite* DataTaggedTestCase::suite ()
5597    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));
5598    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));
5599    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));
5600    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSlicing",&DataTaggedTestCase::testSlicing));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testGetSlice",&DataTaggedTestCase::testGetSlice));
5601      testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetSlice",&DataTaggedTestCase::testSetSlice));
5602    return testSuite;    return testSuite;
5603  }  }

Legend:
Removed from v.514  
changed lines
  Added in v.622

  ViewVC Help
Powered by ViewVC 1.1.26