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

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

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

revision 499 by jgs, Tue Feb 7 04:40:44 2006 UTC revision 503 by jgs, Wed Feb 8 04:25:40 2006 UTC
# Line 16  Line 16 
16  #include "EsysException.h"  #include "EsysException.h"
17    
18  #include "DataTagged.h"  #include "DataTagged.h"
19    #include "DataConstant.h"
20    
21  #include "DataTaggedTestCase.h"  #include "DataTaggedTestCase.h"
22    
# Line 114  void DataTaggedTestCase::testOperations( Line 115  void DataTaggedTestCase::testOperations(
115      assert(left.getDataPointByTag(1)==vZero.getView());      assert(left.getDataPointByTag(1)==vZero.getView());
116      assert(left.getDataPointByTag(2)==vZero.getView());      assert(left.getDataPointByTag(2)==vZero.getView());
117    }    }
118    
119    {    {
120      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
121      viewShape.push_back(3);      viewShape.push_back(3);
# Line 141  void DataTaggedTestCase::testOperations( Line 143  void DataTaggedTestCase::testOperations(
143        assert(left.getDefaultValue()(i)==-(i*mVal));        assert(left.getDefaultValue()(i)==-(i*mVal));
144      }      }
145    }    }
146    
147    {    {
148      cout << "\tTest unaryOp(negate) on default DataTagged." << endl;      cout << "\tTest unaryOp(negate) on default DataTagged." << endl;
149      DataTagged data;      DataTagged data;
# Line 152  void DataTaggedTestCase::testOperations( Line 155  void DataTaggedTestCase::testOperations(
155      unaryOp(data,negate<double>());      unaryOp(data,negate<double>());
156      assert(data.getDefaultValue()()==-1);      assert(data.getDefaultValue()()==-1);
157    }    }
158    
159    {    {
160      cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;      cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;
161      DataArrayView::ShapeType vShape;      DataArrayView::ShapeType vShape;
# Line 181  void DataTaggedTestCase::testOperations( Line 185  void DataTaggedTestCase::testOperations(
185      assert(tData.getDataPointByTag(2)==tTwoView);      assert(tData.getDataPointByTag(2)==tTwoView);
186      assert(tData.getDataPointByTag(3)==tThreeView);      assert(tData.getDataPointByTag(3)==tThreeView);
187    }    }
188    
189    }
190    
191    void DataTaggedTestCase::testAddTaggedValues() {
192    
193      cout << endl;
194    
195      {
196    
197        cout << "\tTest adding one key with empty value list to default DataTagged." << endl;
198        DataTagged myData;
199    
200        DataTagged::TagListType keys;
201        keys.push_back(1);
202    
203        DataTagged::ValueListType values;
204    
205        myData.addTaggedValues(keys,values);
206    
207        assert(myData.isCurrentTag(1));
208    
209        assert(myData.getTagLookup().size()==1);
210    
211        assert(myData.getLength()==2);
212    
213        // data-point 0 has tag number 1 by default
214        assert(myData.getTagNumber(0)==1);
215    
216        assert(myData.getPointOffset(0,0)==1);
217    
218        DataArrayView myDataView = myData.getDataPoint(0,0);
219        assert(!myDataView.isEmpty());
220        assert(myDataView.getOffset()==1);
221        assert(myDataView.getRank()==0);
222        assert(myDataView.noValues()==1);
223        assert(myDataView.getShape().size()==0);
224        assert(myDataView()==0.0);
225    
226        myDataView = myData.getDataPointByTag(1);
227        assert(!myDataView.isEmpty());
228        assert(myDataView.getOffset()==1);
229        assert(myDataView.getRank()==0);
230        assert(myDataView.noValues()==1);
231        assert(myDataView.getShape().size()==0);
232        assert(myDataView()==0.0);
233    
234        myDataView = myData.getDefaultValue();
235        assert(!myDataView.isEmpty());
236        assert(myDataView.getOffset()==0);
237        assert(myDataView.getRank()==0);
238        assert(myDataView.noValues()==1);
239        assert(myDataView.getShape().size()==0);
240        assert(myDataView()==0.0);
241    
242      }
243    
244      {
245    
246        cout << "\tTest adding one key with one value to default DataTagged." << endl;
247        DataTagged myData;
248    
249        DataTagged::TagListType keys;
250        keys.push_back(1);
251    
252        DataTagged::ValueListType values;
253    
254        DataArrayView::ShapeType viewShape;
255        DataArrayView::ValueType viewData(1);
256        viewData[0]=1.0;
257        DataArrayView myView(viewData,viewShape);
258        values.push_back(myView);
259    
260        myData.addTaggedValues(keys,values);
261    
262        assert(myData.isCurrentTag(1));
263    
264        assert(myData.getTagLookup().size()==1);
265    
266        assert(myData.getLength()==2);
267    
268        // data-point 0 has tag number 1 by default
269        assert(myData.getTagNumber(0)==1);
270    
271        assert(myData.getPointOffset(0,0)==1);
272    
273        DataArrayView myDataView = myData.getDataPoint(0,0);
274        assert(!myDataView.isEmpty());
275        assert(myDataView.getOffset()==1);
276        assert(myDataView.getRank()==0);
277        assert(myDataView.noValues()==1);
278        assert(myDataView.getShape().size()==0);
279        assert(myDataView()==1.0);
280    
281        myDataView = myData.getDataPointByTag(1);
282        assert(!myDataView.isEmpty());
283        assert(myDataView.getOffset()==1);
284        assert(myDataView.getRank()==0);
285        assert(myDataView.noValues()==1);
286        assert(myDataView.getShape().size()==0);
287        assert(myDataView()==1.0);
288    
289        myDataView = myData.getDefaultValue();
290        assert(!myDataView.isEmpty());
291        assert(myDataView.getOffset()==0);
292        assert(myDataView.getRank()==0);
293        assert(myDataView.noValues()==1);
294        assert(myDataView.getShape().size()==0);
295        assert(myDataView()==0.0);
296    
297      }
298    
299      {
300    
301        cout << "\tTest adding three keys with one value to default DataTagged." << endl;
302        DataTagged myData;
303    
304        DataTagged::TagListType keys;
305        keys.push_back(1);
306        keys.push_back(2);
307        keys.push_back(3);
308    
309        DataTagged::ValueListType values;
310    
311        DataArrayView::ShapeType viewShape;
312        DataArrayView::ValueType viewData(1);
313        viewData[0]=1.0;
314        DataArrayView myView(viewData,viewShape);
315        values.push_back(myView);
316    
317        myData.addTaggedValues(keys,values);
318    
319        assert(myData.isCurrentTag(1));
320        assert(myData.isCurrentTag(2));
321        assert(myData.isCurrentTag(3));
322    
323        assert(myData.getTagLookup().size()==3);
324    
325        assert(myData.getLength()==4);
326    
327        // data-point 0 has tag number 1 by default
328        assert(myData.getTagNumber(0)==1);
329    
330        assert(myData.getPointOffset(0,0)==1);
331    
332        DataArrayView myDataView = myData.getDataPoint(0,0);
333        assert(!myDataView.isEmpty());
334        assert(myDataView.getOffset()==1);
335        assert(myDataView.getRank()==0);
336        assert(myDataView.noValues()==1);
337        assert(myDataView.getShape().size()==0);
338        assert(myDataView()==1.0);
339    
340        myDataView = myData.getDataPointByTag(1);
341        assert(!myDataView.isEmpty());
342        assert(myDataView.getOffset()==1);
343        assert(myDataView.getRank()==0);
344        assert(myDataView.noValues()==1);
345        assert(myDataView.getShape().size()==0);
346        assert(myDataView()==1.0);
347    
348        myDataView = myData.getDataPointByTag(2);
349        assert(!myDataView.isEmpty());
350        assert(myDataView.getOffset()==2);
351        assert(myDataView.getRank()==0);
352        assert(myDataView.noValues()==1);
353        assert(myDataView.getShape().size()==0);
354        assert(myDataView()==1.0);
355    
356        myDataView = myData.getDataPointByTag(3);
357        assert(!myDataView.isEmpty());
358        assert(myDataView.getOffset()==3);
359        assert(myDataView.getRank()==0);
360        assert(myDataView.noValues()==1);
361        assert(myDataView.getShape().size()==0);
362        assert(myDataView()==1.0);
363    
364        myDataView = myData.getDefaultValue();
365        assert(!myDataView.isEmpty());
366        assert(myDataView.getOffset()==0);
367        assert(myDataView.getRank()==0);
368        assert(myDataView.noValues()==1);
369        assert(myDataView.getShape().size()==0);
370        assert(myDataView()==0.0);
371    
372      }
373    
374      {
375    
376        cout << "\tTest adding three keys with three values to default DataTagged." << endl;
377        DataTagged myData;
378    
379        DataTagged::TagListType keys;
380        keys.push_back(1);
381        keys.push_back(2);
382        keys.push_back(3);
383    
384        DataTagged::ValueListType values;
385    
386        DataArrayView::ShapeType viewShape;
387        DataArrayView::ValueType viewData1(1);
388        viewData1[0]=1.0;
389        DataArrayView::ValueType viewData2(1);
390        viewData2[0]=2.0;
391        DataArrayView::ValueType viewData3(1);
392        viewData3[0]=3.0;
393        DataArrayView myView1(viewData1,viewShape);
394        DataArrayView myView2(viewData2,viewShape);
395        DataArrayView myView3(viewData3,viewShape);
396        values.push_back(myView1);
397        values.push_back(myView2);
398        values.push_back(myView3);
399    
400        myData.addTaggedValues(keys,values);
401    
402        assert(myData.isCurrentTag(1));
403        assert(myData.isCurrentTag(2));
404        assert(myData.isCurrentTag(3));
405    
406        assert(myData.getTagLookup().size()==3);
407    
408        assert(myData.getLength()==4);
409    
410        // data-point 0 has tag number 1 by default
411        assert(myData.getTagNumber(0)==1);
412    
413        assert(myData.getPointOffset(0,0)==1);
414    
415        DataArrayView myDataView = myData.getDataPoint(0,0);
416        assert(!myDataView.isEmpty());
417        assert(myDataView.getOffset()==1);
418        assert(myDataView.getRank()==0);
419        assert(myDataView.noValues()==1);
420        assert(myDataView.getShape().size()==0);
421        assert(myDataView()==1.0);
422    
423        myDataView = myData.getDataPointByTag(1);
424        assert(!myDataView.isEmpty());
425        assert(myDataView.getOffset()==1);
426        assert(myDataView.getRank()==0);
427        assert(myDataView.noValues()==1);
428        assert(myDataView.getShape().size()==0);
429        assert(myDataView()==1.0);
430    
431        myDataView = myData.getDataPointByTag(2);
432        assert(!myDataView.isEmpty());
433        assert(myDataView.getOffset()==2);
434        assert(myDataView.getRank()==0);
435        assert(myDataView.noValues()==1);
436        assert(myDataView.getShape().size()==0);
437        assert(myDataView()==2.0);
438    
439        myDataView = myData.getDataPointByTag(3);
440        assert(!myDataView.isEmpty());
441        assert(myDataView.getOffset()==3);
442        assert(myDataView.getRank()==0);
443        assert(myDataView.noValues()==1);
444        assert(myDataView.getShape().size()==0);
445        assert(myDataView()==3.0);
446    
447        myDataView = myData.getDefaultValue();
448        assert(!myDataView.isEmpty());
449        assert(myDataView.getOffset()==0);
450        assert(myDataView.getRank()==0);
451        assert(myDataView.noValues()==1);
452        assert(myDataView.getShape().size()==0);
453        assert(myDataView()==0.0);
454    
455      }
456    
457      {
458    
459        cout << "\tTest adding one key with empty value list to DataTagged with default value only." << endl;
460    
461        DataArrayView::ShapeType viewShape;
462        viewShape.push_back(3);
463    
464        DataTagged::TagListType keys;
465    
466        DataTagged::ValueListType values;
467    
468        DataArrayView::ValueType viewData(3);
469        for (int i=0;i<viewShape[0];i++) {
470          viewData[i]=i;
471        }
472        DataArrayView myView(viewData,viewShape);
473    
474        DataTagged myData(keys,values,myView,FunctionSpace());
475    
476        keys.push_back(1);
477        values.clear();
478    
479        myData.addTaggedValues(keys,values);
480    
481        assert(myData.isCurrentTag(1));
482    
483        assert(myData.getTagLookup().size()==1);
484    
485        assert(myData.getLength()==6);
486    
487        // data-point 0 has tag number 1 by default
488        assert(myData.getTagNumber(0)==1);
489    
490        assert(myData.getPointOffset(0,0)==3);
491    
492        DataArrayView myDataView = myData.getDataPoint(0,0);
493        assert(myDataView==myView);
494        assert(!myDataView.isEmpty());
495        assert(myDataView.getOffset()==3);
496        assert(myDataView.getRank()==1);
497        assert(myDataView.noValues()==3);
498        assert(myDataView.getShape().size()==1);
499        assert(myDataView(0)==0);
500        assert(myDataView(1)==1);
501        assert(myDataView(2)==2);
502    
503        myDataView = myData.getDataPointByTag(1);
504        assert(myDataView==myView);
505        assert(!myDataView.isEmpty());
506        assert(myDataView.getOffset()==3);
507        assert(myDataView.getRank()==1);
508        assert(myDataView.noValues()==3);
509        assert(myDataView.getShape().size()==1);
510        assert(myDataView(0)==0);
511        assert(myDataView(1)==1);
512        assert(myDataView(2)==2);
513    
514        myDataView = myData.getDefaultValue();
515        assert(myDataView==myView);
516        assert(!myDataView.isEmpty());
517        assert(myDataView.getOffset()==0);
518        assert(myDataView.getRank()==1);
519        assert(myDataView.noValues()==3);
520        assert(myDataView.getShape().size()==1);
521        assert(myDataView(0)==0);
522        assert(myDataView(1)==1);
523        assert(myDataView(2)==2);
524    
525      }
526    
527      {
528    
529        cout << "\tTest adding one key with one value to DataTagged with default value only." << endl;
530    
531        DataArrayView::ShapeType viewShape;
532        viewShape.push_back(3);
533    
534        DataTagged::TagListType keys;
535    
536        DataTagged::ValueListType values;
537    
538        DataArrayView::ValueType viewData(3);
539        for (int i=0;i<viewShape[0];i++) {
540          viewData[i]=i;
541        }
542        DataArrayView myView(viewData,viewShape);
543    
544        DataTagged myData(keys,values,myView,FunctionSpace());
545    
546        keys.push_back(1);
547    
548        DataArrayView::ValueType viewData1(3);
549        for (int i=0;i<viewShape[0];i++) {
550          viewData1[i]=i+1;
551        }
552        DataArrayView myView1(viewData1,viewShape);
553        values.push_back(myView1);
554    
555        myData.addTaggedValues(keys,values);
556    
557        assert(myData.isCurrentTag(1));
558    
559        assert(myData.getTagLookup().size()==1);
560    
561        assert(myData.getLength()==6);
562    
563        // data-point 0 has tag number 1 by default
564        assert(myData.getTagNumber(0)==1);
565    
566        assert(myData.getPointOffset(0,0)==3);
567    
568        DataArrayView myDataView = myData.getDataPoint(0,0);
569        assert(myDataView==myView1);
570        assert(!myDataView.isEmpty());
571        assert(myDataView.getOffset()==3);
572        assert(myDataView.getRank()==1);
573        assert(myDataView.noValues()==3);
574        assert(myDataView.getShape().size()==1);
575        assert(myDataView(0)==1);
576        assert(myDataView(1)==2);
577        assert(myDataView(2)==3);
578    
579        myDataView = myData.getDataPointByTag(1);
580        assert(myDataView==myView1);
581        assert(!myDataView.isEmpty());
582        assert(myDataView.getOffset()==3);
583        assert(myDataView.getRank()==1);
584        assert(myDataView.noValues()==3);
585        assert(myDataView.getShape().size()==1);
586        assert(myDataView(0)==1);
587        assert(myDataView(1)==2);
588        assert(myDataView(2)==3);
589    
590        myDataView = myData.getDefaultValue();
591        assert(myDataView==myView);
592        assert(!myDataView.isEmpty());
593        assert(myDataView.getOffset()==0);
594        assert(myDataView.getRank()==1);
595        assert(myDataView.noValues()==3);
596        assert(myDataView.getShape().size()==1);
597        assert(myDataView(0)==0);
598        assert(myDataView(1)==1);
599        assert(myDataView(2)==2);
600    
601      }
602    
603      {
604    
605        cout << "\tTest adding three keys with one value to DataTagged with default value only." << endl;
606    
607        DataArrayView::ShapeType viewShape;
608        viewShape.push_back(3);
609    
610        DataTagged::TagListType keys;
611    
612        DataTagged::ValueListType values;
613    
614        DataArrayView::ValueType viewData(3);
615        for (int i=0;i<viewShape[0];i++) {
616          viewData[i]=i;
617        }
618        DataArrayView myView(viewData,viewShape);
619    
620        DataTagged myData(keys,values,myView,FunctionSpace());
621    
622        keys.push_back(1);
623        keys.push_back(2);
624        keys.push_back(3);
625    
626        DataArrayView::ValueType viewData1(3);
627        for (int i=0;i<viewShape[0];i++) {
628          viewData1[i]=i+1;
629        }
630        DataArrayView myView1(viewData1,viewShape);
631        values.push_back(myView1);
632    
633        myData.addTaggedValues(keys,values);
634    
635        assert(myData.isCurrentTag(1));
636        assert(myData.isCurrentTag(2));
637        assert(myData.isCurrentTag(3));
638    
639        assert(myData.getTagLookup().size()==3);
640    
641        assert(myData.getLength()==12);
642    
643        // data-point 0 has tag number 1 by default
644        assert(myData.getTagNumber(0)==1);
645    
646        assert(myData.getPointOffset(0,0)==3);
647    
648        DataArrayView myDataView = myData.getDataPoint(0,0);
649        assert(myDataView==myView1);
650        assert(!myDataView.isEmpty());
651        assert(myDataView.getOffset()==3);
652        assert(myDataView.getRank()==1);
653        assert(myDataView.noValues()==3);
654        assert(myDataView.getShape().size()==1);
655        assert(myDataView(0)==1);
656        assert(myDataView(1)==2);
657        assert(myDataView(2)==3);
658    
659        myDataView = myData.getDataPointByTag(1);
660        assert(myDataView==myView1);
661        assert(!myDataView.isEmpty());
662        assert(myDataView.getOffset()==3);
663        assert(myDataView.getRank()==1);
664        assert(myDataView.noValues()==3);
665        assert(myDataView.getShape().size()==1);
666        assert(myDataView(0)==1);
667        assert(myDataView(1)==2);
668        assert(myDataView(2)==3);
669    
670        myDataView = myData.getDataPointByTag(2);
671        assert(myDataView==myView1);
672        assert(!myDataView.isEmpty());
673        assert(myDataView.getOffset()==6);
674        assert(myDataView.getRank()==1);
675        assert(myDataView.noValues()==3);
676        assert(myDataView.getShape().size()==1);
677        assert(myDataView(0)==1);
678        assert(myDataView(1)==2);
679        assert(myDataView(2)==3);
680    
681        myDataView = myData.getDataPointByTag(3);
682        assert(myDataView==myView1);
683        assert(!myDataView.isEmpty());
684        assert(myDataView.getOffset()==9);
685        assert(myDataView.getRank()==1);
686        assert(myDataView.noValues()==3);
687        assert(myDataView.getShape().size()==1);
688        assert(myDataView(0)==1);
689        assert(myDataView(1)==2);
690        assert(myDataView(2)==3);
691    
692        myDataView = myData.getDefaultValue();
693        assert(myDataView==myView);
694        assert(!myDataView.isEmpty());
695        assert(myDataView.getOffset()==0);
696        assert(myDataView.getRank()==1);
697        assert(myDataView.noValues()==3);
698        assert(myDataView.getShape().size()==1);
699        assert(myDataView(0)==0);
700        assert(myDataView(1)==1);
701        assert(myDataView(2)==2);
702    
703      }
704    
705      {
706    
707        cout << "\tTest adding three keys with three values to DataTagged with default value only." << endl;
708    
709        DataArrayView::ShapeType viewShape;
710        viewShape.push_back(3);
711    
712        DataTagged::TagListType keys;
713    
714        DataTagged::ValueListType values;
715    
716        DataArrayView::ValueType viewData(3);
717        for (int i=0;i<viewShape[0];i++) {
718          viewData[i]=i;
719        }
720        DataArrayView myView(viewData,viewShape);
721    
722        DataTagged myData(keys,values,myView,FunctionSpace());
723    
724        keys.push_back(1);
725        keys.push_back(2);
726        keys.push_back(3);
727    
728        DataArrayView::ValueType viewData1(3);
729        for (int i=0;i<viewShape[0];i++) {
730          viewData1[i]=i+1;
731        }
732        DataArrayView myView1(viewData1,viewShape);
733        values.push_back(myView1);
734    
735        DataArrayView::ValueType viewData2(3);
736        for (int i=0;i<viewShape[0];i++) {
737          viewData2[i]=i+2;
738        }
739        DataArrayView myView2(viewData2,viewShape);
740        values.push_back(myView2);
741    
742        DataArrayView::ValueType viewData3(3);
743        for (int i=0;i<viewShape[0];i++) {
744          viewData3[i]=i+3;
745        }
746        DataArrayView myView3(viewData3,viewShape);
747        values.push_back(myView3);
748    
749        myData.addTaggedValues(keys,values);
750    
751        assert(myData.isCurrentTag(1));
752        assert(myData.isCurrentTag(2));
753        assert(myData.isCurrentTag(3));
754    
755        assert(myData.getTagLookup().size()==3);
756    
757        assert(myData.getLength()==12);
758    
759        // data-point 0 has tag number 1 by default
760        assert(myData.getTagNumber(0)==1);
761    
762        assert(myData.getPointOffset(0,0)==3);
763    
764        DataArrayView myDataView = myData.getDataPoint(0,0);
765        assert(myDataView==myView1);
766        assert(!myDataView.isEmpty());
767        assert(myDataView.getOffset()==3);
768        assert(myDataView.getRank()==1);
769        assert(myDataView.noValues()==3);
770        assert(myDataView.getShape().size()==1);
771        assert(myDataView(0)==1);
772        assert(myDataView(1)==2);
773        assert(myDataView(2)==3);
774    
775        myDataView = myData.getDataPointByTag(1);
776        assert(myDataView==myView1);
777        assert(!myDataView.isEmpty());
778        assert(myDataView.getOffset()==3);
779        assert(myDataView.getRank()==1);
780        assert(myDataView.noValues()==3);
781        assert(myDataView.getShape().size()==1);
782        assert(myDataView(0)==1);
783        assert(myDataView(1)==2);
784        assert(myDataView(2)==3);
785    
786        myDataView = myData.getDataPointByTag(2);
787        assert(myDataView==myView2);
788        assert(!myDataView.isEmpty());
789        assert(myDataView.getOffset()==6);
790        assert(myDataView.getRank()==1);
791        assert(myDataView.noValues()==3);
792        assert(myDataView.getShape().size()==1);
793        assert(myDataView(0)==2);
794        assert(myDataView(1)==3);
795        assert(myDataView(2)==4);
796    
797        myDataView = myData.getDataPointByTag(3);
798        assert(myDataView==myView3);
799        assert(!myDataView.isEmpty());
800        assert(myDataView.getOffset()==9);
801        assert(myDataView.getRank()==1);
802        assert(myDataView.noValues()==3);
803        assert(myDataView.getShape().size()==1);
804        assert(myDataView(0)==3);
805        assert(myDataView(1)==4);
806        assert(myDataView(2)==5);
807    
808        myDataView = myData.getDefaultValue();
809        assert(myDataView==myView);
810        assert(!myDataView.isEmpty());
811        assert(myDataView.getOffset()==0);
812        assert(myDataView.getRank()==1);
813        assert(myDataView.noValues()==3);
814        assert(myDataView.getShape().size()==1);
815        assert(myDataView(0)==0);
816        assert(myDataView(1)==1);
817        assert(myDataView(2)==2);
818    
819      }
820    
821      {
822    
823        cout << "\tTest adding one key with empty value list to DataTagged with three tags." << endl;
824    
825        DataTagged::TagListType keys;
826        keys.push_back(1);
827        keys.push_back(2);
828        keys.push_back(3);
829    
830        DataTagged::ValueListType values;
831    
832        DataArrayView::ShapeType viewShape;
833        viewShape.push_back(3);
834    
835        // default value
836        DataArrayView::ValueType viewData(3);
837        for (int i=0;i<viewShape[0];i++) {
838          viewData[i]=i;
839        }
840        DataArrayView myView(viewData,viewShape);
841    
842        // value for tag "1"
843        DataArray eOne(myView);
844        for (int i=0;i<eOne.getView().getShape()[0];i++) {
845          eOne.getView()(i)=i+1.0;
846        }
847        values.push_back(eOne.getView());
848    
849        // value for tag "2"
850        DataArray eTwo(myView);
851        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
852          eTwo.getView()(i)=i+2.0;
853        }
854        values.push_back(eTwo.getView());
855    
856        // value for tag "3"
857        DataArray eThree(myView);
858        for (int i=0;i<eThree.getView().getShape()[0];i++) {
859          eThree.getView()(i)=i+3.0;
860        }
861        values.push_back(eThree.getView());
862    
863        DataTagged myData(keys,values,myView,FunctionSpace());
864    
865        keys.clear();
866        keys.push_back(4);
867        values.clear();
868    
869        myData.addTaggedValues(keys,values);
870    
871        assert(myData.isCurrentTag(4));
872    
873        assert(myData.getTagLookup().size()==4);
874    
875        assert(myData.getLength()==15);
876    
877        DataArrayView myDataView = myData.getDataPointByTag(4);
878        assert(myDataView==myView);
879        assert(!myDataView.isEmpty());
880        assert(myDataView.getOffset()==12);
881        assert(myDataView.getRank()==1);
882        assert(myDataView.noValues()==3);
883        assert(myDataView.getShape().size()==1);
884        assert(myDataView(0)==0);
885        assert(myDataView(1)==1);
886        assert(myDataView(2)==2);
887    
888      }
889    
890      {
891    
892        cout << "\tTest adding one key with one value to DataTagged with three tags." << endl;
893    
894        DataTagged::TagListType keys;
895        keys.push_back(1);
896        keys.push_back(2);
897        keys.push_back(3);
898    
899        DataTagged::ValueListType values;
900    
901        DataArrayView::ShapeType viewShape;
902        viewShape.push_back(3);
903    
904        // default value
905        DataArrayView::ValueType viewData(3);
906        for (int i=0;i<viewShape[0];i++) {
907          viewData[i]=i;
908        }
909        DataArrayView myView(viewData,viewShape);
910    
911        // value for tag "1"
912        DataArray eOne(myView);
913        for (int i=0;i<eOne.getView().getShape()[0];i++) {
914          eOne.getView()(i)=i+1.0;
915        }
916        values.push_back(eOne.getView());
917    
918        // value for tag "2"
919        DataArray eTwo(myView);
920        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
921          eTwo.getView()(i)=i+2.0;
922        }
923        values.push_back(eTwo.getView());
924    
925        // value for tag "3"
926        DataArray eThree(myView);
927        for (int i=0;i<eThree.getView().getShape()[0];i++) {
928          eThree.getView()(i)=i+3.0;
929        }
930        values.push_back(eThree.getView());
931    
932        DataTagged myData(keys,values,myView,FunctionSpace());
933    
934        keys.clear();
935        keys.push_back(4);
936    
937        values.clear();
938        // value for tag "4"
939        DataArray eFour(myView);
940        for (int i=0;i<eFour.getView().getShape()[0];i++) {
941          eFour.getView()(i)=i+4.0;
942        }
943        values.push_back(eFour.getView());
944    
945        myData.addTaggedValues(keys,values);
946    
947        assert(myData.isCurrentTag(4));
948    
949        assert(myData.getTagLookup().size()==4);
950    
951        assert(myData.getLength()==15);
952    
953        DataArrayView myDataView = myData.getDataPointByTag(4);
954        assert(myDataView==eFour.getView());
955        assert(!myDataView.isEmpty());
956        assert(myDataView.getOffset()==12);
957        assert(myDataView.getRank()==1);
958        assert(myDataView.noValues()==3);
959        assert(myDataView.getShape().size()==1);
960        assert(myDataView(0)==4);
961        assert(myDataView(1)==5);
962        assert(myDataView(2)==6);
963    
964      }
965    
966      {
967    
968        cout << "\tTest adding three keys with one value to DataTagged with three tags." << endl;
969    
970        DataTagged::TagListType keys;
971        keys.push_back(1);
972        keys.push_back(2);
973        keys.push_back(3);
974    
975        DataTagged::ValueListType values;
976    
977        DataArrayView::ShapeType viewShape;
978        viewShape.push_back(3);
979    
980        // default value
981        DataArrayView::ValueType viewData(3);
982        for (int i=0;i<viewShape[0];i++) {
983          viewData[i]=i;
984        }
985        DataArrayView myView(viewData,viewShape);
986    
987        // value for tag "1"
988        DataArray eOne(myView);
989        for (int i=0;i<eOne.getView().getShape()[0];i++) {
990          eOne.getView()(i)=i+1.0;
991        }
992        values.push_back(eOne.getView());
993    
994        // value for tag "2"
995        DataArray eTwo(myView);
996        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
997          eTwo.getView()(i)=i+2.0;
998        }
999        values.push_back(eTwo.getView());
1000    
1001        // value for tag "3"
1002        DataArray eThree(myView);
1003        for (int i=0;i<eThree.getView().getShape()[0];i++) {
1004          eThree.getView()(i)=i+3.0;
1005        }
1006        values.push_back(eThree.getView());
1007    
1008        DataTagged myData(keys,values,myView,FunctionSpace());
1009    
1010        keys.clear();
1011        keys.push_back(4);
1012        keys.push_back(5);
1013        keys.push_back(6);
1014    
1015        values.clear();
1016        // value for tags "4", "5" and "6"
1017        DataArray eFour(myView);
1018        for (int i=0;i<eFour.getView().getShape()[0];i++) {
1019          eFour.getView()(i)=i+4.0;
1020        }
1021        values.push_back(eFour.getView());
1022    
1023        myData.addTaggedValues(keys,values);
1024    
1025        assert(myData.isCurrentTag(4));
1026        assert(myData.isCurrentTag(5));
1027        assert(myData.isCurrentTag(6));
1028    
1029        assert(myData.getTagLookup().size()==6);
1030    
1031        assert(myData.getLength()==21);
1032    
1033        DataArrayView myDataView = myData.getDataPointByTag(4);
1034        assert(myDataView==eFour.getView());
1035        assert(!myDataView.isEmpty());
1036        assert(myDataView.getOffset()==12);
1037        assert(myDataView.getRank()==1);
1038        assert(myDataView.noValues()==3);
1039        assert(myDataView.getShape().size()==1);
1040        assert(myDataView(0)==4);
1041        assert(myDataView(1)==5);
1042        assert(myDataView(2)==6);
1043    
1044        myDataView = myData.getDataPointByTag(5);
1045        assert(myDataView==eFour.getView());
1046        assert(!myDataView.isEmpty());
1047        assert(myDataView.getOffset()==15);
1048        assert(myDataView.getRank()==1);
1049        assert(myDataView.noValues()==3);
1050        assert(myDataView.getShape().size()==1);
1051        assert(myDataView(0)==4);
1052        assert(myDataView(1)==5);
1053        assert(myDataView(2)==6);
1054    
1055        myDataView = myData.getDataPointByTag(6);
1056        assert(myDataView==eFour.getView());
1057        assert(!myDataView.isEmpty());
1058        assert(myDataView.getOffset()==18);
1059        assert(myDataView.getRank()==1);
1060        assert(myDataView.noValues()==3);
1061        assert(myDataView.getShape().size()==1);
1062        assert(myDataView(0)==4);
1063        assert(myDataView(1)==5);
1064        assert(myDataView(2)==6);
1065    
1066      }
1067    
1068      {
1069    
1070        cout << "\tTest adding three keys with three values to DataTagged with three tags." << endl;
1071    
1072        DataTagged::TagListType keys;
1073        keys.push_back(1);
1074        keys.push_back(2);
1075        keys.push_back(3);
1076    
1077        DataTagged::ValueListType values;
1078    
1079        DataArrayView::ShapeType viewShape;
1080        viewShape.push_back(3);
1081    
1082        // default value
1083        DataArrayView::ValueType viewData(3);
1084        for (int i=0;i<viewShape[0];i++) {
1085          viewData[i]=i;
1086        }
1087        DataArrayView myView(viewData,viewShape);
1088    
1089        // value for tag "1"
1090        DataArray eOne(myView);
1091        for (int i=0;i<eOne.getView().getShape()[0];i++) {
1092          eOne.getView()(i)=i+1.0;
1093        }
1094        values.push_back(eOne.getView());
1095    
1096        // value for tag "2"
1097        DataArray eTwo(myView);
1098        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
1099          eTwo.getView()(i)=i+2.0;
1100        }
1101        values.push_back(eTwo.getView());
1102    
1103        // value for tag "3"
1104        DataArray eThree(myView);
1105        for (int i=0;i<eThree.getView().getShape()[0];i++) {
1106          eThree.getView()(i)=i+3.0;
1107        }
1108        values.push_back(eThree.getView());
1109    
1110        DataTagged myData(keys,values,myView,FunctionSpace());
1111    
1112        keys.clear();
1113        keys.push_back(4);
1114        keys.push_back(5);
1115        keys.push_back(6);
1116    
1117        values.clear();
1118    
1119        // value for tag "4"
1120        DataArray eFour(myView);
1121        for (int i=0;i<eFour.getView().getShape()[0];i++) {
1122          eFour.getView()(i)=i+4.0;
1123        }
1124        values.push_back(eFour.getView());
1125    
1126        // value for tag "5"
1127        DataArray eFive(myView);
1128        for (int i=0;i<eFive.getView().getShape()[0];i++) {
1129          eFive.getView()(i)=i+5.0;
1130        }
1131        values.push_back(eFive.getView());
1132    
1133        // value for tag "6"
1134        DataArray eSix(myView);
1135        for (int i=0;i<eSix.getView().getShape()[0];i++) {
1136          eSix.getView()(i)=i+6.0;
1137        }
1138        values.push_back(eSix.getView());
1139    
1140        myData.addTaggedValues(keys,values);
1141    
1142        assert(myData.isCurrentTag(4));
1143        assert(myData.isCurrentTag(5));
1144        assert(myData.isCurrentTag(6));
1145    
1146        assert(myData.getTagLookup().size()==6);
1147    
1148        assert(myData.getLength()==21);
1149    
1150        DataArrayView myDataView = myData.getDataPointByTag(4);
1151        assert(myDataView==eFour.getView());
1152        assert(!myDataView.isEmpty());
1153        assert(myDataView.getOffset()==12);
1154        assert(myDataView.getRank()==1);
1155        assert(myDataView.noValues()==3);
1156        assert(myDataView.getShape().size()==1);
1157        assert(myDataView(0)==4);
1158        assert(myDataView(1)==5);
1159        assert(myDataView(2)==6);
1160    
1161        myDataView = myData.getDataPointByTag(5);
1162        assert(myDataView==eFive.getView());
1163        assert(!myDataView.isEmpty());
1164        assert(myDataView.getOffset()==15);
1165        assert(myDataView.getRank()==1);
1166        assert(myDataView.noValues()==3);
1167        assert(myDataView.getShape().size()==1);
1168        assert(myDataView(0)==5);
1169        assert(myDataView(1)==6);
1170        assert(myDataView(2)==7);
1171    
1172        myDataView = myData.getDataPointByTag(6);
1173        assert(myDataView==eSix.getView());
1174        assert(!myDataView.isEmpty());
1175        assert(myDataView.getOffset()==18);
1176        assert(myDataView.getRank()==1);
1177        assert(myDataView.noValues()==3);
1178        assert(myDataView.getShape().size()==1);
1179        assert(myDataView(0)==6);
1180        assert(myDataView(1)==7);
1181        assert(myDataView(2)==8);
1182    
1183      }
1184    
1185    }
1186    
1187    void DataTaggedTestCase::testSetTaggedValue() {
1188    
1189      cout << endl;
1190    
1191      {
1192    
1193        cout << "\tTest setting key in DataTagged with three tags." << endl;
1194    
1195        DataTagged::TagListType keys;
1196        keys.push_back(1);
1197        keys.push_back(2);
1198        keys.push_back(3);
1199    
1200        DataTagged::ValueListType values;
1201    
1202        DataArrayView::ShapeType viewShape;
1203        viewShape.push_back(3);
1204    
1205        // default value
1206        DataArrayView::ValueType viewData(3);
1207        for (int i=0;i<viewShape[0];i++) {
1208          viewData[i]=i;
1209        }
1210        DataArrayView myView(viewData,viewShape);
1211    
1212        // value for tag "1"
1213        DataArray eOne(myView);
1214        for (int i=0;i<eOne.getView().getShape()[0];i++) {
1215          eOne.getView()(i)=i+1.0;
1216        }
1217        values.push_back(eOne.getView());
1218    
1219        // value for tag "2"
1220        DataArray eTwo(myView);
1221        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
1222          eTwo.getView()(i)=i+2.0;
1223        }
1224        values.push_back(eTwo.getView());
1225    
1226        // value for tag "3"
1227        DataArray eThree(myView);
1228        for (int i=0;i<eThree.getView().getShape()[0];i++) {
1229          eThree.getView()(i)=i+3.0;
1230        }
1231        values.push_back(eThree.getView());
1232    
1233        DataTagged myData(keys,values,myView,FunctionSpace());
1234    
1235        // new value for tag "2"
1236        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
1237          eTwo.getView()(i)=i+5.0;
1238        }
1239    
1240        myData.setTaggedValue(2,eTwo.getView());
1241    
1242        assert(myData.isCurrentTag(2));
1243    
1244        assert(myData.getTagLookup().size()==3);
1245    
1246        assert(myData.getLength()==12);
1247    
1248        DataArrayView myDataView = myData.getDataPointByTag(2);
1249        assert(myDataView==eTwo.getView());
1250        assert(!myDataView.isEmpty());
1251        assert(myDataView.getOffset()==6);
1252        assert(myDataView.getRank()==1);
1253        assert(myDataView.noValues()==3);
1254        assert(myDataView.getShape().size()==1);
1255        assert(myDataView(0)==5);
1256        assert(myDataView(1)==6);
1257        assert(myDataView(2)==7);
1258    
1259      }
1260    
1261  }  }
1262    
1263  void DataTaggedTestCase::testAll() {  void DataTaggedTestCase::testAll() {
# Line 202  void DataTaggedTestCase::testAll() { Line 1279  void DataTaggedTestCase::testAll() {
1279      assert(!myData.validSamplePointNo(1));      assert(!myData.validSamplePointNo(1));
1280      assert(!myData.validSampleNo(1));      assert(!myData.validSampleNo(1));
1281    
1282        // data-point 0 has tag number 1 by default
1283      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
1284    
1285      assert(!myData.isCurrentTag(1));      assert(!myData.isCurrentTag(1));
# Line 237  void DataTaggedTestCase::testAll() { Line 1315  void DataTaggedTestCase::testAll() {
1315      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1316      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1317    
     //cout << "\tTest adding two keys with empty value list." << endl;  
     //DataTagged::TagListType keys;  
     //DataTagged::ValueListType values;  
     //keys.push_back(1);  
     //keys.push_back(2);  
     //myData.addTaggedValues(keys,values);  
     //for (int i=0;i<keys.size();++i) {  
     //  assert(myData.getPointDataView()()==0);  
     //}  
   
1318    }    }
1319    
1320    {    {
# Line 278  void DataTaggedTestCase::testAll() { Line 1346  void DataTaggedTestCase::testAll() {
1346      assert(!myData.validSamplePointNo(1));      assert(!myData.validSamplePointNo(1));
1347      assert(!myData.validSampleNo(1));      assert(!myData.validSampleNo(1));
1348    
1349        // data-point 0 has tag number 1 by default
1350      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
1351    
1352      assert(!myData.isCurrentTag(1));      assert(!myData.isCurrentTag(1));
# Line 322  void DataTaggedTestCase::testAll() { Line 1391  void DataTaggedTestCase::testAll() {
1391      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1392      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1393    
     //cout << "\tTest adding a single tag value." << endl;  
     //for (int i=0;i<myView.getShape()[0];++i) {  
     //  myView(i)=i;  
     //}  
     //values.push_back(myView);  
     //keys.push_back(1);  
     //myData.addTaggedValues(keys,values);  
     //assert(myData.getDataPointByTag(1)==myView);  
     //cout << "\tTest addition of further tags." << endl;  
     //keys.resize(0);  
     //keys.push_back(3);  
     //for (int i=0;i<myView.getShape()[0];++i) {  
     //  myView(i)=i+1.5;  
     //}  
     //myData.addTaggedValues(keys,values);  
     //assert(myData.getDataPointByTag(3)==myView);  
     //assert(myData.getDataPointByTag(1)!=myView);  
     //cout << "\tTrigger the size mismatch exception." << endl;  
     //try {  
     //  values.push_back(myView);  
     //  myData.addTaggedValues(keys,values);  
     //  assert(false);  
     //}  
     //catch (EsysException& e) {  
     // assert(true);  
     //}  
   
1394    }    }
1395    
1396    {    {
# Line 391  void DataTaggedTestCase::testAll() { Line 1433  void DataTaggedTestCase::testAll() {
1433      assert(!myData.validSamplePointNo(1));      assert(!myData.validSamplePointNo(1));
1434      assert(!myData.validSampleNo(1));      assert(!myData.validSampleNo(1));
1435    
1436        // data-point 0 has tag number 1 by default
1437      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
1438    
1439      assert(!myData.isCurrentTag(0));      assert(!myData.isCurrentTag(0));
# Line 505  void DataTaggedTestCase::testAll() { Line 1548  void DataTaggedTestCase::testAll() {
1548      assert(!myData.validSamplePointNo(1));      assert(!myData.validSamplePointNo(1));
1549      assert(!myData.validSampleNo(1));      assert(!myData.validSampleNo(1));
1550    
1551        // data-point 0 has tag number 1 by default
1552      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
1553    
1554      assert(!myData.isCurrentTag(0));      assert(!myData.isCurrentTag(0));
# Line 586  void DataTaggedTestCase::testAll() { Line 1630  void DataTaggedTestCase::testAll() {
1630      assert(myDataView(1)==4);      assert(myDataView(1)==4);
1631      assert(myDataView(2)==5);      assert(myDataView(2)==5);
1632    
1633      //cout << "\tTrigger bad shape in input values exception." << endl;    }
1634      //viewShape.clear();  
1635      //viewShape.push_back(1);  }
1636      //keys.clear();  
1637      //values.clear();  void DataTaggedTestCase::testCopyConstructors() {
1638      //viewData.resize(1,0.0);  
1639      //DataArrayView myView2(viewData,viewShape);    cout << endl;
1640      //try {  
1641      //  myData.addTaggedValue(5,myView2);    {
1642      //  assert(false);  
1643      //}      cout << "\tTest DataTagged copy constructor for DataTagged with multiple tags." << endl;
1644      //catch (EsysException& e) {  
1645      //  assert(true);      // the one data-point has tag value "1"
1646      //}  
1647      //cout << "\tTest addTaggedValues." << endl;      DataTagged::TagListType keys;
1648      //DataTagged myData2;      keys.push_back(1);
1649      //myData2.reshapeDataPoint(myView.getShape());      keys.push_back(2);
1650      //keys.clear();      keys.push_back(3);
1651      //values.clear();  
1652      //keys.push_back(1);      DataTagged::ValueListType values;
1653      //keys.push_back(2);  
1654      //keys.push_back(3);      DataArrayView::ShapeType viewShape;
1655      //values.push_back(eOne.getView());      viewShape.push_back(3);
1656      //values.push_back(eTwo.getView());  
1657      //values.push_back(eThree.getView());      // default value
1658      //myData2.addTaggedValues(keys,values);      DataArrayView::ValueType viewData(3);
1659      //assert(myData2.getDataPointByTag(1)==eOne.getView());      for (int i=0;i<viewShape[0];i++) {
1660      //assert(myData2.getDataPointByTag(2)==eTwo.getView());        viewData[i]=i;
1661      //assert(myData2.getDataPointByTag(3)==eThree.getView());      }
1662      //cout << "\tTest setTaggedValue." << endl;      DataArrayView myView(viewData,viewShape);
1663      //DataTagged myData3;  
1664      //myData3.reshapeDataPoint(myView.getShape());      // value for tag "1"
1665      //myData3.addTaggedValue(1,eThree.getView());      DataArray eOne(myView);
1666      //myData3.addTaggedValue(2,eOne.getView());      for (int i=0;i<eOne.getView().getShape()[0];i++) {
1667      //myData3.addTaggedValue(3,eTwo.getView());        eOne.getView()(i)=i+1.0;
1668      //myData3.setTaggedValue(1,eOne.getView());      }
1669      //myData3.setTaggedValue(2,eTwo.getView());      values.push_back(eOne.getView());
1670      //myData3.setTaggedValue(3,eThree.getView());  
1671      //assert(myData3.getDataPointByTag(1)==eOne.getView());      // value for tag "2"
1672      //assert(myData3.getDataPointByTag(2)==eTwo.getView());      DataArray eTwo(myView);
1673      //assert(myData3.getDataPointByTag(3)==eThree.getView());      for (int i=0;i<eTwo.getView().getShape()[0];i++) {
1674          eTwo.getView()(i)=i+2.0;
1675        }
1676        values.push_back(eTwo.getView());
1677    
1678        // value for tag "3"
1679        DataArray eThree(myView);
1680        for (int i=0;i<eThree.getView().getShape()[0];i++) {
1681          eThree.getView()(i)=i+3.0;
1682        }
1683        values.push_back(eThree.getView());
1684    
1685        DataTagged myData(keys,values,myView,FunctionSpace());
1686    
1687        DataTagged myDataCopy(myData);
1688    
1689        //cout << myDataCopy.toString() << endl;
1690    
1691        assert(myDataCopy.getNumSamples()==1);
1692        assert(myDataCopy.getNumDPPSample()==1);
1693    
1694        assert(myDataCopy.validSamplePointNo(0));
1695        assert(myDataCopy.validSampleNo(0));
1696        assert(!myDataCopy.validSamplePointNo(1));
1697        assert(!myDataCopy.validSampleNo(1));
1698    
1699        // data-point 0 has tag number 1 by default
1700        assert(myDataCopy.getTagNumber(0)==1);
1701    
1702        assert(!myDataCopy.isCurrentTag(0));
1703        assert(myDataCopy.isCurrentTag(1));
1704        assert(myDataCopy.isCurrentTag(2));
1705        assert(myDataCopy.isCurrentTag(3));
1706    
1707        assert(myDataCopy.getTagLookup().size()==3);
1708    
1709        assert(myDataCopy.getLength()==12);
1710    
1711        assert(myDataCopy.getPointOffset(0,0)==3);
1712    
1713        DataArrayView myDataView = myDataCopy.getDataPoint(0,0);
1714        assert(myDataView==eOne.getView());
1715        assert(!myDataView.isEmpty());
1716        assert(myDataView.getOffset()==3);
1717        assert(myDataView.getRank()==1);
1718        assert(myDataView.noValues()==3);
1719        assert(myDataView.getShape().size()==1);
1720        assert(myDataView(0)==1);
1721        assert(myDataView(1)==2);
1722        assert(myDataView(2)==3);
1723    
1724        myDataView = myDataCopy.getDataPointByTag(1);
1725        assert(myDataView==eOne.getView());
1726        assert(!myDataView.isEmpty());
1727        assert(myDataView.getOffset()==3);
1728        assert(myDataView.getRank()==1);
1729        assert(myDataView.noValues()==3);
1730        assert(myDataView.getShape().size()==1);
1731        assert(myDataView(0)==1);
1732        assert(myDataView(1)==2);
1733        assert(myDataView(2)==3);
1734    
1735        // Test non-existent tag returns the default value.
1736        myDataView = myDataCopy.getDataPointByTag(0);
1737        assert(myDataView==myView);
1738        assert(!myDataView.isEmpty());
1739        assert(myDataView.getOffset()==0);
1740        assert(myDataView.getRank()==1);
1741        assert(myDataView.noValues()==3);
1742        assert(myDataView.getShape().size()==1);
1743        assert(myDataView(0)==0);
1744        assert(myDataView(1)==1);
1745        assert(myDataView(2)==2);
1746    
1747        myDataView = myDataCopy.getDefaultValue();
1748        assert(myDataView==myView);
1749        assert(!myDataView.isEmpty());
1750        assert(myDataView.getOffset()==0);
1751        assert(myDataView.getRank()==1);
1752        assert(myDataView.noValues()==3);
1753        assert(myDataView.getShape().size()==1);
1754        assert(myDataView(0)==0);
1755        assert(myDataView(1)==1);
1756        assert(myDataView(2)==2);
1757    
1758        // Test data-points held for remaining tags
1759        myDataView = myDataCopy.getDataPointByTag(2);
1760        assert(myDataView==eTwo.getView());
1761        assert(!myDataView.isEmpty());
1762        assert(myDataView.getOffset()==6);
1763        assert(myDataView.getRank()==1);
1764        assert(myDataView.noValues()==3);
1765        assert(myDataView.getShape().size()==1);
1766        assert(myDataView(0)==2);
1767        assert(myDataView(1)==3);
1768        assert(myDataView(2)==4);
1769    
1770        myDataView = myDataCopy.getDataPointByTag(3);
1771        assert(myDataView==eThree.getView());
1772        assert(!myDataView.isEmpty());
1773        assert(myDataView.getOffset()==9);
1774        assert(myDataView.getRank()==1);
1775        assert(myDataView.noValues()==3);
1776        assert(myDataView.getShape().size()==1);
1777        assert(myDataView(0)==3);
1778        assert(myDataView(1)==4);
1779        assert(myDataView(2)==5);
1780    
1781      }
1782    
1783      {
1784    
1785        cout << "\tTest DataTagged copy constructor for DataConstant." << endl;
1786    
1787        // Create a DataConstant
1788        DataArrayView::ShapeType shape;
1789        DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
1790        DataArrayView pointData(data,shape);
1791        pointData()=1.0;
1792        DataConstant myConstantData(pointData, FunctionSpace());
1793    
1794        // use this DataConstant to initialise a DataTagged
1795        DataTagged myData(myConstantData);
1796    
1797        //cout << myData.toString() << endl;
1798    
1799        assert(myData.getNumSamples()==1);
1800        assert(myData.getNumDPPSample()==1);
1801    
1802        assert(myData.validSamplePointNo(0));
1803        assert(myData.validSampleNo(0));
1804        assert(!myData.validSamplePointNo(1));
1805        assert(!myData.validSampleNo(1));
1806    
1807        // data-point 0 has tag number 1 by default
1808        assert(myData.getTagNumber(0)==1);
1809    
1810        assert(!myData.isCurrentTag(1));
1811    
1812        assert(myData.getTagLookup().size()==0);
1813    
1814        assert(myData.getLength()==1);
1815    
1816        assert(myData.getPointOffset(0,0)==0);
1817    
1818        DataArrayView myDataView = myData.getDataPoint(0,0);
1819        assert(!myDataView.isEmpty());
1820        assert(myDataView.getOffset()==0);
1821        assert(myDataView.getRank()==0);
1822        assert(myDataView.noValues()==1);
1823        assert(myDataView.getShape().size()==0);
1824        assert(myDataView()==1.0);
1825    
1826        // Test non-existent tag returns the default value.
1827        myDataView = myData.getDataPointByTag(1);
1828        assert(!myDataView.isEmpty());
1829        assert(myDataView.getOffset()==0);
1830        assert(myDataView.getRank()==0);
1831        assert(myDataView.noValues()==1);
1832        assert(myDataView.getShape().size()==0);
1833        assert(myDataView()==1.0);
1834    
1835        myDataView = myData.getDefaultValue();
1836        assert(!myDataView.isEmpty());
1837        assert(myDataView.getOffset()==0);
1838        assert(myDataView.getRank()==0);
1839        assert(myDataView.noValues()==1);
1840        assert(myDataView.getShape().size()==0);
1841        assert(myDataView()==1.0);
1842    
1843    }    }
1844    
# Line 638  TestSuite* DataTaggedTestCase::suite () Line 1850  TestSuite* DataTaggedTestCase::suite ()
1850    // create the suite of tests to perform.    // create the suite of tests to perform.
1851    TestSuite *testSuite = new TestSuite ("DataTaggedTestCase");    TestSuite *testSuite = new TestSuite ("DataTaggedTestCase");
1852    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testAll",&DataTaggedTestCase::testAll));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testAll",&DataTaggedTestCase::testAll));
1853      testSuite->addTest (new TestCaller< DataTaggedTestCase>("testAddTaggedValues",&DataTaggedTestCase::testAddTaggedValues));
1854      testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetTaggedValue",&DataTaggedTestCase::testSetTaggedValue));
1855      testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));
1856  //  testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));  //  testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));
1857  //  testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));  //  testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));
1858    return testSuite;    return testSuite;

Legend:
Removed from v.499  
changed lines
  Added in v.503

  ViewVC Help
Powered by ViewVC 1.1.26