test/Data/DataTestCase.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 "esysUtils/EsysException.h"
#include "escript/Data/Data.h"
#include "escript/Data/FunctionSpace.h"

#include "DataTestCase.h"

#include <iostream>
#include <math.h>

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

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

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

void DataTestCase::testSlicing() {

  cout << endl;

  {
    DataArrayView::ShapeType viewShape;
    //
    // weak tests for slicing DataConstant
    cout << "\tTest slicing DataConstant" << endl;
    viewShape.push_back(2);
    viewShape.push_back(3);
    Data temp(1.3,viewShape,FunctionSpace(),false);
    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    Data slice(temp.getSlice(region));
    assert(slice.getDataPointRank()==0);
    assert(slice.getDataPoint(0,0)()==1.3);
    //
    // try the same but this time to produce a matrix containing one value
    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,1));
    region.push_back(DataArrayView::RegionType::value_type(0,1));
    slice=temp.getSlice(region);
    assert(slice.getDataPointRank()==2);
    assert(slice.getDataPoint(0,0)(0,0)==1.3);
  }

  {
    DataArrayView::ShapeType viewShape;
    //
    // weak tests for slicing DataExpanded
    cout << "\tTest slicing DataExpanded" << endl;
    viewShape.push_back(2);
    viewShape.push_back(3);
    Data temp(1.3,viewShape,FunctionSpace(),true);
    temp.getDataPoint(0,0)(0,0)=0.0;
    temp.getDataPoint(0,0)(1,1)=1.0;
    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    Data slice(temp.getSlice(region));
    assert(slice.getDataPointRank()==0);
    assert(slice.getDataPoint(0,0)()==0.0);
    //
    // try the same but this time to produce a matrix containing one value
    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,1));
    region.push_back(DataArrayView::RegionType::value_type(0,1));
    slice=temp.getSlice(region);
    assert(slice.getDataPointRank()==2);
    assert(slice.getDataPoint(0,0)(0,0)==0.0);
    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,2));
    region.push_back(DataArrayView::RegionType::value_type(0,2));
    slice=temp.getSlice(region);
    assert(slice.getDataPoint(0,0)(0,0)==0.0);
    assert(slice.getDataPoint(0,0)(1,1)==1.0);
  }

  {
    DataArrayView::ShapeType viewShape;
    //
    // weak tests for slicing DataTagged
    cout << "\tTest slicing DataTagged" << endl;
    viewShape.push_back(2);
    viewShape.push_back(3);
    Data temp(1.3,viewShape,FunctionSpace(),false);
    //
    // convert the data to tagged
    temp.tag();
    temp.getDataPoint(0,0)(0,0)=0.0;
    temp.getDataPoint(0,0)(1,1)=1.0;
    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    Data slice(temp.getSlice(region));
    assert(slice.getDataPointRank()==0);
    assert(slice.getDataPoint(0,0)()==0.0);
    //
    // try the same but this time to produce a matrix containing one value
    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,1));
    region.push_back(DataArrayView::RegionType::value_type(0,1));
    slice=temp.getSlice(region);
    assert(slice.getDataPointRank()==2);
    assert(slice.getDataPoint(0,0)(0,0)==0.0);
    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,2));
    region.push_back(DataArrayView::RegionType::value_type(0,2));
    slice=temp.getSlice(region);
    assert(slice.getDataPoint(0,0)(0,0)==0.0);
    assert(slice.getDataPoint(0,0)(1,1)==1.0);
  }

  {
    DataArrayView::ShapeType viewShape;
    Data source(10.0,viewShape,FunctionSpace(),false);
    //
    // weak tests for setting a slice of DataConstant
    cout << "\tTest slicing DataConstant" << endl;
    viewShape.push_back(2);
    viewShape.push_back(3);
    Data target(1.3,viewShape,FunctionSpace(),false);
    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    target.setSlice(source,region);
    assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());
  }

  {
    DataArrayView::ShapeType viewShape;
    Data source(10.0,viewShape,FunctionSpace(),true);
    //
    // weak tests for setting a slice of DataExpanded
    viewShape.push_back(2);
    viewShape.push_back(3);
    Data target(1.3,viewShape,FunctionSpace(),true);
    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    target.setSlice(source,region);
    assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());
  }

  {
    DataArrayView::ShapeType viewShape;
    Data source(10.0,viewShape,FunctionSpace(),false);
    source.tag();
    //
    // weak tests for slicing DataTagged
    cout << "\tTest slicing DataTagged" << endl;
    viewShape.push_back(2);
    viewShape.push_back(3);
    Data target(1.3,viewShape,FunctionSpace(),false);
    //
    // convert the data to tagged
    target.tag();
    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    target.setSlice(source,region);
    assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());
  }

}

void DataTestCase::testMore() {

  cout << endl;

  cout << "\tCreate a Data object from a DataArrayView" << endl;

  DataArrayView::ShapeType viewShape;
  viewShape.push_back(3);
  DataArrayView::ValueType viewData(3);
  for (int i=0;i<viewShape[0];++i) {
    viewData[i]=i;
  }
  DataArrayView myView(viewData,viewShape);

  bool expanded=true;
  Data exData(myView,FunctionSpace(),expanded);
  Data cData(myView);
  Data result;

  assert(exData.isExpanded());
  assert(cData.isConstant());
  assert(result.isEmpty());

  cout << "\tTest some basic operations" << endl;
  result=exData*cData;
  assert(result.isExpanded());

  assert(result.Lsup()==4);
  assert(result.sup()==4);
  assert(result.inf()==0);

  result=exData+cData;
  result=exData-cData;
  result=exData/cData;

  cout << "\tExercise wherePositive method" << endl;
  assert(!exData.wherePositive().isEmpty());

  cout << "\tExercise copyWithMask method" << endl;
  exData.copyWithMask(result, exData.wherePositive());
  assert(!exData.wherePositive().isEmpty());

}

void DataTestCase::testAll() {

  cout << endl;

  cout << "\tCreate a Data object from a DataArrayView" << endl;

  DataArrayView::ShapeType viewShape;
  viewShape.push_back(3);
  DataArrayView::ValueType viewData(3);
  for (int i=0;i<viewShape[0];++i) {
    viewData[i]=i;
  }
  DataArrayView myView(viewData,viewShape);

  bool expanded=true;

  Data exData(myView,FunctionSpace(),expanded);
  Data cData(myView);
  Data result;

  assert(exData.isExpanded());
  assert(cData.isConstant());
  assert(result.isEmpty());

  cout << "\tTest some basic operations" << endl;
  result=exData*cData;
  assert(result.isExpanded());

}

void DataTestCase::testDataConstant() {

  cout << endl;

  cout << "\tCreate a DataConstant object from a DataArrayView" << endl;

  DataArrayView::ShapeType viewShape;
  viewShape.push_back(2);
  viewShape.push_back(3);
  viewShape.push_back(4);
  DataArrayView::ValueType viewData(2*3*4);
  for (int i=0;i<DataArrayView::noValues(viewShape);++i) {
    viewData[i]=i;
  }
  DataArrayView myView(viewData,viewShape);

  Data left(myView);
  Data right(myView);
  Data result;

  cout << "\tTest some basic operations" << endl;

  result=left-right;

  assert(left.isConstant());
  assert(right.isConstant());
  assert(result.isConstant());

  result=left+right;

  assert(left.isConstant());
  assert(right.isConstant());
  assert(result.isConstant());

  assert(!result.isExpanded());
  assert(!result.isTagged());

}

void DataTestCase::testDataTaggedExceptions() {

  cout << endl;

  cout << "\tTest DataTagged operations exceptions." << endl;

  Data myData;
  DataArrayView myView;

  try {
      myData.getSampleDataByTag(0);;
      assert(false);
  }
  catch (EsysException& e) {
      //cout << e.what() << endl;
      assert(true);
  }

  /*
  try {
      myData.setTaggedValue(0,myView);;
      assert(false);
  }
  catch (EsysException& e) {
      //cout << e.what() << endl;
      assert(true);
  }
  */

}

void DataTestCase::testDataTagged() {

  cout << endl;

  cout << "\tCreate a DataTagged object from a DataArrayView" << endl;

  DataTagged::TagListType keys;
  DataTagged::ValueListType values;
  DataArrayView::ShapeType viewShape;
  viewShape.push_back(3);
  DataArrayView::ValueType viewData(3);
  for (int i=0;i<viewShape[0];++i) {
    viewData[i]=i;
  }
  DataArrayView myView(viewData,viewShape);

  // create tagged data with no tag values just a default
  bool expanded=false;

  Data myData(keys,values,myView,FunctionSpace(),expanded);
  assert(myData.isTagged());

  cout << "\tTest some basic operations" << endl;

  Data myDataCopy(myData);
  myDataCopy.expand();
  assert(myDataCopy.isExpanded());

}

void DataTestCase::testConstructors() {

  cout << endl;

  DataArrayView::ShapeType viewShape;
  {
    cout << "\tCreate an Empty Data object" << endl;
    Data temp(1.3,viewShape,FunctionSpace(),false);
  }
  {
    cout << "\tCreate a rank 2 Data object" << endl;
    viewShape.push_back(2);
    viewShape.push_back(3);
    Data temp(1.3,viewShape,FunctionSpace(),false);
  }
}

void DataTestCase::testOperations() {

  cout << endl;

  // define the shape for the DataArrayView test data
  DataArrayView::ShapeType shape;
  shape.push_back(2);
  shape.push_back(3);

  // allocate the data for the DataArrayView
  DataArrayView::ValueType data(DataArrayView::noValues(shape),0);

  // construct DataArrayView
  DataArrayView dataView(data,shape);

  // assign values to the data
  for (int i=0;i<shape[0];i++) {
    for (int j=0;j<shape[1];j++) {
      dataView(i,j)=dataView.index(i,j);
    }
  }

  Data base(dataView);

  // test unary operations

  cout << "\tTest Data::pow." << endl;
  Data power(3.0,shape,FunctionSpace(),true);
  Data result(base.powD(power));
  for (int i=0;i<shape[0];i++) {
    for (int j=0;j<shape[1];j++) {
      assert(result.getPointDataView()(i,j) == pow(dataView.index(i,j),3.0));
    }
  }

  cout << "\tTest Data::sin." << endl;
  result.copy(base.sin());
  assert(true);

  cout << "\tTest Data::cos." << endl;
  result.copy(base.cos());
  assert(true);

  cout << "\tTest Data::tan." << endl;
  result.copy(base.tan());
  assert(true);

  cout << "\tTest Data::asin." << endl;
  result.copy(base.asin());
  assert(true);

  cout << "\tTest Data::acos." << endl;
  result.copy(base.acos());
  assert(true);

  cout << "\tTest Data::atan." << endl;
  result.copy(base.atan());
  assert(true);

  cout << "\tTest Data::sinh." << endl;
  result.copy(base.sinh());
  assert(true);

  cout << "\tTest Data::cosh." << endl;
  result.copy(base.cosh());
  assert(true);

  cout << "\tTest Data::tanh." << endl;
  result.copy(base.tanh());
  assert(true);

  cout << "\tTest Data::asinh." << endl;
  result.copy(base.asinh());
  assert(true);

  cout << "\tTest Data::acosh." << endl;
  result.copy(base.acosh());
  assert(true);

  cout << "\tTest Data::atanh." << endl;
  result.copy(base.atanh());
  assert(true);

  cout << "\tTest Data::log." << endl;
  result.copy(base.log());
  assert(true);

  //cout << "\tTest Data::ln." << endl;
  //result.copy(base.ln());
  //assert(true);

  cout << "\tTest Data::abs." << endl;
  result.copy(base.abs());
  assert(true);

  cout << "\tTest Data::sign." << endl;
  result.copy(base.sign());
  assert(true);

  cout << "\tTest Data::exp." << endl;
  result.copy(base.exp());
  assert(true);

  cout << "\tTest Data::sqrt." << endl;
  result.copy(base.sqrt());
  assert(true);

  cout << "\tTest Data::neg." << endl;
  result.copy(base.neg());
  assert(true);

  cout << "\tTest Data::pos." << endl;
  result.copy(base.pos());
  for (int i=0;i<shape[0];i++) {
    for (int j=0;j<shape[1];j++) {
      assert(result.getPointDataView()(i,j) == dataView.index(i,j));
    }
  }

  // test reduction operations

  cout << "\tTest Data::Lsup." << endl;
  assert(base.Lsup() == 5);

  cout << "\tTest Data::sup." << endl;
  assert(base.sup() == 5);

  cout << "\tTest Data::inf." << endl;
  assert(base.inf() == 0);

  // test data-point reduction operations

  cout << "\tTest Data::minval." << endl;
  result.copy(base.minval());
  assert(result.getPointDataView()() == 0);

  cout << "\tTest Data::maxval." << endl;
  result.copy(base.maxval());
  assert(result.getPointDataView()() == 5);

  //cout << "\tTest Data::length." << endl;
  //result.copy(base.length());
  //assert(pow(result.getPointDataView()(),2.0) == 55);

  cout << "\tTest Data::trace." << endl;
  result.copy(base.trace());
  assert(result.getPointDataView()() == 15);

  //result.copy(base.transpose(0));
  //assert(true);

}

void DataTestCase::testRefValue() {

  //
  // Note - this test can't be run as boost::python::numeric::array
  // objects can only be created and used from within a python thread!
  //

  cout << endl;

  cout << "\tTest Data object RefValue methods." << endl;

  // Create three Data object - DataExpanded, DataConstant and DataEmpty
  DataArrayView::ShapeType viewShape;
  viewShape.push_back(3);
  DataArrayView::ValueType viewData(3);
  for (int i=0;i<viewShape[0];++i) {
    viewData[i]=i;
  }
  DataArrayView myView(viewData,viewShape);

  bool expanded=true;

  Data expandedData(myView,FunctionSpace(),expanded);
  Data constantData(myView);
  Data emptyData;

  assert(expandedData.isExpanded());
  assert(constantData.isConstant());
  assert(emptyData.isEmpty());

  // Check assertions are thrown for RefValue methods on DataEmpty

  int ref = 0;
  boost::python::numeric::array num_array(1.0);

  try {
      emptyData.getRefValue(ref,num_array);
      assert(false);
  }
  catch (EsysException& e) {
      assert(true);
  }
  try {
      emptyData.setRefValue(ref,num_array);
      assert(false);
  }
  catch (EsysException& e) {
      assert(true);
  }

  // Check assertions are thrown for RefValue methods on DataConstant
  try {
      constantData.getRefValue(ref,num_array);
      assert(false);
  }
  catch (EsysException& e) {
      assert(true);
  }
  try {
      constantData.setRefValue(ref,num_array);
      assert(false);
  }
  catch (EsysException& e) {
      assert(true);
  }

  // Check calls to RefValue methods on DataExpanded
  expandedData.getRefValue(ref,num_array);
  expandedData.setRefValue(ref,num_array);

}

void DataTestCase::testMemAlloc() {

  //
  // Simple little sanity check for the memory allocator

  cout << endl;

  Data *testData;
  for (int i=0; i<1000; i++) {
    testData = new Data(0.0, DataArrayView::ShapeType(), FunctionSpace(), true);
    delete testData;
  }

  DataArrayView::ShapeType viewShape;
  viewShape.push_back(10);
  viewShape.push_back(10);
  viewShape.push_back(10);

  Data *testData2;
  Data *testData3 = new Data(0.0, viewShape, FunctionSpace(), true);
  for (int i=0; i<1000; i++) {
    testData2 = new Data(0.0, viewShape, FunctionSpace(), true);
    delete testData2;
  }
  delete testData3;

}

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

  testSuite->addTest (new TestCaller< DataTestCase>("testAll",&DataTestCase::testAll));
  testSuite->addTest (new TestCaller< DataTestCase>("testMore",&DataTestCase::testMore));
  testSuite->addTest (new TestCaller< DataTestCase>("testDataConstant",&DataTestCase::testDataConstant));
  testSuite->addTest (new TestCaller< DataTestCase>("testDataTagged",&DataTestCase::testDataTagged));
  testSuite->addTest (new TestCaller< DataTestCase>("testDataTaggedExceptions",&DataTestCase::testDataTaggedExceptions));
  testSuite->addTest (new TestCaller< DataTestCase>("testConstructors",&DataTestCase::testConstructors));
  testSuite->addTest (new TestCaller< DataTestCase>("testSlicing",&DataTestCase::testSlicing));
  testSuite->addTest (new TestCaller< DataTestCase>("testOperations",&DataTestCase::testOperations));
  //testSuite->addTest (new TestCaller< DataTestCase>("testRefValue",&DataTestCase::testRefValue));
  testSuite->addTest (new TestCaller< DataTestCase>("testMemAlloc",&DataTestCase::testMemAlloc));

  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 "esysUtils/EsysException.h"
16			#include "escript/Data/Data.h"
17			#include "escript/Data/FunctionSpace.h"
18
19			#include "DataTestCase.h"
20
21			#include <iostream>
22	jgs	113	#include <math.h>
23	jgs	82
24			using namespace std;
25			using namespace CppUnitTest;
26			using namespace escript;
27			using namespace esysUtils;
28
29			void DataTestCase::setUp() {
30			//
31			// This is called before each test is run
32			}
33
34			void DataTestCase::tearDown() {
35			//
36			// This is called after each test has been run
37			}
38
39			void DataTestCase::testSlicing() {
40
41			cout << endl;
42
43			{
44			DataArrayView::ShapeType viewShape;
45			//
46			// weak tests for slicing DataConstant
47			cout << "\tTest slicing DataConstant" << endl;
48			viewShape.push_back(2);
49			viewShape.push_back(3);
50			Data temp(1.3,viewShape,FunctionSpace(),false);
51			DataArrayView::RegionType region;
52			region.push_back(DataArrayView::RegionType::value_type(0,0));
53			region.push_back(DataArrayView::RegionType::value_type(0,0));
54			Data slice(temp.getSlice(region));
55			assert(slice.getDataPointRank()==0);
56			assert(slice.getDataPoint(0,0)()==1.3);
57			//
58			// try the same but this time to produce a matrix containing one value
59			region.clear();
60			region.push_back(DataArrayView::RegionType::value_type(0,1));
61			region.push_back(DataArrayView::RegionType::value_type(0,1));
62			slice=temp.getSlice(region);
63			assert(slice.getDataPointRank()==2);
64			assert(slice.getDataPoint(0,0)(0,0)==1.3);
65			}
66
67			{
68			DataArrayView::ShapeType viewShape;
69			//
70			// weak tests for slicing DataExpanded
71			cout << "\tTest slicing DataExpanded" << endl;
72			viewShape.push_back(2);
73			viewShape.push_back(3);
74			Data temp(1.3,viewShape,FunctionSpace(),true);
75			temp.getDataPoint(0,0)(0,0)=0.0;
76			temp.getDataPoint(0,0)(1,1)=1.0;
77			DataArrayView::RegionType region;
78			region.push_back(DataArrayView::RegionType::value_type(0,0));
79			region.push_back(DataArrayView::RegionType::value_type(0,0));
80			Data slice(temp.getSlice(region));
81			assert(slice.getDataPointRank()==0);
82			assert(slice.getDataPoint(0,0)()==0.0);
83			//
84			// try the same but this time to produce a matrix containing one value
85			region.clear();
86			region.push_back(DataArrayView::RegionType::value_type(0,1));
87			region.push_back(DataArrayView::RegionType::value_type(0,1));
88			slice=temp.getSlice(region);
89			assert(slice.getDataPointRank()==2);
90			assert(slice.getDataPoint(0,0)(0,0)==0.0);
91			region.clear();
92			region.push_back(DataArrayView::RegionType::value_type(0,2));
93			region.push_back(DataArrayView::RegionType::value_type(0,2));
94			slice=temp.getSlice(region);
95			assert(slice.getDataPoint(0,0)(0,0)==0.0);
96			assert(slice.getDataPoint(0,0)(1,1)==1.0);
97			}
98
99			{
100			DataArrayView::ShapeType viewShape;
101			//
102			// weak tests for slicing DataTagged
103			cout << "\tTest slicing DataTagged" << endl;
104			viewShape.push_back(2);
105			viewShape.push_back(3);
106			Data temp(1.3,viewShape,FunctionSpace(),false);
107			//
108			// convert the data to tagged
109			temp.tag();
110			temp.getDataPoint(0,0)(0,0)=0.0;
111			temp.getDataPoint(0,0)(1,1)=1.0;
112			DataArrayView::RegionType region;
113			region.push_back(DataArrayView::RegionType::value_type(0,0));
114			region.push_back(DataArrayView::RegionType::value_type(0,0));
115			Data slice(temp.getSlice(region));
116			assert(slice.getDataPointRank()==0);
117			assert(slice.getDataPoint(0,0)()==0.0);
118			//
119			// try the same but this time to produce a matrix containing one value
120			region.clear();
121			region.push_back(DataArrayView::RegionType::value_type(0,1));
122			region.push_back(DataArrayView::RegionType::value_type(0,1));
123			slice=temp.getSlice(region);
124			assert(slice.getDataPointRank()==2);
125			assert(slice.getDataPoint(0,0)(0,0)==0.0);
126			region.clear();
127			region.push_back(DataArrayView::RegionType::value_type(0,2));
128			region.push_back(DataArrayView::RegionType::value_type(0,2));
129			slice=temp.getSlice(region);
130			assert(slice.getDataPoint(0,0)(0,0)==0.0);
131			assert(slice.getDataPoint(0,0)(1,1)==1.0);
132			}
133
134			{
135			DataArrayView::ShapeType viewShape;
136			Data source(10.0,viewShape,FunctionSpace(),false);
137			//
138			// weak tests for setting a slice of DataConstant
139			cout << "\tTest slicing DataConstant" << endl;
140			viewShape.push_back(2);
141			viewShape.push_back(3);
142			Data target(1.3,viewShape,FunctionSpace(),false);
143			DataArrayView::RegionType region;
144			region.push_back(DataArrayView::RegionType::value_type(0,0));
145			region.push_back(DataArrayView::RegionType::value_type(0,0));
146			target.setSlice(source,region);
147			assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());
148			}
149
150			{
151			DataArrayView::ShapeType viewShape;
152			Data source(10.0,viewShape,FunctionSpace(),true);
153			//
154	jgs	123	// weak tests for setting a slice of DataExpanded
155	jgs	82	viewShape.push_back(2);
156			viewShape.push_back(3);
157			Data target(1.3,viewShape,FunctionSpace(),true);
158			DataArrayView::RegionType region;
159			region.push_back(DataArrayView::RegionType::value_type(0,0));
160			region.push_back(DataArrayView::RegionType::value_type(0,0));
161			target.setSlice(source,region);
162			assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());
163			}
164
165			{
166			DataArrayView::ShapeType viewShape;
167			Data source(10.0,viewShape,FunctionSpace(),false);
168			source.tag();
169			//
170			// weak tests for slicing DataTagged
171			cout << "\tTest slicing DataTagged" << endl;
172			viewShape.push_back(2);
173			viewShape.push_back(3);
174			Data target(1.3,viewShape,FunctionSpace(),false);
175			//
176			// convert the data to tagged
177			target.tag();
178			DataArrayView::RegionType region;
179			region.push_back(DataArrayView::RegionType::value_type(0,0));
180			region.push_back(DataArrayView::RegionType::value_type(0,0));
181			target.setSlice(source,region);
182			assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());
183			}
184
185			}
186
187			void DataTestCase::testMore() {
188
189			cout << endl;
190
191			cout << "\tCreate a Data object from a DataArrayView" << endl;
192
193			DataArrayView::ShapeType viewShape;
194			viewShape.push_back(3);
195	jgs	121	DataArrayView::ValueType viewData(3);
196	jgs	82	for (int i=0;i<viewShape[0];++i) {
197	jgs	121	viewData[i]=i;
198	jgs	82	}
199			DataArrayView myView(viewData,viewShape);
200
201			bool expanded=true;
202			Data exData(myView,FunctionSpace(),expanded);
203			Data cData(myView);
204			Data result;
205
206			assert(exData.isExpanded());
207			assert(cData.isConstant());
208			assert(result.isEmpty());
209
210			cout << "\tTest some basic operations" << endl;
211			result=exData*cData;
212			assert(result.isExpanded());
213
214			assert(result.Lsup()==4);
215			assert(result.sup()==4);
216			assert(result.inf()==0);
217
218			result=exData+cData;
219			result=exData-cData;
220			result=exData/cData;
221
222			cout << "\tExercise wherePositive method" << endl;
223			assert(!exData.wherePositive().isEmpty());
224
225			cout << "\tExercise copyWithMask method" << endl;
226			exData.copyWithMask(result, exData.wherePositive());
227			assert(!exData.wherePositive().isEmpty());
228
229			}
230
231			void DataTestCase::testAll() {
232
233			cout << endl;
234
235			cout << "\tCreate a Data object from a DataArrayView" << endl;
236
237			DataArrayView::ShapeType viewShape;
238			viewShape.push_back(3);
239	jgs	121	DataArrayView::ValueType viewData(3);
240	jgs	82	for (int i=0;i<viewShape[0];++i) {
241	jgs	121	viewData[i]=i;
242	jgs	82	}
243			DataArrayView myView(viewData,viewShape);
244
245			bool expanded=true;
246
247			Data exData(myView,FunctionSpace(),expanded);
248			Data cData(myView);
249			Data result;
250	jgs	123
251	jgs	82	assert(exData.isExpanded());
252			assert(cData.isConstant());
253			assert(result.isEmpty());
254
255			cout << "\tTest some basic operations" << endl;
256			result=exData*cData;
257			assert(result.isExpanded());
258
259			}
260
261			void DataTestCase::testDataConstant() {
262
263			cout << endl;
264
265			cout << "\tCreate a DataConstant object from a DataArrayView" << endl;
266
267			DataArrayView::ShapeType viewShape;
268			viewShape.push_back(2);
269			viewShape.push_back(3);
270			viewShape.push_back(4);
271	jgs	121	DataArrayView::ValueType viewData(234);
272	jgs	82	for (int i=0;i<DataArrayView::noValues(viewShape);++i) {
273	jgs	121	viewData[i]=i;
274	jgs	82	}
275			DataArrayView myView(viewData,viewShape);
276
277			Data left(myView);
278			Data right(myView);
279			Data result;
280
281			cout << "\tTest some basic operations" << endl;
282
283			result=left-right;
284
285			assert(left.isConstant());
286			assert(right.isConstant());
287			assert(result.isConstant());
288
289			result=left+right;
290
291			assert(left.isConstant());
292			assert(right.isConstant());
293			assert(result.isConstant());
294
295			assert(!result.isExpanded());
296			assert(!result.isTagged());
297
298			}
299
300			void DataTestCase::testDataTaggedExceptions() {
301
302			cout << endl;
303
304			cout << "\tTest DataTagged operations exceptions." << endl;
305	jgs	123
306	jgs	82	Data myData;
307			DataArrayView myView;
308	jgs	123
309	jgs	82	try {
310			myData.getSampleDataByTag(0);;
311			assert(false);
312			}
313			catch (EsysException& e) {
314			//cout << e.what() << endl;
315			assert(true);
316			}
317	jgs	123
318	jgs	82	/*
319			try {
320			myData.setTaggedValue(0,myView);;
321			assert(false);
322			}
323			catch (EsysException& e) {
324			//cout << e.what() << endl;
325			assert(true);
326			}
327			*/
328
329			}
330
331			void DataTestCase::testDataTagged() {
332
333			cout << endl;
334
335			cout << "\tCreate a DataTagged object from a DataArrayView" << endl;
336
337			DataTagged::TagListType keys;
338			DataTagged::ValueListType values;
339			DataArrayView::ShapeType viewShape;
340			viewShape.push_back(3);
341	jgs	121	DataArrayView::ValueType viewData(3);
342	jgs	82	for (int i=0;i<viewShape[0];++i) {
343	jgs	121	viewData[i]=i;
344	jgs	82	}
345			DataArrayView myView(viewData,viewShape);
346
347			// create tagged data with no tag values just a default
348			bool expanded=false;
349
350			Data myData(keys,values,myView,FunctionSpace(),expanded);
351			assert(myData.isTagged());
352
353			cout << "\tTest some basic operations" << endl;
354
355			Data myDataCopy(myData);
356			myDataCopy.expand();
357			assert(myDataCopy.isExpanded());
358
359			}
360
361			void DataTestCase::testConstructors() {
362
363			cout << endl;
364
365			DataArrayView::ShapeType viewShape;
366			{
367			cout << "\tCreate an Empty Data object" << endl;
368			Data temp(1.3,viewShape,FunctionSpace(),false);
369			}
370			{
371			cout << "\tCreate a rank 2 Data object" << endl;
372			viewShape.push_back(2);
373			viewShape.push_back(3);
374			Data temp(1.3,viewShape,FunctionSpace(),false);
375			}
376			}
377
378			void DataTestCase::testOperations() {
379	jgs	113
380	jgs	82	cout << endl;
381
382	jgs	113	// define the shape for the DataArrayView test data
383			DataArrayView::ShapeType shape;
384			shape.push_back(2);
385			shape.push_back(3);
386	jgs	82
387	jgs	113	// allocate the data for the DataArrayView
388			DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
389	jgs	82
390	jgs	113	// construct DataArrayView
391			DataArrayView dataView(data,shape);
392	jgs	82
393	jgs	113	// assign values to the data
394			for (int i=0;i<shape[0];i++) {
395			for (int j=0;j<shape[1];j++) {
396			dataView(i,j)=dataView.index(i,j);
397			}
398			}
399
400			Data base(dataView);
401
402			// test unary operations
403
404			cout << "\tTest Data::pow." << endl;
405			Data power(3.0,shape,FunctionSpace(),true);
406	jgs	82	Data result(base.powD(power));
407	jgs	113	for (int i=0;i<shape[0];i++) {
408			for (int j=0;j<shape[1];j++) {
409			assert(result.getPointDataView()(i,j) == pow(dataView.index(i,j),3.0));
410			}
411			}
412	jgs	82
413	jgs	113	cout << "\tTest Data::sin." << endl;
414	jgs	82	result.copy(base.sin());
415	jgs	102	assert(true);
416
417	jgs	113	cout << "\tTest Data::cos." << endl;
418	jgs	82	result.copy(base.cos());
419	jgs	102	assert(true);
420
421	jgs	113	cout << "\tTest Data::tan." << endl;
422	jgs	82	result.copy(base.tan());
423	jgs	102	assert(true);
424
425	jgs	150	cout << "\tTest Data::asin." << endl;
426			result.copy(base.asin());
427			assert(true);
428
429			cout << "\tTest Data::acos." << endl;
430			result.copy(base.acos());
431			assert(true);
432
433			cout << "\tTest Data::atan." << endl;
434			result.copy(base.atan());
435			assert(true);
436
437			cout << "\tTest Data::sinh." << endl;
438			result.copy(base.sinh());
439			assert(true);
440
441			cout << "\tTest Data::cosh." << endl;
442			result.copy(base.cosh());
443			assert(true);
444
445			cout << "\tTest Data::tanh." << endl;
446			result.copy(base.tanh());
447			assert(true);
448
449			cout << "\tTest Data::asinh." << endl;
450			result.copy(base.asinh());
451			assert(true);
452
453			cout << "\tTest Data::acosh." << endl;
454			result.copy(base.acosh());
455			assert(true);
456
457			cout << "\tTest Data::atanh." << endl;
458			result.copy(base.atanh());
459			assert(true);
460
461	jgs	113	cout << "\tTest Data::log." << endl;
462	jgs	82	result.copy(base.log());
463	jgs	102	assert(true);
464
465	jgs	311	//cout << "\tTest Data::ln." << endl;
466			//result.copy(base.ln());
467			//assert(true);
468	jgs	102
469	jgs	113	cout << "\tTest Data::abs." << endl;
470	jgs	102	result.copy(base.abs());
471			assert(true);
472
473	jgs	113	cout << "\tTest Data::sign." << endl;
474	jgs	106	result.copy(base.sign());
475	jgs	102	assert(true);
476
477	jgs	113	cout << "\tTest Data::exp." << endl;
478	jgs	106	result.copy(base.exp());
479	jgs	102	assert(true);
480
481	jgs	113	cout << "\tTest Data::sqrt." << endl;
482	jgs	106	result.copy(base.sqrt());
483	jgs	102	assert(true);
484
485	jgs	113	cout << "\tTest Data::neg." << endl;
486	jgs	106	result.copy(base.neg());
487	jgs	102	assert(true);
488
489	jgs	113	cout << "\tTest Data::pos." << endl;
490	jgs	106	result.copy(base.pos());
491	jgs	113	for (int i=0;i<shape[0];i++) {
492			for (int j=0;j<shape[1];j++) {
493			assert(result.getPointDataView()(i,j) == dataView.index(i,j));
494			}
495			}
496	jgs	102
497	jgs	113	// test reduction operations
498
499			cout << "\tTest Data::Lsup." << endl;
500			assert(base.Lsup() == 5);
501
502			cout << "\tTest Data::sup." << endl;
503			assert(base.sup() == 5);
504
505			cout << "\tTest Data::inf." << endl;
506			assert(base.inf() == 0);
507
508			// test data-point reduction operations
509
510			cout << "\tTest Data::minval." << endl;
511	jgs	106	result.copy(base.minval());
512	jgs	113	assert(result.getPointDataView()() == 0);
513	jgs	102
514	jgs	113	cout << "\tTest Data::maxval." << endl;
515	jgs	106	result.copy(base.maxval());
516	jgs	113	assert(result.getPointDataView()() == 5);
517	jgs	102
518	jgs	311	//cout << "\tTest Data::length." << endl;
519			//result.copy(base.length());
520			//assert(pow(result.getPointDataView()(),2.0) == 55);
521	jgs	102
522	jgs	113	cout << "\tTest Data::trace." << endl;
523	jgs	106	result.copy(base.trace());
524	jgs	113	assert(result.getPointDataView()() == 15);
525	jgs	102
526	jgs	106	//result.copy(base.transpose(0));
527			//assert(true);
528
529	jgs	82	}
530
531	jgs	110	void DataTestCase::testRefValue() {
532
533			//
534			// Note - this test can't be run as boost::python::numeric::array
535	jgs	113	// objects can only be created and used from within a python thread!
536	jgs	110	//
537
538			cout << endl;
539
540			cout << "\tTest Data object RefValue methods." << endl;
541
542			// Create three Data object - DataExpanded, DataConstant and DataEmpty
543			DataArrayView::ShapeType viewShape;
544			viewShape.push_back(3);
545	jgs	121	DataArrayView::ValueType viewData(3);
546	jgs	110	for (int i=0;i<viewShape[0];++i) {
547	jgs	121	viewData[i]=i;
548	jgs	110	}
549			DataArrayView myView(viewData,viewShape);
550
551			bool expanded=true;
552
553			Data expandedData(myView,FunctionSpace(),expanded);
554			Data constantData(myView);
555			Data emptyData;
556
557			assert(expandedData.isExpanded());
558			assert(constantData.isConstant());
559			assert(emptyData.isEmpty());
560
561			// Check assertions are thrown for RefValue methods on DataEmpty
562
563			int ref = 0;
564			boost::python::numeric::array num_array(1.0);
565
566			try {
567			emptyData.getRefValue(ref,num_array);
568			assert(false);
569			}
570			catch (EsysException& e) {
571			assert(true);
572			}
573			try {
574			emptyData.setRefValue(ref,num_array);
575			assert(false);
576			}
577			catch (EsysException& e) {
578			assert(true);
579			}
580
581			// Check assertions are thrown for RefValue methods on DataConstant
582			try {
583			constantData.getRefValue(ref,num_array);
584			assert(false);
585			}
586			catch (EsysException& e) {
587			assert(true);
588			}
589			try {
590			constantData.setRefValue(ref,num_array);
591			assert(false);
592			}
593			catch (EsysException& e) {
594			assert(true);
595			}
596
597			// Check calls to RefValue methods on DataExpanded
598			expandedData.getRefValue(ref,num_array);
599			expandedData.setRefValue(ref,num_array);
600
601			}
602
603	jgs	151	void DataTestCase::testMemAlloc() {
604
605			//
606			// Simple little sanity check for the memory allocator
607
608			cout << endl;
609
610			Data *testData;
611			for (int i=0; i<1000; i++) {
612			testData = new Data(0.0, DataArrayView::ShapeType(), FunctionSpace(), true);
613			delete testData;
614			}
615
616			DataArrayView::ShapeType viewShape;
617			viewShape.push_back(10);
618			viewShape.push_back(10);
619			viewShape.push_back(10);
620
621			Data *testData2;
622			Data *testData3 = new Data(0.0, viewShape, FunctionSpace(), true);
623			for (int i=0; i<1000; i++) {
624			testData2 = new Data(0.0, viewShape, FunctionSpace(), true);
625			delete testData2;
626			}
627			delete testData3;
628
629			}
630
631	jgs	82	TestSuite* DataTestCase::suite ()
632			{
633			//
634			// create the suite of tests to perform.
635			TestSuite *testSuite = new TestSuite ("DataTestCase");
636
637			testSuite->addTest (new TestCaller< DataTestCase>("testAll",&DataTestCase::testAll));
638			testSuite->addTest (new TestCaller< DataTestCase>("testMore",&DataTestCase::testMore));
639			testSuite->addTest (new TestCaller< DataTestCase>("testDataConstant",&DataTestCase::testDataConstant));
640			testSuite->addTest (new TestCaller< DataTestCase>("testDataTagged",&DataTestCase::testDataTagged));
641			testSuite->addTest (new TestCaller< DataTestCase>("testDataTaggedExceptions",&DataTestCase::testDataTaggedExceptions));
642			testSuite->addTest (new TestCaller< DataTestCase>("testConstructors",&DataTestCase::testConstructors));
643			testSuite->addTest (new TestCaller< DataTestCase>("testSlicing",&DataTestCase::testSlicing));
644			testSuite->addTest (new TestCaller< DataTestCase>("testOperations",&DataTestCase::testOperations));
645	jgs	110	//testSuite->addTest (new TestCaller< DataTestCase>("testRefValue",&DataTestCase::testRefValue));
646	jgs	151	testSuite->addTest (new TestCaller< DataTestCase>("testMemAlloc",&DataTestCase::testMemAlloc));
647	jgs	82
648			return testSuite;
649			}
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision