#include <test000087.h>

Inheritance diagram for test000087:

Collaboration diagram for test000087:

Public Member Functions
void	setUp ()

void	tearDown ()

void	test_export_reaction_flux_reference_1 ()

void	test_export_reaction_flux_reference_2 ()

void	test_import_reaction_flux_reference_1 ()

void	test_import_reaction_flux_reference_2 ()

void	test_import_reaction_flux_reference_3 ()

void	test_simulate_reaction_flux_reference_1 ()

Static Protected Attributes
static const char *	MODEL_STRING1

static const char *	MODEL_STRING2

static const char *	MODEL_STRING3

static const char *	MODEL_STRING4

static const char *	MODEL_STRING5

static CCopasiDataModel *	pCOPASIDATAMODEL = NULL

Private Member Functions
	CPPUNIT_TEST (test_import_reaction_flux_reference_1)

	CPPUNIT_TEST (test_import_reaction_flux_reference_2)

	CPPUNIT_TEST (test_import_reaction_flux_reference_3)

	CPPUNIT_TEST (test_export_reaction_flux_reference_1)

	CPPUNIT_TEST (test_export_reaction_flux_reference_2)

	CPPUNIT_TEST (test_simulate_reaction_flux_reference_1)

	CPPUNIT_TEST_SUITE (test000087)

	CPPUNIT_TEST_SUITE_END ()

Detailed Description

Definition at line 24 of file test000087.h.

Member Function Documentation

test000087::CPPUNIT_TEST ( test_import_reaction_flux_reference_1 )

private

test000087::CPPUNIT_TEST ( test_import_reaction_flux_reference_2 )

private

test000087::CPPUNIT_TEST ( test_import_reaction_flux_reference_3 )

private

test000087::CPPUNIT_TEST ( test_export_reaction_flux_reference_1 )

private

test000087::CPPUNIT_TEST ( test_export_reaction_flux_reference_2 )

private

test000087::CPPUNIT_TEST ( test_simulate_reaction_flux_reference_1 )

private

test000087::CPPUNIT_TEST_SUITE ( test000087 )

private

test000087::CPPUNIT_TEST_SUITE_END ( )

private

void test000087::setUp ( )

Definition at line 49 of file test000087.cpp.

References CCopasiRootContainer::addDatamodel(), CCopasiRootContainer::init(), and pCOPASIDATAMODEL.

 {
   // Create the root container.
   CCopasiRootContainer::init(0, NULL, false);
   // Create the global data model.
   pCOPASIDATAMODEL = CCopasiRootContainer::addDatamodel();
 }

void test000087::tearDown ( )

Definition at line 57 of file test000087.cpp.

References CCopasiRootContainer::destroy().

 {
   CCopasiRootContainer::destroy();
 }

void test000087::test_export_reaction_flux_reference_1 ( )

Definition at line 165 of file test000087.cpp.

References CCopasiDataModel::exportSBMLToString(), CCopasiDataModel::getCurrentSBMLDocument(), CCopasiDataModel::getModel(), load_cps_model_from_stream(), MODEL_STRING4, pCOPASIDATAMODEL, and CCopasiMessage::size().

 {
   try
     {
       std::istringstream iss(test000087::MODEL_STRING4);
       bool result = load_cps_model_from_stream(iss, *pCOPASIDATAMODEL);
       CPPUNIT_ASSERT(result == true);
       CPPUNIT_ASSERT(pCOPASIDATAMODEL->getModel() != NULL);
     }
   catch (...)
     {
       // there should be no exception
       CPPUNIT_ASSERT(false);
     }
 
   try
     {
       CPPUNIT_ASSERT(pCOPASIDATAMODEL->exportSBMLToString(NULL, 2, 3).empty() == false);
     }
   catch (...)
     {
       // there should be no exception
       CPPUNIT_ASSERT(false);
     }
 
   CPPUNIT_ASSERT(CCopasiMessage::size() == 0);
   const SBMLDocument* pDocument = pCOPASIDATAMODEL->getCurrentSBMLDocument();
   CPPUNIT_ASSERT(pDocument != NULL);
   CPPUNIT_ASSERT(pDocument->getLevel() == 2);
   CPPUNIT_ASSERT(pDocument->getVersion() == 3);
   const Model* pModel = pDocument->getModel();
   CPPUNIT_ASSERT(pModel != NULL);
   CPPUNIT_ASSERT(pModel->getListOfFunctionDefinitions()->size() == 0);
   CPPUNIT_ASSERT(pModel->getListOfCompartments()->size() == 1);
   CPPUNIT_ASSERT(pModel->getListOfSpecies()->size() == 3);
   CPPUNIT_ASSERT(pModel->getListOfReactions()->size() == 1);
   CPPUNIT_ASSERT(pModel->getListOfRules()->size() == 1);
   const Reaction* pReaction = pModel->getReaction(0);
   CPPUNIT_ASSERT(pReaction != NULL);
   std::string reactionId = pReaction->getId();
   CPPUNIT_ASSERT(reactionId.empty() == false);
   const Rule* pRule = pModel->getRule(0);
   CPPUNIT_ASSERT(pRule != NULL);
   CPPUNIT_ASSERT(pRule->getTypeCode() == SBML_ASSIGNMENT_RULE);
   const AssignmentRule* pAssignmentRule = dynamic_cast<const AssignmentRule*>(pRule);
   CPPUNIT_ASSERT(pAssignmentRule != NULL);
   const Species* pSpecies = pModel->getSpecies(pAssignmentRule->getVariable());
   CPPUNIT_ASSERT(pSpecies != NULL);
   CPPUNIT_ASSERT(pSpecies->getName() == "C");
   const ASTNode* pMath = pAssignmentRule->getMath();
   CPPUNIT_ASSERT(pMath != NULL);
   CPPUNIT_ASSERT(pMath->getType() == AST_NAME);
   CPPUNIT_ASSERT(pMath->getName() == reactionId);
 }

void test000087::test_export_reaction_flux_reference_2 ( )

Definition at line 220 of file test000087.cpp.

References CCopasiMessage::EXCEPTION, CCopasiDataModel::exportSBMLToString(), CCopasiDataModel::getCurrentSBMLDocument(), CCopasiMessage::getLastMessage(), CCopasiDataModel::getModel(), load_cps_model_from_stream(), MODEL_STRING4, pCOPASIDATAMODEL, CCopasiMessage::RAW, and CCopasiMessage::size().

 {
   try
     {
       std::istringstream iss(test000087::MODEL_STRING4);
       bool result = load_cps_model_from_stream(iss, *pCOPASIDATAMODEL);
       CPPUNIT_ASSERT(result == true);
       CPPUNIT_ASSERT(pCOPASIDATAMODEL->getModel() != NULL);
     }
   catch (...)
     {
       // there should be no exception
       CPPUNIT_ASSERT(false);
     }
 
   try
     {
       std::string result = pCOPASIDATAMODEL->exportSBMLToString(NULL, 2, 1);
       CPPUNIT_ASSERT(result.empty());
     }
   catch (...)
     {
       // there should be an exception
       // check if the correct error message has been created
       CPPUNIT_ASSERT(pCOPASIDATAMODEL->getCurrentSBMLDocument() == NULL);
       // last message should be an exception
       CCopasiMessage message = CCopasiMessage::getLastMessage();
       CPPUNIT_ASSERT(message.getType() == CCopasiMessage::EXCEPTION);
       // see if the incompatibility message is there
       bool found = false;
 
       while (CCopasiMessage::size() > 0)
         {
           message = CCopasiMessage::getLastMessage();
 
           if (message.getType() == CCopasiMessage::RAW)
             {
               std::string s = message.getText();
 
               if (s.find(std::string("SBML Incompatibility (10)")) != std::string::npos)
                 {
                   found = true;
                   break;
                 }
             }
         }
 
       CPPUNIT_ASSERT_MESSAGE("Error message not found.", found == true);
       return;
     }
 
   CPPUNIT_ASSERT(false);
 }

void test000087::test_import_reaction_flux_reference_1 ( )

Definition at line 62 of file test000087.cpp.

References CCopasiMessage::getLastMessage(), CCopasiMessage::getNumber(), CCopasiDataModel::importSBMLFromString(), MCSBML, MODEL_STRING1, pCOPASIDATAMODEL, and CCopasiMessage::size().

 {
   try
     {
       CPPUNIT_ASSERT(pCOPASIDATAMODEL->importSBMLFromString(test000087::MODEL_STRING1));
     }
   catch (...)
     {
       // there should be an exception (MCSBML + 81)
       unsigned int i, iMax = CCopasiMessage::size();
       CCopasiMessage message;
       bool found81 = false;
 
       for (i = 0; i < iMax; ++i)
         {
           message = CCopasiMessage::getLastMessage();
 
           if (message.getNumber() == MCSBML + 81)
             {
               found81 = true;
               break;
             }
         }
 
       CPPUNIT_ASSERT(found81 == true);
       return;
     }
 
   // we should never get here
   CPPUNIT_ASSERT(false);
 }

void test000087::test_import_reaction_flux_reference_2 ( )

Definition at line 94 of file test000087.cpp.

References CModelEntity::ASSIGNMENT, CModel::getCompartments(), CModelEntity::getExpressionPtr(), CModel::getMetabolites(), CCopasiDataModel::getModel(), CModel::getModelValues(), CEvaluationNodeObject::getObjectCN(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CModel::getReactions(), CModelEntity::getStatus(), CEvaluationNode::getType(), CCopasiDataModel::importSBMLFromString(), CCopasiObject::isReference(), MODEL_STRING2, CEvaluationNode::OBJECT, CCopasiDataModel::ObjectFromName(), pCOPASIDATAMODEL, CCopasiVector< T >::size(), and CEvaluationNode::type().

 {
   try
     {
       CPPUNIT_ASSERT(pCOPASIDATAMODEL->importSBMLFromString(test000087::MODEL_STRING2));
     }
   catch (...)
     {
       // there should not be an exception
       CPPUNIT_ASSERT(false);
     }
 
   CPPUNIT_ASSERT(pCOPASIDATAMODEL->getModel() != NULL);
   CPPUNIT_ASSERT(pCOPASIDATAMODEL->getModel()->getCompartments().size() == 1);
   CPPUNIT_ASSERT(pCOPASIDATAMODEL->getModel()->getMetabolites().size() == 2);
   CPPUNIT_ASSERT(pCOPASIDATAMODEL->getModel()->getModelValues().size() == 1);
   CPPUNIT_ASSERT(pCOPASIDATAMODEL->getModel()->getReactions().size() == 1);
   const CReaction* pReaction = pCOPASIDATAMODEL->getModel()->getReactions()[0];
   CPPUNIT_ASSERT(pReaction != NULL);
   const CModelValue* pMV = pCOPASIDATAMODEL->getModel()->getModelValues()[0];
   CPPUNIT_ASSERT(pMV != NULL);
   CPPUNIT_ASSERT(pMV->getStatus() == CModelEntity::ASSIGNMENT);
   const CExpression* pExpr = pMV->getExpressionPtr();
   CPPUNIT_ASSERT(pExpr != NULL);
   const CEvaluationNode* pRoot = pExpr->getRoot();
   CPPUNIT_ASSERT(pRoot != NULL);
   CPPUNIT_ASSERT(CEvaluationNode::type(pRoot->getType()) == CEvaluationNode::OBJECT);
   const CEvaluationNodeObject* pObjectNode = dynamic_cast<const CEvaluationNodeObject*>(pRoot);
   CPPUNIT_ASSERT(pObjectNode != NULL);
   const CRegisteredObjectName cn = pObjectNode->getObjectCN();
   std::vector<CCopasiContainer*> listOfContainers;
   listOfContainers.push_back(pCOPASIDATAMODEL->getModel());
   const CCopasiObject* pObject = pCOPASIDATAMODEL->ObjectFromName(listOfContainers, cn);
   CPPUNIT_ASSERT(pObject != NULL);
   CPPUNIT_ASSERT(pObject->isReference() == true);
   CPPUNIT_ASSERT(pObject->getObjectName() == "Flux");
   CPPUNIT_ASSERT(pObject->getObjectParent() == pReaction);
 }

void test000087::test_import_reaction_flux_reference_3 ( )

Definition at line 133 of file test000087.cpp.

References CCopasiMessage::getLastMessage(), CCopasiMessage::getNumber(), CCopasiDataModel::importSBMLFromString(), MCSBML, MODEL_STRING3, pCOPASIDATAMODEL, and CCopasiMessage::size().

 {
   try
     {
       CPPUNIT_ASSERT(pCOPASIDATAMODEL->importSBMLFromString(test000087::MODEL_STRING3));
     }
   catch (...)
     {
       // there should be an exception (MCSBML + 81)
       unsigned int i, iMax = CCopasiMessage::size();
       CCopasiMessage message;
       bool found80 = false;
 
       for (i = 0; i < iMax; ++i)
         {
           message = CCopasiMessage::getLastMessage();
 
           if (message.getNumber() == MCSBML + 80)
             {
               found80 = true;
               break;
             }
         }
 
       CPPUNIT_ASSERT(found80 == true);
       return;
     }
 
   // we should never get here
   CPPUNIT_ASSERT(false);
 }

void test000087::test_simulate_reaction_flux_reference_1 ( )

Definition at line 274 of file test000087.cpp.

References CCopasiVectorN< CType >::add(), CModelEntity::ASSIGNMENT, C_FLOAT64, C_INT32, CReportDefinitionVector::createReportDefinition(), CModelEntity::FIXED, CKeyFactory::get(), CReportDefinition::getBodyAddr(), CCopasiObject::getCN(), CModel::getCompartments(), CModelEntity::getExpressionPtr(), CReportDefinition::getHeaderAddr(), CMetab::getInitialConcentration(), CModelEntity::getInitialValue(), CModelEntity::getKey(), CCopasiRootContainer::getKeyFactory(), CModel::getMetabolites(), CCopasiTask::getMethod(), CCopasiDataModel::getModel(), CModel::getModelValues(), CEvaluationNodeObject::getObjectCN(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CCopasiParameterGroup::getParameter(), CCopasiTask::getProblem(), CModel::getReactions(), CCopasiTask::getReport(), CCopasiDataModel::getReportDefinitionList(), CEvaluationTree::getRoot(), CReportDefinition::getSeparator(), CCopasiDataModel::getTaskList(), CEvaluationNode::getType(), CCopasiDataModel::importSBMLFromString(), CTrajectoryTask::initialize(), CCopasiObject::isReference(), CCopasiMethod::LSODAR, CEvaluationTree::MassAction, max, MODEL_STRING5, CEvaluationNode::OBJECT, CCopasiDataModel::ObjectFromName(), CCopasiTask::OUTPUT_UI, pCOPASIDATAMODEL, CTrajectoryTask::process(), CCopasiVectorN< CType >::remove(), CTrajectoryTask::restore(), CTrajectoryProblem::setDuration(), CModel::setInitialTime(), CReportDefinition::setIsTable(), CTrajectoryTask::setMethodType(), CCopasiProblem::setModel(), CReport::setReportDefinition(), CCopasiTask::setScheduled(), CReportDefinition::setSeparator(), CTrajectoryProblem::setStepNumber(), CReport::setTarget(), CReportDefinition::setTaskType(), CTrajectoryProblem::setTimeSeriesRequested(), CCopasiParameter::setValue(), CCopasiVector< T >::size(), strToDouble(), CCopasiTask::timeCourse, and CEvaluationNode::type().

 {
   try
     {
       bool result = pCOPASIDATAMODEL->importSBMLFromString(test000087::MODEL_STRING5);
       CPPUNIT_ASSERT(result = true);
     }
   catch (...)
     {
       // there should be no exception
       CPPUNIT_ASSERT(false);
     }
 
   CModel* pModel = pCOPASIDATAMODEL->getModel();
   CPPUNIT_ASSERT(pModel != NULL);
   CPPUNIT_ASSERT(pModel->getCompartments().size() == 1);
   CPPUNIT_ASSERT(pModel->getMetabolites().size() == 2);
   CPPUNIT_ASSERT(pModel->getModelValues().size() == 2);
   CPPUNIT_ASSERT(pModel->getReactions().size() == 1);
   const CReaction* pReaction = pModel->getReactions()[0];
   CPPUNIT_ASSERT(pReaction != NULL);
   CModelValue* pConstParameter = NULL;
   CModelValue* pNonConstParameter = NULL;
   unsigned int i, iMax = pModel->getModelValues().size();
 
   for (i = 0; i < iMax; ++i)
     {
       if (pModel->getModelValues()[i]->getStatus() == CModelEntity::FIXED)
         {
           pConstParameter = pModel->getModelValues()[i];
         }
 
       if (pModel->getModelValues()[i]->getStatus() == CModelEntity::ASSIGNMENT)
         {
           pNonConstParameter = pModel->getModelValues()[i];
         }
     }
 
   CPPUNIT_ASSERT(pConstParameter != NULL);
   CPPUNIT_ASSERT(pNonConstParameter != NULL);
   // check if the kinetic law is mass action with const global parameter as the kinetic constant
   CPPUNIT_ASSERT(pReaction->getChemEq().getSubstrates().size() == 1);
   CPPUNIT_ASSERT(pReaction->getChemEq().getProducts().size() == 1);
   CPPUNIT_ASSERT(pReaction->getChemEq().getModifiers().size() == 0);
   CPPUNIT_ASSERT(pReaction->isReversible() == false);
   const CFunction* pKineticLaw = pReaction->getFunction();
   CPPUNIT_ASSERT(pKineticLaw != NULL);
   CPPUNIT_ASSERT(pKineticLaw->getType() == CEvaluationTree::MassAction);
   const std::vector< std::vector<std::string> > & parameterMappings = pReaction->getParameterMappings();
   CPPUNIT_ASSERT(parameterMappings.size() == 2);
   CPPUNIT_ASSERT(parameterMappings[0].size() == 1);
   CPPUNIT_ASSERT(parameterMappings[0][0] == pConstParameter->getKey());
   CPPUNIT_ASSERT(parameterMappings[1].size() == 1);
   std::string substrateKey = parameterMappings[1][0];
   const CCopasiObject* pTempObject = CCopasiRootContainer::getKeyFactory()->get(substrateKey);
   CPPUNIT_ASSERT(pTempObject != NULL);
   const CMetab* pSubstrate = dynamic_cast<const CMetab*>(pTempObject);
   CPPUNIT_ASSERT(pSubstrate != NULL);
   // check that the assignment consists of only one object node that is a reference to the reaction flux
   const CExpression* pExpression = pNonConstParameter->getExpressionPtr();
   CPPUNIT_ASSERT(pExpression != NULL);
   const CEvaluationNode* pRoot = pExpression->getRoot();
   CPPUNIT_ASSERT(pRoot != NULL);
   CPPUNIT_ASSERT(CEvaluationNode::type(pRoot->getType()) == CEvaluationNode::OBJECT);
   const CEvaluationNodeObject* pObjectNode = dynamic_cast<const CEvaluationNodeObject*>(pRoot);
   CPPUNIT_ASSERT(pObjectNode != NULL);
   const CRegisteredObjectName cn = pObjectNode->getObjectCN();
   std::vector<CCopasiContainer*> listOfContainers;
   listOfContainers.push_back(pCOPASIDATAMODEL->getModel());
   const CCopasiObject* pObject = pCOPASIDATAMODEL->ObjectFromName(listOfContainers, cn);
   CPPUNIT_ASSERT(pObject != NULL);
   CPPUNIT_ASSERT(pObject->isReference() == true);
   CPPUNIT_ASSERT(pObject->getObjectName() == "Flux");
   CPPUNIT_ASSERT(pObject->getObjectParent() == pReaction);
   // Simulate the model (5 steps, stepsize 1 and check that at each step, the value of the variable parameter
   // is the same as the flux through the reaction.
   std::ostringstream result;
   // create a report with the correct filename and all the species against
   // time.
   CReportDefinitionVector* pReports = pCOPASIDATAMODEL->getReportDefinitionList();
   CReportDefinition* pReport = pReports->createReportDefinition("Report", "Output for simulation");
   pReport->setTaskType(CCopasiTask::timeCourse);
   pReport->setIsTable(false);
   pReport->setSeparator(CCopasiReportSeparator(", "));
 
   std::vector<CRegisteredObjectName>* pHeader = pReport->getHeaderAddr();
   std::vector<CRegisteredObjectName>* pBody = pReport->getBodyAddr();
   pHeader->push_back(CCopasiStaticString("time").getCN());
   pHeader->push_back(pReport->getSeparator().getCN());
   pHeader->push_back(CCopasiStaticString("substrate").getCN());
   pHeader->push_back(pReport->getSeparator().getCN());
   pHeader->push_back(CCopasiStaticString("reaction flux").getCN());
   pHeader->push_back(pReport->getSeparator().getCN());
   pHeader->push_back(CCopasiStaticString("variable model value").getCN());
   pBody->push_back(CCopasiObjectName(pCOPASIDATAMODEL->getModel()->getCN() + ",Reference=Time"));
   pBody->push_back(CRegisteredObjectName(pReport->getSeparator().getCN()));
   pBody->push_back(CCopasiObjectName(pSubstrate->getCN() + ",Reference=Concentration"));
   pBody->push_back(CRegisteredObjectName(pReport->getSeparator().getCN()));
   pBody->push_back(CCopasiObjectName(pReaction->getCN() + ",Reference=Flux"));
   pBody->push_back(CRegisteredObjectName(pReport->getSeparator().getCN()));
   pBody->push_back(CCopasiObjectName(pNonConstParameter->getCN() + ",Reference=Value"));
   //
   // create a trajectory task
   CTrajectoryTask* pTrajectoryTask = new CTrajectoryTask();
   // use LSODAR from now on since we will have events pretty soon
   pTrajectoryTask->setMethodType(CCopasiMethod::LSODAR);
   pTrajectoryTask->getProblem()->setModel(pCOPASIDATAMODEL->getModel());
 
   pTrajectoryTask->setScheduled(true);
   pTrajectoryTask->getReport().setReportDefinition(pReport);
   // the target needs to be set in order to get output on the stream
   // object passed to the task in the call to initialize below
   pTrajectoryTask->getReport().setTarget("test.tmp");
 
   CTrajectoryProblem* pProblem = dynamic_cast<CTrajectoryProblem*>(pTrajectoryTask->getProblem());
 
   pProblem->setStepNumber((const unsigned C_INT32)30);
   pCOPASIDATAMODEL->getModel()->setInitialTime((const C_FLOAT64)0.0);
   pProblem->setDuration((const C_FLOAT64)30);
   pProblem->setTimeSeriesRequested(true);
 
   CTrajectoryMethod* pMethod = dynamic_cast<CTrajectoryMethod*>(pTrajectoryTask->getMethod());
 
   pMethod->getParameter("Absolute Tolerance")->setValue(1.0e-12);
 
   CCopasiVectorN< CCopasiTask > & TaskList = * pCOPASIDATAMODEL->getTaskList();
 
   TaskList.remove("Time-Course");
   TaskList.add(pTrajectoryTask, true);
 
   try
     {
       pTrajectoryTask->initialize(CCopasiTask::OUTPUT_UI, pCOPASIDATAMODEL, &result);
       pTrajectoryTask->process(true);
       pTrajectoryTask->restore();
     }
   catch (...)
     {
       // there should be no exception
       CPPUNIT_ASSERT(false);
     }
 
   // analyse the result
   CPPUNIT_ASSERT(!result.str().empty());
   std::string result_string = result.str();
   std::string delimiter = "\n";
   std::string delimiter2 = ",";
   std::size_t lastPos = result_string.find_first_not_of(delimiter);
   std::size_t pos;
   std::string line, number_string;
   unsigned int index = 0;
   unsigned int index2;
   std::size_t lastPos2;
   std::size_t pos2;
   double last = std::numeric_limits<double>::max(), current = std::numeric_limits<double>::max();
 
   while (lastPos != std::string::npos)
     {
       pos = result_string.find_first_of(delimiter, lastPos);
       line = result_string.substr(lastPos, pos - lastPos);
       lastPos = result_string.find_first_not_of(delimiter, pos);
       lastPos2 = line.find_first_not_of(delimiter2);
 
       // skip the header line
       if (index != 0)
         {
           index2 = 0;
 
           while (lastPos2 != std::string::npos)
             {
               pos2 = line.find_first_of(delimiter2, lastPos2);
               number_string = line.substr(lastPos2, pos2 - lastPos2);
               lastPos2 = line.find_first_not_of(delimiter2, pos2);
 
               // skip the time column
               if (index2 != 0)
                 {
                   //check that all values in the row (besides the time)
                   // are always the same
                   if (index2 == 1)
                     {
                       last = strToDouble(number_string.c_str(), NULL);
 
                       if (index == 1)
                         {
                           // just make sure that we don't compare all zeros
                           // The initial value of the substrate hould be higher than 1
                           CPPUNIT_ASSERT(fabs(pSubstrate->getInitialValue()) > 1);
                           // the first rwo should correspond the the initial value of the substrate
                           // We check this to make sure that the whole timeseries does not consist of zeros
                           CPPUNIT_ASSERT(fabs((last - pSubstrate->getInitialConcentration()) / pSubstrate->getInitialConcentration()) < 1e-20);
                         }
                     }
                   else
                     {
                       current = strToDouble(number_string.c_str(), NULL);
                       CPPUNIT_ASSERT(fabs((current - last) / last) < 1e-20);
                       last = current;
                     }
                 }
 
               ++index2;
             }
         }
 
       ++index;
     }
 
   // make sure there actually were datapoints
   CPPUNIT_ASSERT(index > 1);
   // the simulation is set to run until all substrate is depleted, so in the end
   // last should be below the absolute tolerance for the simulation
   CPPUNIT_ASSERT(last < *pMethod->getParameter("Absolute Tolerance")->getValue().pDOUBLE);
 }