test/DataTagged/DataTaggedTestCase.cpp

// $Id$
/* 
 *****************************************************************************
 *                                                                           *
 *       COPYRIGHT  ACcESS  -  All Rights Reserved                           *
 *                                                                           *
 * This software is the property of ACcESS. No part of this code             *
 * may be copied in any form or by any means without the expressed written   *
 * consent of ACcESS.  Copying, use or modification of this software         *
 * by any unauthorised person is illegal unless that person has a software   *
 * license agreement with ACcESS.                                            *
 *                                                                           *
 *****************************************************************************
*/
#include "escript/Data/DataTagged.h"
#include "escript/Data/BinaryOp.h"
#include "escript/Data/UnaryOp.h"
#include "esysUtils/EsysException.h"

#include "finley/CPPAdapter/MeshAdapter.h"
#include "finley/CPPAdapter/MeshAdapterFactory.h"
#include "escript/Data/AbstractContinuousDomain.h"

#include "escript/Data/FunctionSpaceFactory.h"
#include "escript/Data/DataFactory.h"

#include "DataTaggedTestCase.h"

#include <iostream>
#include <functional>
#include <algorithm>

using namespace CppUnitTest;
using namespace escript;
using namespace esysUtils;
using namespace std;

using namespace finley;

void DataTaggedTestCase::setUp() {
  //
  // This is called before each test is run
 
}

void DataTaggedTestCase::tearDown() {
  //
  // This is called after each test has been run
 
}

void DataTaggedTestCase::testReshape() {

  cout << endl;

  {
    cout << "\tTest reshape of default constructed DataTagged to rank 1." << endl;
    DataTagged value;
    value.getPointDataView()()=1.0;
    DataArrayView::ShapeType shape;
    shape.push_back(2);
    value.reshapeDataPoint(shape);
    for (int i=0;i<shape[0];++i) {
      assert(value.getDefaultValue()(i)==1);
    }
  }
  {
    cout << "\tTest reshape of default constructed DataTagged to rank 2." << endl;
    DataTagged value;
    value.getPointDataView()()=0.0;
    DataArray vOne(1.0);
    DataArray vTwo(2.0);
    value.addTaggedValue(1,vOne.getView());
    value.addTaggedValue(2,vTwo.getView());
    DataArrayView::ShapeType shape;
    shape.push_back(2);
    shape.push_back(5);
    value.reshapeDataPoint(shape);
    for (int j=0;j<shape[1];++j) {
      for (int i=0;i<shape[0];++i) {
    assert(value.getDefaultValue()(i,j)==0.0);
    assert(value.getDataPointByTag(1)(i,j)==vOne.getView()());
    assert(value.getDataPointByTag(2)(i,j)==vTwo.getView()());
      }
    }
  }
}

void DataTaggedTestCase::testOperations() {

  cout << endl;

  {
    cout << "\tTest default DataTagged contains only a default value." << endl;
    DataTagged left;
    DataTagged right;
    binaryOp(left,right,plus<double>());
    assert(left.getPointDataView()()==0);
    assert(right.getPointDataView()()==0);
    cout << "\tTest addTaggedValue and binaryOp(plus)." << endl;
    DataArray vOne(1.0);
    DataArray vTwo(2.0);
    right.addTaggedValue(1,vOne.getView());
    right.addTaggedValue(2,vTwo.getView());
    binaryOp(left,right,plus<double>());
    assert(left.getPointDataView()()==0);
    assert(left.getDataPointByTag(1)==vOne.getView());
    assert(left.getDataPointByTag(2)==vTwo.getView());
    cout << "\tTest setTaggedValue and binaryOp(multiplies)." << endl;
    DataArray vZero(0.0);
    right.setTaggedValue(1,vZero.getView());
    right.setTaggedValue(2,vZero.getView());
    binaryOp(left,right,multiplies<double>());
    assert(left.getPointDataView()()==0);
    assert(left.getDataPointByTag(1)==vZero.getView());
    assert(left.getDataPointByTag(2)==vZero.getView());
  }
  {
    DataArrayView::ValueType viewData;
    DataArrayView::ShapeType viewShape;
    viewShape.push_back(3);
    DataTagged::TagListType keys;
    DataTagged::ValueListType values;
    for (int i=0;i<viewShape[0];++i) {
      viewData.push_back(i);
    }
    DataArrayView myView(viewData,viewShape);
    cout << "\tCreate tagged data with no tag values just a default." << endl;
    DataTagged left(keys,values,myView,FunctionSpace());
    DataTagged right(keys,values,myView,FunctionSpace());
    binaryOp(left,right,minus<double>());
    for (int i=0;i<viewShape[0];++i) {
      assert(left.getDefaultValue()(i)==0);
    }
    double mVal=10.0;
    for (int i=0;i<viewShape[0];++i) {
      viewData[i]=i*mVal;
    }
    cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;
    binaryOp(left,myView,minus<double>());
    for (int i=0;i<viewShape[0];++i) {
      assert(left.getDefaultValue()(i)==-(i*mVal));
    }
  }
  {
    cout << "\tTest unaryOp(negate) on default DataTagged." << endl;
    DataTagged data;
    unaryOp(data,negate<double>());
    assert(data.getDefaultValue()()==0);
    DataArray vOne(1);
    binaryOp(data,vOne.getView(),plus<double>());
    assert(data.getDefaultValue()()==1);
    unaryOp(data,negate<double>());
    assert(data.getDefaultValue()()==-1);
  }
  {
    cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;
    DataArrayView::ShapeType vShape;
    vShape.push_back(3);
    vShape.push_back(2);
    vShape.push_back(1);
    DataArray defData(vShape,0.0);
    DataArrayView& defView=defData.getView();
    DataArray tOneData(vShape,1.0);
    DataArrayView& tOneView=tOneData.getView();
    DataArray tTwoData(vShape,2.0);
    DataArrayView& tTwoView=tTwoData.getView();
    DataArray tThreeData(vShape,3.0);
    DataArrayView& tThreeView=tThreeData.getView();
    DataTagged::TagListType keys;
    DataTagged::ValueListType values;
    keys.push_back(1);
    keys.push_back(2);
    keys.push_back(3);
    values.push_back(tOneView);
    values.push_back(tTwoView);
    values.push_back(tThreeView);
    DataTagged tData(keys,values,defView,FunctionSpace());
    unaryOp(tData,negate<double>());
    unaryOp(tData,negate<double>());
    assert(tData.getDataPointByTag(1)==tOneView);
    assert(tData.getDataPointByTag(2)==tTwoView);
    assert(tData.getDataPointByTag(3)==tThreeView);
  }

}

void DataTaggedTestCase::testAll() {
  cout << endl;
  {
    cout << "\tTest default construction." << endl;
    DataTagged myData;
    assert(myData.getPointDataView()()==0);
    assert(myData.getNumDPPSample()==1);
    assert(myData.getNumSamples()==1);
    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);
    }
  }
  {
    DataArrayView::ValueType viewData;
    DataArrayView::ShapeType viewShape;
    viewShape.push_back(3);
    DataTagged::TagListType keys;
    DataTagged::ValueListType values;
    for (int i=0;i<viewShape[0];++i) {
      viewData.push_back(0.0);
    }
    DataArrayView myView(viewData,viewShape);
    cout << "\tCreate tagged data with no tag values just a default." << endl;
    DataTagged myData(keys,values,myView,FunctionSpace());
    assert(myData.getNumDPPSample()==1);
    assert(myData.getNumSamples()==1);
    cout << "\tTest non existent tag returns the default value." << endl;
    assert(myData.getDataPointByTag(1)==myView);
    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.clear();
    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) {
      //cout << e.what() << endl;
      assert(true);
    }
  }
  {
    cout << "\tTest creation of tagged data with multiple tags." << endl;
    DataArrayView::ValueType viewData;
    DataArrayView::ShapeType viewShape;
    viewShape.push_back(3);
    DataTagged::TagListType keys;
    DataTagged::ValueListType values;
    for (int i=0;i<viewShape[0];++i) {
      viewData.push_back(0.0);
    }
    DataArrayView myView(viewData,viewShape);
    DataArray eOne(myView);
    DataArray eTwo(myView);
    DataArray eThree(myView);
    for (int i=0;i<eOne.getView().getShape()[0];++i) {
      eOne.getView()(i)=i+1.0;
    }
    for (int i=0;i<eTwo.getView().getShape()[0];++i) {
      eTwo.getView()(i)=i+2.0;
    }
    for (int i=0;i<eThree.getView().getShape()[0];++i) {
      eThree.getView()(i)=i+3.0;
    }
    values.push_back(eOne.getView());
    values.push_back(eTwo.getView());
    values.push_back(eThree.getView());
    keys.push_back(1);
    keys.push_back(2);
    keys.push_back(3);
    DataTagged myData(keys,values,myView,FunctionSpace());
    assert(myData.getDataPointByTag(1)==eOne.getView());
    assert(myData.getDataPointByTag(2)==eTwo.getView());
    assert(myData.getDataPointByTag(3)==eThree.getView());
    cout << "\tTest isCurrentTag function." << endl;
    for (int i=0;i<keys.size();++i) {
      assert(myData.isCurrentTag(keys[i]));
    }
    cout << "\tCheck correct operation for key that doesn't exist." << endl;
    assert(!myData.isCurrentTag(123));
    cout << "\tTrigger bad shape in input values exception." << endl;
    viewShape.clear();
    viewShape.push_back(1);
    keys.clear();
    values.clear();
    viewData.clear();
    for (int i=0;i<viewShape[0];++i) {
      viewData.push_back(0.0);
    }
    DataArrayView myView2(viewData,viewShape);
    try {
      myData.addTaggedValue(5,myView2);
      assert(false);
    }
    catch (EsysException& e) {
      //cout << e.what() << endl;
      assert(true);
    }
    cout << "\tTest setTaggedValues." << endl;
    DataTagged myData2;
    myData2.reshapeDataPoint(myView.getShape());
    keys.clear();
    values.clear();
    keys.push_back(1);
    keys.push_back(2);
    keys.push_back(3);
    values.push_back(eOne.getView());
    values.push_back(eTwo.getView());
    values.push_back(eThree.getView());
    myData2.setTaggedValues(keys,values);
    assert(myData2.getDataPointByTag(1)==eOne.getView());
    assert(myData2.getDataPointByTag(2)==eTwo.getView());
    assert(myData2.getDataPointByTag(3)==eThree.getView());
    cout << "\tTest setTaggedValue." << endl;
    DataTagged myData3;
    myData3.reshapeDataPoint(myView.getShape());
    myData3.setTaggedValue(1,eOne.getView());
    myData3.setTaggedValue(2,eTwo.getView());
    myData3.setTaggedValue(3,eThree.getView());
    assert(myData3.getDataPointByTag(1)==eOne.getView());
    assert(myData3.getDataPointByTag(2)==eTwo.getView());
    assert(myData3.getDataPointByTag(3)==eThree.getView());
  }

}

void DataTaggedTestCase::testSubtraction() {

  // An error with FinleyMesh::getTagList used to cause binary operations
  // between DataExpanded and DataTagged objects to seg-fault. This test
  // case will provoke this error if it arises again.

  // This test requires the version of setTaggedData which takes a Data
  // object as an argument. This version is not currently available, so
  // this test is disabled for now

  /*

  cout << endl;

  cout << "\tCreate domain and function-space." << endl;
  AbstractContinuousDomain* myDomain = rectangle(10,10);
  FunctionSpace f = functionOnBoundary(*myDomain);

  cout << "\tCreate two vectors, one being DataExpanded." << endl;
  Data A = Vector(0,f);
  Data B = Vector(0,f,true);

  cout << "\tCreate some tags and values to add to the other." << endl;
  DataArrayView::ValueType viewData;
  DataArrayView::ShapeType viewShape;
  viewShape.push_back(2);
  for (int i=0;i<viewShape[0];++i) {
    viewData.push_back(0.0);
  }
  DataArrayView myView(viewData,viewShape);
  DataArray eOne(myView);
  for (int i=0;i<eOne.getView().getShape()[0];++i) {
    eOne.getView()(i)=i+1.0;
  }

  A.setTaggedValue(2,eOne.getView());

  //cout << A.toString() << endl;

  cout << "\tCalculate difference." << endl;
  Data difference = B - A;

  cout << "\tCalculate other binaryOps just to be sure." << endl;
  Data sum = B + A;
  Data product = B * A;
  Data dividend = B / A;

  // If we get here, subtraction operation did not seg-fault.
  assert(true);

  */

}

TestSuite* DataTaggedTestCase::suite ()
{
  //
  // create the suite of tests to perform.
  TestSuite *testSuite = new TestSuite ("DataTaggedTestCase");
  testSuite->addTest (new TestCaller< DataTaggedTestCase>("testAll",&DataTaggedTestCase::testAll));
  testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));
  testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));
  //testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSubtraction",&DataTaggedTestCase::testSubtraction));
  return testSuite;
}
1	jgs	82	// $Id$
2			/*
3			*****************************************************************************
4			* *
5			* COPYRIGHT ACcESS - All Rights Reserved *
6			* *
7			* This software is the property of ACcESS. No part of this code *
8			* may be copied in any form or by any means without the expressed written *
9			* consent of ACcESS. Copying, use or modification of this software *
10			* by any unauthorised person is illegal unless that person has a software *
11			* license agreement with ACcESS. *
12			* *
13			*****************************************************************************
14			*/
15			#include "escript/Data/DataTagged.h"
16			#include "escript/Data/BinaryOp.h"
17			#include "escript/Data/UnaryOp.h"
18			#include "esysUtils/EsysException.h"
19
20			#include "finley/CPPAdapter/MeshAdapter.h"
21			#include "finley/CPPAdapter/MeshAdapterFactory.h"
22			#include "escript/Data/AbstractContinuousDomain.h"
23
24			#include "escript/Data/FunctionSpaceFactory.h"
25			#include "escript/Data/DataFactory.h"
26
27			#include "DataTaggedTestCase.h"
28
29			#include <iostream>
30			#include <functional>
31			#include <algorithm>
32
33			using namespace CppUnitTest;
34			using namespace escript;
35			using namespace esysUtils;
36			using namespace std;
37
38			using namespace finley;
39
40			void DataTaggedTestCase::setUp() {
41			//
42			// This is called before each test is run
43
44			}
45
46			void DataTaggedTestCase::tearDown() {
47			//
48			// This is called after each test has been run
49
50			}
51
52			void DataTaggedTestCase::testReshape() {
53
54			cout << endl;
55
56			{
57			cout << "\tTest reshape of default constructed DataTagged to rank 1." << endl;
58			DataTagged value;
59			value.getPointDataView()()=1.0;
60			DataArrayView::ShapeType shape;
61			shape.push_back(2);
62			value.reshapeDataPoint(shape);
63			for (int i=0;i<shape[0];++i) {
64			assert(value.getDefaultValue()(i)==1);
65			}
66			}
67			{
68			cout << "\tTest reshape of default constructed DataTagged to rank 2." << endl;
69			DataTagged value;
70			value.getPointDataView()()=0.0;
71			DataArray vOne(1.0);
72			DataArray vTwo(2.0);
73			value.addTaggedValue(1,vOne.getView());
74			value.addTaggedValue(2,vTwo.getView());
75			DataArrayView::ShapeType shape;
76			shape.push_back(2);
77			shape.push_back(5);
78			value.reshapeDataPoint(shape);
79			for (int j=0;j<shape[1];++j) {
80			for (int i=0;i<shape[0];++i) {
81			assert(value.getDefaultValue()(i,j)==0.0);
82			assert(value.getDataPointByTag(1)(i,j)==vOne.getView()());
83			assert(value.getDataPointByTag(2)(i,j)==vTwo.getView()());
84			}
85			}
86			}
87			}
88
89			void DataTaggedTestCase::testOperations() {
90
91			cout << endl;
92
93			{
94			cout << "\tTest default DataTagged contains only a default value." << endl;
95			DataTagged left;
96			DataTagged right;
97			binaryOp(left,right,plus<double>());
98			assert(left.getPointDataView()()==0);
99			assert(right.getPointDataView()()==0);
100			cout << "\tTest addTaggedValue and binaryOp(plus)." << endl;
101			DataArray vOne(1.0);
102			DataArray vTwo(2.0);
103			right.addTaggedValue(1,vOne.getView());
104			right.addTaggedValue(2,vTwo.getView());
105			binaryOp(left,right,plus<double>());
106			assert(left.getPointDataView()()==0);
107			assert(left.getDataPointByTag(1)==vOne.getView());
108			assert(left.getDataPointByTag(2)==vTwo.getView());
109			cout << "\tTest setTaggedValue and binaryOp(multiplies)." << endl;
110			DataArray vZero(0.0);
111			right.setTaggedValue(1,vZero.getView());
112			right.setTaggedValue(2,vZero.getView());
113			binaryOp(left,right,multiplies<double>());
114			assert(left.getPointDataView()()==0);
115			assert(left.getDataPointByTag(1)==vZero.getView());
116			assert(left.getDataPointByTag(2)==vZero.getView());
117			}
118			{
119			DataArrayView::ValueType viewData;
120			DataArrayView::ShapeType viewShape;
121			viewShape.push_back(3);
122			DataTagged::TagListType keys;
123			DataTagged::ValueListType values;
124			for (int i=0;i<viewShape[0];++i) {
125			viewData.push_back(i);
126			}
127			DataArrayView myView(viewData,viewShape);
128			cout << "\tCreate tagged data with no tag values just a default." << endl;
129			DataTagged left(keys,values,myView,FunctionSpace());
130			DataTagged right(keys,values,myView,FunctionSpace());
131			binaryOp(left,right,minus<double>());
132			for (int i=0;i<viewShape[0];++i) {
133			assert(left.getDefaultValue()(i)==0);
134			}
135			double mVal=10.0;
136			for (int i=0;i<viewShape[0];++i) {
137			viewData[i]=i*mVal;
138			}
139			cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;
140			binaryOp(left,myView,minus<double>());
141			for (int i=0;i<viewShape[0];++i) {
142			assert(left.getDefaultValue()(i)==-(i*mVal));
143			}
144			}
145			{
146			cout << "\tTest unaryOp(negate) on default DataTagged." << endl;
147			DataTagged data;
148			unaryOp(data,negate<double>());
149			assert(data.getDefaultValue()()==0);
150			DataArray vOne(1);
151			binaryOp(data,vOne.getView(),plus<double>());
152			assert(data.getDefaultValue()()==1);
153			unaryOp(data,negate<double>());
154			assert(data.getDefaultValue()()==-1);
155			}
156			{
157			cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;
158			DataArrayView::ShapeType vShape;
159			vShape.push_back(3);
160			vShape.push_back(2);
161			vShape.push_back(1);
162			DataArray defData(vShape,0.0);
163			DataArrayView& defView=defData.getView();
164			DataArray tOneData(vShape,1.0);
165			DataArrayView& tOneView=tOneData.getView();
166			DataArray tTwoData(vShape,2.0);
167			DataArrayView& tTwoView=tTwoData.getView();
168			DataArray tThreeData(vShape,3.0);
169			DataArrayView& tThreeView=tThreeData.getView();
170			DataTagged::TagListType keys;
171			DataTagged::ValueListType values;
172			keys.push_back(1);
173			keys.push_back(2);
174			keys.push_back(3);
175			values.push_back(tOneView);
176			values.push_back(tTwoView);
177			values.push_back(tThreeView);
178			DataTagged tData(keys,values,defView,FunctionSpace());
179			unaryOp(tData,negate<double>());
180			unaryOp(tData,negate<double>());
181			assert(tData.getDataPointByTag(1)==tOneView);
182			assert(tData.getDataPointByTag(2)==tTwoView);
183			assert(tData.getDataPointByTag(3)==tThreeView);
184			}
185
186			}
187
188			void DataTaggedTestCase::testAll() {
189			cout << endl;
190			{
191			cout << "\tTest default construction." << endl;
192			DataTagged myData;
193			assert(myData.getPointDataView()()==0);
194			assert(myData.getNumDPPSample()==1);
195			assert(myData.getNumSamples()==1);
196			cout << "\tTest adding two keys with empty value list." << endl;
197			DataTagged::TagListType keys;
198			DataTagged::ValueListType values;
199			keys.push_back(1);
200			keys.push_back(2);
201			myData.addTaggedValues(keys,values);
202			for (int i=0;i<keys.size();++i) {
203			assert(myData.getPointDataView()()==0);
204			}
205			}
206			{
207			DataArrayView::ValueType viewData;
208			DataArrayView::ShapeType viewShape;
209			viewShape.push_back(3);
210			DataTagged::TagListType keys;
211			DataTagged::ValueListType values;
212			for (int i=0;i<viewShape[0];++i) {
213			viewData.push_back(0.0);
214			}
215			DataArrayView myView(viewData,viewShape);
216			cout << "\tCreate tagged data with no tag values just a default." << endl;
217			DataTagged myData(keys,values,myView,FunctionSpace());
218			assert(myData.getNumDPPSample()==1);
219			assert(myData.getNumSamples()==1);
220			cout << "\tTest non existent tag returns the default value." << endl;
221			assert(myData.getDataPointByTag(1)==myView);
222			cout << "\tTest adding a single tag value." << endl;
223			for (int i=0;i<myView.getShape()[0];++i) {
224			myView(i)=i;
225			}
226			values.push_back(myView);
227			keys.push_back(1);
228			myData.addTaggedValues(keys,values);
229			assert(myData.getDataPointByTag(1)==myView);
230			cout << "\tTest addition of further tags." << endl;
231			keys.clear();
232			keys.push_back(3);
233			for (int i=0;i<myView.getShape()[0];++i) {
234			myView(i)=i+1.5;
235			}
236			myData.addTaggedValues(keys,values);
237			assert(myData.getDataPointByTag(3)==myView);
238			assert(myData.getDataPointByTag(1)!=myView);
239			cout << "\tTrigger the size mismatch exception." << endl;
240			try {
241			values.push_back(myView);
242			myData.addTaggedValues(keys,values);
243			assert(false);
244			}
245			catch (EsysException& e) {
246			//cout << e.what() << endl;
247			assert(true);
248			}
249			}
250			{
251			cout << "\tTest creation of tagged data with multiple tags." << endl;
252			DataArrayView::ValueType viewData;
253			DataArrayView::ShapeType viewShape;
254			viewShape.push_back(3);
255			DataTagged::TagListType keys;
256			DataTagged::ValueListType values;
257			for (int i=0;i<viewShape[0];++i) {
258			viewData.push_back(0.0);
259			}
260			DataArrayView myView(viewData,viewShape);
261			DataArray eOne(myView);
262			DataArray eTwo(myView);
263			DataArray eThree(myView);
264			for (int i=0;i<eOne.getView().getShape()[0];++i) {
265			eOne.getView()(i)=i+1.0;
266			}
267			for (int i=0;i<eTwo.getView().getShape()[0];++i) {
268			eTwo.getView()(i)=i+2.0;
269			}
270			for (int i=0;i<eThree.getView().getShape()[0];++i) {
271			eThree.getView()(i)=i+3.0;
272			}
273			values.push_back(eOne.getView());
274			values.push_back(eTwo.getView());
275			values.push_back(eThree.getView());
276			keys.push_back(1);
277			keys.push_back(2);
278			keys.push_back(3);
279			DataTagged myData(keys,values,myView,FunctionSpace());
280			assert(myData.getDataPointByTag(1)==eOne.getView());
281			assert(myData.getDataPointByTag(2)==eTwo.getView());
282			assert(myData.getDataPointByTag(3)==eThree.getView());
283			cout << "\tTest isCurrentTag function." << endl;
284			for (int i=0;i<keys.size();++i) {
285			assert(myData.isCurrentTag(keys[i]));
286			}
287			cout << "\tCheck correct operation for key that doesn't exist." << endl;
288			assert(!myData.isCurrentTag(123));
289			cout << "\tTrigger bad shape in input values exception." << endl;
290			viewShape.clear();
291			viewShape.push_back(1);
292			keys.clear();
293			values.clear();
294			viewData.clear();
295			for (int i=0;i<viewShape[0];++i) {
296			viewData.push_back(0.0);
297			}
298			DataArrayView myView2(viewData,viewShape);
299			try {
300			myData.addTaggedValue(5,myView2);
301			assert(false);
302			}
303			catch (EsysException& e) {
304			//cout << e.what() << endl;
305			assert(true);
306			}
307			cout << "\tTest setTaggedValues." << endl;
308			DataTagged myData2;
309			myData2.reshapeDataPoint(myView.getShape());
310			keys.clear();
311			values.clear();
312			keys.push_back(1);
313			keys.push_back(2);
314			keys.push_back(3);
315			values.push_back(eOne.getView());
316			values.push_back(eTwo.getView());
317			values.push_back(eThree.getView());
318			myData2.setTaggedValues(keys,values);
319			assert(myData2.getDataPointByTag(1)==eOne.getView());
320			assert(myData2.getDataPointByTag(2)==eTwo.getView());
321			assert(myData2.getDataPointByTag(3)==eThree.getView());
322			cout << "\tTest setTaggedValue." << endl;
323			DataTagged myData3;
324			myData3.reshapeDataPoint(myView.getShape());
325			myData3.setTaggedValue(1,eOne.getView());
326			myData3.setTaggedValue(2,eTwo.getView());
327			myData3.setTaggedValue(3,eThree.getView());
328			assert(myData3.getDataPointByTag(1)==eOne.getView());
329			assert(myData3.getDataPointByTag(2)==eTwo.getView());
330			assert(myData3.getDataPointByTag(3)==eThree.getView());
331			}
332
333			}
334
335			void DataTaggedTestCase::testSubtraction() {
336
337			// An error with FinleyMesh::getTagList used to cause binary operations
338			// between DataExpanded and DataTagged objects to seg-fault. This test
339			// case will provoke this error if it arises again.
340
341	jgs	95	// This test requires the version of setTaggedData which takes a Data
342			// object as an argument. This version is not currently available, so
343			// this test is disabled for now
344
345			/*
346
347	jgs	82	cout << endl;
348
349			cout << "\tCreate domain and function-space." << endl;
350			AbstractContinuousDomain* myDomain = rectangle(10,10);
351			FunctionSpace f = functionOnBoundary(*myDomain);
352
353			cout << "\tCreate two vectors, one being DataExpanded." << endl;
354			Data A = Vector(0,f);
355			Data B = Vector(0,f,true);
356
357			cout << "\tCreate some tags and values to add to the other." << endl;
358			DataArrayView::ValueType viewData;
359			DataArrayView::ShapeType viewShape;
360			viewShape.push_back(2);
361			for (int i=0;i<viewShape[0];++i) {
362			viewData.push_back(0.0);
363			}
364			DataArrayView myView(viewData,viewShape);
365			DataArray eOne(myView);
366			for (int i=0;i<eOne.getView().getShape()[0];++i) {
367			eOne.getView()(i)=i+1.0;
368			}
369
370			A.setTaggedValue(2,eOne.getView());
371
372			//cout << A.toString() << endl;
373
374			cout << "\tCalculate difference." << endl;
375			Data difference = B - A;
376
377			cout << "\tCalculate other binaryOps just to be sure." << endl;
378			Data sum = B + A;
379			Data product = B * A;
380			Data dividend = B / A;
381
382			// If we get here, subtraction operation did not seg-fault.
383			assert(true);
384
385	jgs	95	*/
386
387	jgs	82	}
388
389			TestSuite* DataTaggedTestCase::suite ()
390			{
391			//
392			// create the suite of tests to perform.
393			TestSuite *testSuite = new TestSuite ("DataTaggedTestCase");
394			testSuite->addTest (new TestCaller< DataTaggedTestCase>("testAll",&DataTaggedTestCase::testAll));
395			testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));
396			testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));
397	jgs	95	//testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSubtraction",&DataTaggedTestCase::testSubtraction));
398	jgs	82	return testSuite;
399			}
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision