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 "DataTestCase.h"

#include "FunctionSpace.h"
#include "EsysException.h"

#include "Data.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;

  {

    cout << "\tTest get-slicing DataConstant" << endl;

    DataArrayView::ShapeType viewShape;
    viewShape.push_back(2);
    viewShape.push_back(3);
    Data data(1.3,viewShape,FunctionSpace(),false);

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

    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    region.push_back(DataArrayView::RegionType::value_type(0,0));

    Data slice1(data.getSlice(region));

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

    assert(slice1.getDataPointRank()==0);
    assert(slice1.getDataPoint(0,0)()==1.3);

    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,1));
    region.push_back(DataArrayView::RegionType::value_type(0,1));

    Data slice2(data.getSlice(region));

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

    assert(slice2.getDataPointRank()==2);
    assert(slice2.getDataPoint(0,0)(0,0)==1.3);

    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,1));
    region.push_back(DataArrayView::RegionType::value_type(0,2));

    Data slice3(data.getSlice(region));

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

    assert(slice3.getDataPointRank()==2);
    assert(slice3.getDataPoint(0,0)(0,0)==1.3);
    assert(slice3.getDataPoint(0,0)(0,1)==1.3);

  }

  {

    cout << "\tTest set-slicing DataConstant" << endl;

    DataArrayView::ShapeType viewShape;
    Data source(10.0,viewShape,FunctionSpace(),false);

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

    viewShape.push_back(2);
    viewShape.push_back(3);
    Data target(1.3,viewShape,FunctionSpace(),false);

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

    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);

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

    assert(target.getDataPoint(0,0)(0,0)==source.getDataPoint(0,0)());

  }

  {

    cout << "\tTest get-slicing DataTagged" << endl;

    //
    // create a DataTagged with a default value only

    DataArrayView::ShapeType viewShape;
    viewShape.push_back(2);
    viewShape.push_back(3);
    Data data(1.3,viewShape,FunctionSpace(),false);
    data.tag();
    data.getDataPoint(0,0)(0,0)=1.0;
    data.getDataPoint(0,0)(1,1)=2.0;

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

    //
    // create a scalar slice

    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    region.push_back(DataArrayView::RegionType::value_type(0,0));

    Data slice1(data.getSlice(region));

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

    assert(slice1.isTagged());
    assert(slice1.getDataPointRank()==0);
    assert(slice1.getDataPoint(0,0)()==1.0);

    //
    // create a rank 2 slice with one value

    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,1));
    region.push_back(DataArrayView::RegionType::value_type(0,1));

    Data slice2(data.getSlice(region));

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

    assert(slice2.isTagged());
    assert(slice2.getDataPointRank()==2);
    assert(slice2.getDataPoint(0,0)(0,0)==1.0);

    //
    // create a rank 2 slice with four values

    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,2));
    region.push_back(DataArrayView::RegionType::value_type(0,2));

    Data slice3(data.getSlice(region));

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

    assert(slice3.isTagged());
    assert(slice3.getDataPointRank()==2);
    assert(slice3.getDataPoint(0,0)(0,0)==1.0);
    assert(slice3.getDataPoint(0,0)(0,1)==1.3);
    assert(slice3.getDataPoint(0,0)(1,0)==1.3);
    assert(slice3.getDataPoint(0,0)(1,1)==2.0);

    //
    // add a value for tag "1"

    DataArrayView::ValueType viewData(6);
    for (int i=0;i<viewData.size();i++) {
      viewData[i]=i;
    }
    DataArrayView dataView(viewData,viewShape);

    data.setTaggedValueFromCPP(1, dataView);

    //
    // create a full slice

    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,2));
    region.push_back(DataArrayView::RegionType::value_type(0,3));

    Data slice4(data.getSlice(region));

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

    assert(slice4.isTagged());
    assert(slice4.getDataPointRank()==2);
    assert(slice4.getDataPoint(0,0)(0,0)==0);
    assert(slice4.getDataPoint(0,0)(0,1)==2);
    assert(slice4.getDataPoint(0,0)(0,2)==4);
    assert(slice4.getDataPoint(0,0)(1,0)==1);
    assert(slice4.getDataPoint(0,0)(1,1)==3);
    assert(slice4.getDataPoint(0,0)(1,2)==5);

  }

  {

    cout << "\tTest set-slicing DataTagged" << endl;

    //
    // create a DataTagged with a scalar default value only

    DataArrayView::ShapeType viewShape;
    Data source(10.0,viewShape,FunctionSpace(),false);
    source.tag();

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

    //
    // create a DataTagged with a rank 2 default value only

    viewShape.push_back(2);
    viewShape.push_back(3);
    Data target(1.3,viewShape,FunctionSpace(),false);
    target.tag();

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

    //
    // set a slice in target from source

    DataArrayView::RegionType region;
    region.push_back(DataArrayView::RegionType::value_type(1,1));
    region.push_back(DataArrayView::RegionType::value_type(1,1));

    target.setSlice(source,region);

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

    assert(target.isTagged());
    assert(target.getDataPointRank()==2);
    assert(target.getDataPoint(0,0)(0,0)==1.3);
    assert(target.getDataPoint(0,0)(0,1)==1.3);
    assert(target.getDataPoint(0,0)(0,2)==1.3);
    assert(target.getDataPoint(0,0)(1,0)==1.3);
    assert(target.getDataPoint(0,0)(1,1)==source.getDataPoint(0,0)());
    assert(target.getDataPoint(0,0)(1,2)==1.3);

    //
    // add a value for tag "1"

    DataArrayView::ValueType viewData(6);
    for (int i=0;i<viewData.size();i++) {
      viewData[i]=i;
    }
    DataArrayView dataView(viewData,viewShape);

    target.setTaggedValueFromCPP(1, dataView);

    //
    // set a slice in target from source

    region.clear();
    region.push_back(DataArrayView::RegionType::value_type(0,0));
    region.push_back(DataArrayView::RegionType::value_type(1,1));

    target.setSlice(source,region);

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

    assert(target.isTagged());
    assert(target.getDataPointRank()==2);
    assert(target.getDataPoint(0,0)(0,0)==0);
    assert(target.getDataPoint(0,0)(0,1)==source.getDataPoint(0,0)());
    assert(target.getDataPoint(0,0)(0,2)==4);
    assert(target.getDataPoint(0,0)(1,0)==1);
    assert(target.getDataPoint(0,0)(1,1)==3);
    assert(target.getDataPoint(0,0)(1,2)==5);

  }

  {

    cout << "\tTest get-slicing DataExpanded" << endl;

    DataArrayView::ShapeType viewShape;
    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);

    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);

  }

  {

    cout << "\tTest set-slicing DataExpanded" << endl;

    DataArrayView::ShapeType viewShape;
    Data source(10.0,viewShape,FunctionSpace(),true);

    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)());

  }

}

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::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::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::testDataTagged() {

  cout << endl;

  {

    cout << "\tCreate a DataTagged object with a default value only." << 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 defaultValue(viewData,viewShape);

    bool expanded=false;
  
    Data myData(keys,values,defaultValue,FunctionSpace(),expanded);

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

    assert(!myData.isEmpty());
    assert(myData.isTagged());
    assert(myData.getTagNumber(0)==1);
    assert(myData.getDataPointRank()==1);
    assert(myData.getLength()==3);

    DataArrayView myDataView = myData.getPointDataView();
    assert(!myDataView.isEmpty());
    assert(myDataView.getOffset()==0);
    assert(myDataView.getRank()==1);
    assert(myDataView.noValues()==3);
    assert(myDataView.getShape().size()==1);
    assert(myDataView(0)==0.0);
    assert(myDataView(1)==1.0);
    assert(myDataView(2)==2.0);

    myDataView = myData.getDataPoint(0,0);
    assert(!myDataView.isEmpty());
    assert(myDataView.getOffset()==0);
    assert(myDataView.getRank()==1);
    assert(myDataView.noValues()==3);
    assert(myDataView.getShape().size()==1);
    assert(myDataView(0)==0.0);
    assert(myDataView(1)==1.0);
    assert(myDataView(2)==2.0);

    double* sampleData=myData.getSampleData(0);
    for (int i=0; i<myDataView.noValues(); i++) {
      assert(sampleData[i]==i);
    }
    // use a non-existent tag so we get a pointer to
    // the first element of the data array
    sampleData=myData.getSampleDataByTag(9);
    for (int i=0; i<myData.getLength(); i++) {
      assert(sampleData[i]==i);
    }

    cout << "\tTest setting of a tag and associated value." << endl;

    // value for tag "1"
    DataArray eTwo(defaultValue);
    for (int i=0;i<eTwo.getView().getShape()[0];i++) {
      eTwo.getView()(i)=i+2.0;
    }

    myData.setTaggedValueFromCPP(1,eTwo.getView());

    assert(myData.getLength()==6);

    myDataView = myData.getDataPoint(0,0);
    assert(myDataView==eTwo.getView());
    assert(!myDataView.isEmpty());
    assert(myDataView.getOffset()==3);
    assert(myDataView.getRank()==1);
    assert(myDataView.noValues()==3);
    assert(myDataView.getShape().size()==1);
    assert(myDataView(0)==2);
    assert(myDataView(1)==3);
    assert(myDataView(2)==4);

    sampleData=myData.getSampleDataByTag(1);
    for (int i=0; i<myDataView.noValues(); i++) {
      assert(sampleData[i]==i+2);
    }

  }

  {

    cout << "\tCreate a DataTagged object via tag() method." << endl;

    DataArrayView::ShapeType viewShape;
    viewShape.push_back(2);
    viewShape.push_back(3);
    Data myData(1.3,viewShape,FunctionSpace(),false);
    myData.tag();

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

    assert(!myData.isEmpty());
    assert(myData.isTagged());
    assert(myData.getTagNumber(0)==1);
    assert(myData.getDataPointRank()==2);
    assert(myData.getLength()==6);

    // check default value
    DataArrayView myDataView = myData.getPointDataView();
    assert(!myDataView.isEmpty());
    assert(myDataView.getOffset()==0);
    assert(myDataView.getRank()==2);
    assert(myDataView.noValues()==6);
    assert(myDataView.getShape().size()==2);
    assert(myDataView(0,0)==1.3);
    assert(myDataView(0,1)==1.3);
    assert(myDataView(0,2)==1.3);
    assert(myDataView(1,0)==1.3);
    assert(myDataView(1,1)==1.3);
    assert(myDataView(1,2)==1.3);

    // check value for data-point (0,0).
    myDataView = myData.getDataPoint(0,0);
    assert(!myDataView.isEmpty());
    assert(myDataView.getOffset()==0);
    assert(myDataView.getRank()==2);
    assert(myDataView.noValues()==6);
    assert(myDataView.getShape().size()==2);
    assert(myDataView(0,0)==1.3);
    assert(myDataView(0,1)==1.3);
    assert(myDataView(0,2)==1.3);
    assert(myDataView(1,0)==1.3);
    assert(myDataView(1,1)==1.3);
    assert(myDataView(1,2)==1.3);

  }

}

void DataTestCase::testDataTaggedExceptions() {

  cout << endl;

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

  Data myData;
  DataArrayView myView;

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

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

}

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;
}
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision