escript/test/SharedDataTestCase.cpp

/*******************************************************
*
* Copyright (c) 2003-2008 by University of Queensland
* Earth Systems Science Computational Center (ESSCC)
* http://www.uq.edu.au/esscc
*
* Primary Business: Queensland, Australia
* Licensed under the Open Software License version 3.0
* http://www.opensource.org/licenses/osl-3.0.php
*
*******************************************************/

// The purpose of these tests is to check for unwanted sharing of between Data objects


#include "SharedDataTestCase.h"
#include "escript/Data.h"
#include "escript/EscriptParams.h"

#include <iostream>

using namespace escript;
using namespace std;
using namespace CppUnitTest;
using namespace escript::DataTypes;

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

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

// Create a data, involve it in a lazy expression. Then modify the original and see if the value of the lazy is affected.
#define TESTEQOP(OP) { Data d((double)42,DataTypes::scalarShape); Data L=d.delay(); L-=Data((double)42,DataTypes::scalarShape); d OP Data(2,DataTypes::scalarShape); assert(L.Lsup()<0.001);} 

// Test if the copy constructor shares a DataAbstract with its originator
void SharedDataTestCase::testEQ()
{
  cout << endl << "Testing +=" << flush;
  TESTEQOP(+=)
  cout << "\tOK" << endl << "Testing -=";
  TESTEQOP(-=)
  cout << "\tOK" << endl << "Testing *=";
  TESTEQOP(*=)
  cout << "\tOK" << endl << "Testing /=";
  TESTEQOP(/=)
}

// Test for shared data caused by using a copy constructor
void SharedDataTestCase::testCC()
{
  cout << endl;
  Data d(42, DataTypes::scalarShape);
  Data shared(d);
  d+=Data(20,DataTypes::scalarShape);
  shared-=Data(42,DataTypes::scalarShape);
  assert(shared.Lsup()<0.001);
}

// Test for shared data caused by using = operator
void SharedDataTestCase::testAssign()
{
  cout << endl;
  Data d(42, DataTypes::scalarShape);
  Data shared=d;
  d+=Data(20,DataTypes::scalarShape);
  shared-=Data(42,DataTypes::scalarShape);
  assert(shared.Lsup()<0.001);
}

void SharedDataTestCase::testSetToZero()
{
  Data d((double)42,DataTypes::scalarShape); 
  Data L=d.delay(); 
  L-=Data((double)42,DataTypes::scalarShape);
  d.setToZero();
  assert(L.Lsup()<0.001);
}

void SharedDataTestCase::testSetTaggedValueFromCPP()
{
  Data d((double)42,DataTypes::scalarShape);
  d.tag(); 
  Data L=d.delay();
  ValueType v(1,17);
  d.setTaggedValueFromCPP(1,DataTypes::scalarShape,v);
  L.resolve();
  // at this point, d should have a tag and L should not
  // unfortunately its a little tricky to find out what tags a Data object has so I'll use strings
  string s=L.toString();
  assert(s.find("Tag(1)")==string::npos);       // if the tag shows up we have shared data
}

void SharedDataTestCase::testGetDataAtOffset()
{
  Data d((double)42,DataTypes::scalarShape);
  Data L=d.delay();
  // now change the data directly
  d.getDataAtOffsetRW(0)=17;
  assert(L.getDataAtOffsetRO(0)==42);
}

void SharedDataTestCase::testGetDataPoint()
{
  Data d((double)42,DataTypes::scalarShape);
  Data L=d.delay();
  // now change the data directly
  d.getDataPointRW(0,0)=17;
  assert(L.getDataPointRO(0,0)==42);
}

void SharedDataTestCase::testGetSampleRW()
{
  Data d((double)42,DataTypes::scalarShape);
  Data L=d.delay();
  // now change the data directly
  try
  {
    *d.getSampleDataRW(0)=17;
    assert(false);          // should have thrown 
  } catch (DataException e)
  {
  }
  // Now try again properly 
  d.requireWrite();
  *d.getSampleDataRW(0)=17;
  L.resolve();
  assert(*L.getSampleDataRO(0)==42);
}

TestSuite* SharedDataTestCase::suite ()
{
  //
  // create the suite of tests to perform.
  TestSuite *testSuite = new TestSuite ("SharedDataTestCase");

  testSuite->addTest (new TestCaller< SharedDataTestCase>("Arithmetic Assignment operators",&SharedDataTestCase::testEQ));
  testSuite->addTest (new TestCaller< SharedDataTestCase>("Copy Constructor",&SharedDataTestCase::testCC));
  testSuite->addTest (new TestCaller< SharedDataTestCase>("Assignment operator",&SharedDataTestCase::testAssign));
  testSuite->addTest (new TestCaller< SharedDataTestCase>("setToZero",&SharedDataTestCase::testSetToZero));
  testSuite->addTest (new TestCaller< SharedDataTestCase>("setTaggedValueFromCPP",&SharedDataTestCase::testSetTaggedValueFromCPP));
  testSuite->addTest (new TestCaller< SharedDataTestCase>("getDataAtOffset",&SharedDataTestCase::testGetDataAtOffset));
  testSuite->addTest (new TestCaller< SharedDataTestCase>("getDataPoint",&SharedDataTestCase::testGetDataPoint));
  testSuite->addTest (new TestCaller< SharedDataTestCase>("getSampleRW",&SharedDataTestCase::testGetSampleRW));
  return testSuite;
}
1	/*******************************************************
2	*
3	* Copyright (c) 2003-2008 by University of Queensland
4	* Earth Systems Science Computational Center (ESSCC)
5	* http://www.uq.edu.au/esscc
6	*
7	* Primary Business: Queensland, Australia
8	* Licensed under the Open Software License version 3.0
9	* http://www.opensource.org/licenses/osl-3.0.php
10	*
11	*******************************************************/
12
13	// The purpose of these tests is to check for unwanted sharing of between Data objects
14
15
16	#include "SharedDataTestCase.h"
17	#include "escript/Data.h"
18	#include "escript/EscriptParams.h"
19
20	#include <iostream>
21
22	using namespace escript;
23	using namespace std;
24	using namespace CppUnitTest;
25	using namespace escript::DataTypes;
26
27	void SharedDataTestCase::setUp()
28	{
29	//
30	// This is called before each test is run
31	}
32
33	void SharedDataTestCase::tearDown()
34	{
35	//
36	// This is called after each test has been run
37	}
38
39	// Create a data, involve it in a lazy expression. Then modify the original and see if the value of the lazy is affected.
40	#define TESTEQOP(OP) { Data d((double)42,DataTypes::scalarShape); Data L=d.delay(); L-=Data((double)42,DataTypes::scalarShape); d OP Data(2,DataTypes::scalarShape); assert(L.Lsup()<0.001);}
41
42	// Test if the copy constructor shares a DataAbstract with its originator
43	void SharedDataTestCase::testEQ()
44	{
45	cout << endl << "Testing +=" << flush;
46	TESTEQOP(+=)
47	cout << "\tOK" << endl << "Testing -=";
48	TESTEQOP(-=)
49	cout << "\tOK" << endl << "Testing *=";
50	TESTEQOP(*=)
51	cout << "\tOK" << endl << "Testing /=";
52	TESTEQOP(/=)
53	}
54
55	// Test for shared data caused by using a copy constructor
56	void SharedDataTestCase::testCC()
57	{
58	cout << endl;
59	Data d(42, DataTypes::scalarShape);
60	Data shared(d);
61	d+=Data(20,DataTypes::scalarShape);
62	shared-=Data(42,DataTypes::scalarShape);
63	assert(shared.Lsup()<0.001);
64	}
65
66	// Test for shared data caused by using = operator
67	void SharedDataTestCase::testAssign()
68	{
69	cout << endl;
70	Data d(42, DataTypes::scalarShape);
71	Data shared=d;
72	d+=Data(20,DataTypes::scalarShape);
73	shared-=Data(42,DataTypes::scalarShape);
74	assert(shared.Lsup()<0.001);
75	}
76
77	void SharedDataTestCase::testSetToZero()
78	{
79	Data d((double)42,DataTypes::scalarShape);
80	Data L=d.delay();
81	L-=Data((double)42,DataTypes::scalarShape);
82	d.setToZero();
83	assert(L.Lsup()<0.001);
84	}
85
86	void SharedDataTestCase::testSetTaggedValueFromCPP()
87	{
88	Data d((double)42,DataTypes::scalarShape);
89	d.tag();
90	Data L=d.delay();
91	ValueType v(1,17);
92	d.setTaggedValueFromCPP(1,DataTypes::scalarShape,v);
93	L.resolve();
94	// at this point, d should have a tag and L should not
95	// unfortunately its a little tricky to find out what tags a Data object has so I'll use strings
96	string s=L.toString();
97	assert(s.find("Tag(1)")==string::npos); // if the tag shows up we have shared data
98	}
99
100	void SharedDataTestCase::testGetDataAtOffset()
101	{
102	Data d((double)42,DataTypes::scalarShape);
103	Data L=d.delay();
104	// now change the data directly
105	d.getDataAtOffsetRW(0)=17;
106	assert(L.getDataAtOffsetRO(0)==42);
107	}
108
109	void SharedDataTestCase::testGetDataPoint()
110	{
111	Data d((double)42,DataTypes::scalarShape);
112	Data L=d.delay();
113	// now change the data directly
114	d.getDataPointRW(0,0)=17;
115	assert(L.getDataPointRO(0,0)==42);
116	}
117
118	void SharedDataTestCase::testGetSampleRW()
119	{
120	Data d((double)42,DataTypes::scalarShape);
121	Data L=d.delay();
122	// now change the data directly
123	try
124	{
125	*d.getSampleDataRW(0)=17;
126	assert(false); // should have thrown
127	} catch (DataException e)
128	{
129	}
130	// Now try again properly
131	d.requireWrite();
132	*d.getSampleDataRW(0)=17;
133	L.resolve();
134	assert(*L.getSampleDataRO(0)==42);
135	}
136
137	TestSuite* SharedDataTestCase::suite ()
138	{
139	//
140	// create the suite of tests to perform.
141	TestSuite *testSuite = new TestSuite ("SharedDataTestCase");
142
143	testSuite->addTest (new TestCaller< SharedDataTestCase>("Arithmetic Assignment operators",&SharedDataTestCase::testEQ));
144	testSuite->addTest (new TestCaller< SharedDataTestCase>("Copy Constructor",&SharedDataTestCase::testCC));
145	testSuite->addTest (new TestCaller< SharedDataTestCase>("Assignment operator",&SharedDataTestCase::testAssign));
146	testSuite->addTest (new TestCaller< SharedDataTestCase>("setToZero",&SharedDataTestCase::testSetToZero));
147	testSuite->addTest (new TestCaller< SharedDataTestCase>("setTaggedValueFromCPP",&SharedDataTestCase::testSetTaggedValueFromCPP));
148	testSuite->addTest (new TestCaller< SharedDataTestCase>("getDataAtOffset",&SharedDataTestCase::testGetDataAtOffset));
149	testSuite->addTest (new TestCaller< SharedDataTestCase>("getDataPoint",&SharedDataTestCase::testGetDataPoint));
150	testSuite->addTest (new TestCaller< SharedDataTestCase>("getSampleRW",&SharedDataTestCase::testGetSampleRW));
151	return testSuite;
152	}