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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 474 - (hide annotations)
Mon Jan 30 04:23:44 2006 UTC (13 years, 10 months ago) by jgs
Original Path: trunk/escript/test/DataTagged/DataTaggedTestCase.cpp
File size: 11374 byte(s)
restructure escript source tree
move src/Data/* -> src
remove inc
modify #includes and cpppath settings accordingly

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 jgs 474 #include "DataTagged.h"
16     #include "BinaryOp.h"
17     #include "UnaryOp.h"
18 jgs 468 #include "EsysException.h"
19 jgs 82
20 jgs 474 #include "FunctionSpaceFactory.h"
21     #include "DataFactory.h"
22 jgs 82
23     #include "DataTaggedTestCase.h"
24    
25     #include <iostream>
26     #include <functional>
27     #include <algorithm>
28    
29     using namespace CppUnitTest;
30     using namespace escript;
31     using namespace esysUtils;
32     using namespace std;
33    
34     void DataTaggedTestCase::setUp() {
35     //
36     // This is called before each test is run
37    
38     }
39    
40     void DataTaggedTestCase::tearDown() {
41     //
42     // This is called after each test has been run
43    
44     }
45    
46     void DataTaggedTestCase::testReshape() {
47    
48     cout << endl;
49    
50     {
51     cout << "\tTest reshape of default constructed DataTagged to rank 1." << endl;
52     DataTagged value;
53     value.getPointDataView()()=1.0;
54     DataArrayView::ShapeType shape;
55     shape.push_back(2);
56     value.reshapeDataPoint(shape);
57     for (int i=0;i<shape[0];++i) {
58     assert(value.getDefaultValue()(i)==1);
59     }
60     }
61     {
62     cout << "\tTest reshape of default constructed DataTagged to rank 2." << endl;
63     DataTagged value;
64     value.getPointDataView()()=0.0;
65     DataArray vOne(1.0);
66     DataArray vTwo(2.0);
67     value.addTaggedValue(1,vOne.getView());
68     value.addTaggedValue(2,vTwo.getView());
69     DataArrayView::ShapeType shape;
70     shape.push_back(2);
71     shape.push_back(5);
72     value.reshapeDataPoint(shape);
73     for (int j=0;j<shape[1];++j) {
74     for (int i=0;i<shape[0];++i) {
75     assert(value.getDefaultValue()(i,j)==0.0);
76     assert(value.getDataPointByTag(1)(i,j)==vOne.getView()());
77     assert(value.getDataPointByTag(2)(i,j)==vTwo.getView()());
78     }
79     }
80     }
81     }
82    
83     void DataTaggedTestCase::testOperations() {
84    
85     cout << endl;
86    
87     {
88     DataTagged left;
89     DataTagged right;
90 jgs 121
91     cout << "\tTest default DataTagged contains only a default value." << endl;
92 jgs 82 binaryOp(left,right,plus<double>());
93     assert(left.getPointDataView()()==0);
94     assert(right.getPointDataView()()==0);
95 jgs 121
96     cout << "\tTest binaryOp(plus)." << endl;
97 jgs 82 DataArray vOne(1.0);
98     DataArray vTwo(2.0);
99     right.addTaggedValue(1,vOne.getView());
100     right.addTaggedValue(2,vTwo.getView());
101     binaryOp(left,right,plus<double>());
102     assert(left.getPointDataView()()==0);
103     assert(left.getDataPointByTag(1)==vOne.getView());
104     assert(left.getDataPointByTag(2)==vTwo.getView());
105 jgs 121
106     cout << "\tTest binaryOp(multiplies)." << endl;
107 jgs 82 DataArray vZero(0.0);
108     right.setTaggedValue(1,vZero.getView());
109     right.setTaggedValue(2,vZero.getView());
110     binaryOp(left,right,multiplies<double>());
111     assert(left.getPointDataView()()==0);
112     assert(left.getDataPointByTag(1)==vZero.getView());
113     assert(left.getDataPointByTag(2)==vZero.getView());
114     }
115     {
116     DataArrayView::ShapeType viewShape;
117     viewShape.push_back(3);
118 jgs 121 DataArrayView::ValueType viewData(3);
119 jgs 82 DataTagged::TagListType keys;
120     DataTagged::ValueListType values;
121     for (int i=0;i<viewShape[0];++i) {
122 jgs 121 viewData[i]=i;
123 jgs 82 }
124     DataArrayView myView(viewData,viewShape);
125     cout << "\tCreate tagged data with no tag values just a default." << endl;
126     DataTagged left(keys,values,myView,FunctionSpace());
127     DataTagged right(keys,values,myView,FunctionSpace());
128     binaryOp(left,right,minus<double>());
129     for (int i=0;i<viewShape[0];++i) {
130     assert(left.getDefaultValue()(i)==0);
131     }
132     double mVal=10.0;
133     for (int i=0;i<viewShape[0];++i) {
134     viewData[i]=i*mVal;
135     }
136     cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;
137     binaryOp(left,myView,minus<double>());
138     for (int i=0;i<viewShape[0];++i) {
139     assert(left.getDefaultValue()(i)==-(i*mVal));
140     }
141     }
142     {
143     cout << "\tTest unaryOp(negate) on default DataTagged." << endl;
144     DataTagged data;
145     unaryOp(data,negate<double>());
146     assert(data.getDefaultValue()()==0);
147     DataArray vOne(1);
148     binaryOp(data,vOne.getView(),plus<double>());
149     assert(data.getDefaultValue()()==1);
150     unaryOp(data,negate<double>());
151     assert(data.getDefaultValue()()==-1);
152     }
153     {
154     cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;
155     DataArrayView::ShapeType vShape;
156     vShape.push_back(3);
157     vShape.push_back(2);
158     vShape.push_back(1);
159     DataArray defData(vShape,0.0);
160     DataArrayView& defView=defData.getView();
161     DataArray tOneData(vShape,1.0);
162     DataArrayView& tOneView=tOneData.getView();
163     DataArray tTwoData(vShape,2.0);
164     DataArrayView& tTwoView=tTwoData.getView();
165     DataArray tThreeData(vShape,3.0);
166     DataArrayView& tThreeView=tThreeData.getView();
167     DataTagged::TagListType keys;
168     DataTagged::ValueListType values;
169     keys.push_back(1);
170     keys.push_back(2);
171     keys.push_back(3);
172     values.push_back(tOneView);
173     values.push_back(tTwoView);
174     values.push_back(tThreeView);
175     DataTagged tData(keys,values,defView,FunctionSpace());
176     unaryOp(tData,negate<double>());
177     unaryOp(tData,negate<double>());
178     assert(tData.getDataPointByTag(1)==tOneView);
179     assert(tData.getDataPointByTag(2)==tTwoView);
180     assert(tData.getDataPointByTag(3)==tThreeView);
181     }
182     }
183    
184     void DataTaggedTestCase::testAll() {
185 jgs 121
186 jgs 82 cout << endl;
187 jgs 121
188 jgs 82 {
189     cout << "\tTest default construction." << endl;
190     DataTagged myData;
191     assert(myData.getPointDataView()()==0);
192     assert(myData.getNumDPPSample()==1);
193     assert(myData.getNumSamples()==1);
194     cout << "\tTest adding two keys with empty value list." << endl;
195     DataTagged::TagListType keys;
196     DataTagged::ValueListType values;
197     keys.push_back(1);
198     keys.push_back(2);
199     myData.addTaggedValues(keys,values);
200     for (int i=0;i<keys.size();++i) {
201     assert(myData.getPointDataView()()==0);
202     }
203     }
204     {
205     DataArrayView::ShapeType viewShape;
206     viewShape.push_back(3);
207 jgs 121 DataArrayView::ValueType viewData(3);
208 jgs 82 DataTagged::TagListType keys;
209     DataTagged::ValueListType values;
210     for (int i=0;i<viewShape[0];++i) {
211 jgs 121 viewData[i]=0.0;
212 jgs 82 }
213     DataArrayView myView(viewData,viewShape);
214     cout << "\tCreate tagged data with no tag values just a default." << endl;
215     DataTagged myData(keys,values,myView,FunctionSpace());
216     assert(myData.getNumDPPSample()==1);
217     assert(myData.getNumSamples()==1);
218     cout << "\tTest non existent tag returns the default value." << endl;
219     assert(myData.getDataPointByTag(1)==myView);
220     cout << "\tTest adding a single tag value." << endl;
221     for (int i=0;i<myView.getShape()[0];++i) {
222     myView(i)=i;
223     }
224     values.push_back(myView);
225     keys.push_back(1);
226     myData.addTaggedValues(keys,values);
227     assert(myData.getDataPointByTag(1)==myView);
228     cout << "\tTest addition of further tags." << endl;
229 jgs 117 keys.resize(0);
230 jgs 82 keys.push_back(3);
231     for (int i=0;i<myView.getShape()[0];++i) {
232     myView(i)=i+1.5;
233     }
234     myData.addTaggedValues(keys,values);
235     assert(myData.getDataPointByTag(3)==myView);
236     assert(myData.getDataPointByTag(1)!=myView);
237     cout << "\tTrigger the size mismatch exception." << endl;
238     try {
239     values.push_back(myView);
240     myData.addTaggedValues(keys,values);
241     assert(false);
242     }
243     catch (EsysException& e) {
244     assert(true);
245     }
246     }
247     {
248     cout << "\tTest creation of tagged data with multiple tags." << endl;
249     DataArrayView::ShapeType viewShape;
250     viewShape.push_back(3);
251 jgs 121 DataArrayView::ValueType viewData(3);
252 jgs 82 DataTagged::TagListType keys;
253     DataTagged::ValueListType values;
254     for (int i=0;i<viewShape[0];++i) {
255 jgs 121 viewData[i]=0.0;
256 jgs 82 }
257     DataArrayView myView(viewData,viewShape);
258     DataArray eOne(myView);
259     DataArray eTwo(myView);
260     DataArray eThree(myView);
261     for (int i=0;i<eOne.getView().getShape()[0];++i) {
262     eOne.getView()(i)=i+1.0;
263     }
264     for (int i=0;i<eTwo.getView().getShape()[0];++i) {
265     eTwo.getView()(i)=i+2.0;
266     }
267     for (int i=0;i<eThree.getView().getShape()[0];++i) {
268     eThree.getView()(i)=i+3.0;
269     }
270     values.push_back(eOne.getView());
271     values.push_back(eTwo.getView());
272     values.push_back(eThree.getView());
273     keys.push_back(1);
274     keys.push_back(2);
275     keys.push_back(3);
276     DataTagged myData(keys,values,myView,FunctionSpace());
277     assert(myData.getDataPointByTag(1)==eOne.getView());
278     assert(myData.getDataPointByTag(2)==eTwo.getView());
279     assert(myData.getDataPointByTag(3)==eThree.getView());
280     cout << "\tTest isCurrentTag function." << endl;
281     for (int i=0;i<keys.size();++i) {
282     assert(myData.isCurrentTag(keys[i]));
283     }
284     cout << "\tCheck correct operation for key that doesn't exist." << endl;
285     assert(!myData.isCurrentTag(123));
286     cout << "\tTrigger bad shape in input values exception." << endl;
287     viewShape.clear();
288     viewShape.push_back(1);
289     keys.clear();
290     values.clear();
291 jgs 121 viewData.resize(1,0.0);
292 jgs 82 DataArrayView myView2(viewData,viewShape);
293     try {
294     myData.addTaggedValue(5,myView2);
295     assert(false);
296     }
297     catch (EsysException& e) {
298     assert(true);
299     }
300 jgs 121 cout << "\tTest addTaggedValues." << endl;
301 jgs 82 DataTagged myData2;
302     myData2.reshapeDataPoint(myView.getShape());
303     keys.clear();
304     values.clear();
305     keys.push_back(1);
306     keys.push_back(2);
307     keys.push_back(3);
308     values.push_back(eOne.getView());
309     values.push_back(eTwo.getView());
310     values.push_back(eThree.getView());
311 jgs 121 myData2.addTaggedValues(keys,values);
312 jgs 82 assert(myData2.getDataPointByTag(1)==eOne.getView());
313     assert(myData2.getDataPointByTag(2)==eTwo.getView());
314     assert(myData2.getDataPointByTag(3)==eThree.getView());
315     cout << "\tTest setTaggedValue." << endl;
316     DataTagged myData3;
317     myData3.reshapeDataPoint(myView.getShape());
318 jgs 121 myData3.addTaggedValue(1,eThree.getView());
319     myData3.addTaggedValue(2,eOne.getView());
320     myData3.addTaggedValue(3,eTwo.getView());
321 jgs 82 myData3.setTaggedValue(1,eOne.getView());
322     myData3.setTaggedValue(2,eTwo.getView());
323     myData3.setTaggedValue(3,eThree.getView());
324     assert(myData3.getDataPointByTag(1)==eOne.getView());
325     assert(myData3.getDataPointByTag(2)==eTwo.getView());
326     assert(myData3.getDataPointByTag(3)==eThree.getView());
327     }
328    
329     }
330    
331     TestSuite* DataTaggedTestCase::suite ()
332     {
333     //
334     // create the suite of tests to perform.
335     TestSuite *testSuite = new TestSuite ("DataTaggedTestCase");
336     testSuite->addTest (new TestCaller< DataTaggedTestCase>("testAll",&DataTaggedTestCase::testAll));
337     testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));
338     testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));
339     return testSuite;
340     }

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26