END_TEST START_TEST (test_strip_comp) { std::string filename(TestDataDirectory); std::string fileIn = filename + "package1.xml"; SBMLDocument* d = readSBMLFromFile(fileIn.c_str()); fail_unless(d != NULL); ConversionProperties props; props.addOption("package", "comp"); SBMLConverter* converter = new SBMLStripPackageConverter(); converter->setProperties(&props); converter->setDocument(d); fail_unless (converter->convert() == LIBSBML_OPERATION_SUCCESS); std::string newModel = writeSBMLToStdString(d); std::string fileOut = filename + "package1-comp_stripped.xml"; SBMLDocument* fdoc = readSBMLFromFile(fileOut.c_str()); string stripped = writeSBMLToStdString(fdoc); fail_unless(stripped == newModel); delete converter; delete fdoc; delete d; }
ConversionProperties SBMLLevel1Version1Converter::getDefaultProperties() const { static ConversionProperties prop; static bool init = false; if (init) { return prop; } else { SBMLNamespaces * sbmlns = new SBMLNamespaces(1,1); // default namespaces prop.setTargetNamespaces(sbmlns); // this gets cloned prop.addOption("convertToL1V1", true, "convert the document to SBML Level 1 Version 1"); prop.addOption("changePow", false, "change pow expressions to the (^) hat notation"); prop.addOption("inlineCompartmentSizes", false, "if true, occurrances of compartment ids in expressions will be replaced with their initial size"); delete sbmlns; init = true; return prop; } }
ConversionProperties SBMLLevelVersionConverter::getDefaultProperties() const { static ConversionProperties prop; static bool init = false; if (init) { return prop; } else { SBMLNamespaces * sbmlns = new SBMLNamespaces(); // default namespaces prop.setTargetNamespaces(sbmlns); // this gets cloned prop.addOption("strict", true, "Whether validity should be strictly preserved"); prop.addOption("setLevelAndVersion", true, "Convert the model to a given Level and Version of SBML"); prop.addOption("addDefaultUnits", true, "Whether default units should be added when converting to L3"); delete sbmlns; init = true; return prop; } }
bool hasActualErrors(SBMLDocument* document) { document->checkConsistency(); for (unsigned int e=0; e<document->getNumErrors(); e++) { if (document->getError(e)->getSeverity() >= LIBSBML_SEV_ERROR) return true; } #ifdef USE_COMP CompModelPlugin* compmod = static_cast<CompModelPlugin*>(document->getModel()->getPlugin("comp")); if (compmod != NULL && compmod->getNumSubmodels() > 0) { SBMLDocument flat(*document); ConversionProperties* props = new ConversionProperties(); props->addOption("flatten comp"); SBMLConverter* converter = SBMLConverterRegistry::getInstance().getConverterFor(*props); converter->setDocument(&flat); int result = converter->convert(); flat.checkConsistency(); bool flaterrors = false; SBMLErrorLog* errlog = document->getErrorLog(); for (unsigned int e=0; e<flat.getNumErrors(); e++) { if (flat.getError(e)->getSeverity() >= LIBSBML_SEV_ERROR) { flaterrors = true; errlog->add(*(flat.getError(e))); } } if (flaterrors) return true; } #endif return false; }
ConversionProperties CobraToFbcConverter::getDefaultProperties() const { static ConversionProperties prop; prop.addOption("convert cobra", true, "convert cobra sbml to fbc"); return prop; }
ConversionProperties FbcToCobraConverter::getDefaultProperties() const { static ConversionProperties prop; prop.addOption("convert fbc to cobra", true, "convert FBC L3V1 to SBML L2V4 with COBRA annotation"); return prop; }
END_TEST START_TEST(test_strip_unknown_1) { const std::string model = "<?xml version='1.0' encoding='UTF-8'?>\n" "<sbml xmlns='http://www.sbml.org/sbml/level3/version1/core' level='3' version='1' " "xmlns:pkg1='http://www.sbml.org/sbml/level3/version1/pkg1/version1' pkg1:required='true' " "xmlns:pkg2='http://www.sbml.org/sbml/level3/version1/pkg2/version1' pkg2:required='true' " "xmlns:pkg3='http://www.sbml.org/sbml/level3/version1/pkg3/version1' pkg3:required='false' " ">\n\t<model/>\n" "</sbml>"; SBMLDocument* doc = readSBMLFromString(model.c_str()); fail_unless(doc->getNumUnknownPackages() == 3); ConversionProperties props; props.addOption("stripPackage", true); fail_unless(doc->convert(props) == LIBSBML_OPERATION_SUCCESS); fail_unless(doc->getNumUnknownPackages() == 3); props.addOption("package", "pkg1,pkg3"); fail_unless(doc->convert(props) == LIBSBML_OPERATION_SUCCESS); fail_unless(doc->getNumUnknownPackages() == 1); delete doc; }
LIBSBML_CPP_NAMESPACE_USE int main (int argc, char *argv[]) { if (argc != 3) { cout << endl << "Usage: inlineFunctionDefintions input-filename output-filename" << endl << endl << "This program will attempt to inline all function definitions" << endl << "contained in the source model, and write a new SBML file." << endl << endl; return 1; } const char* inputFile = argv[1]; const char* outputFile = argv[2]; // read document SBMLDocument* document = readSBML(inputFile); unsigned int errors = document->getNumErrors(LIBSBML_SEV_ERROR); // stop in case of errors if (errors > 0) { cerr << "Encountered the following SBML errors:" << endl; document->printErrors(cerr); cerr << "Conversion skipped. Please correct the problems above first." << endl; return errors; } // create conversion object that identifies the function definition converter ConversionProperties props; props.addOption("expandFunctionDefinitions", true, "Expand all function definitions in the model"); // convert int success = document->convert(props); if (success != LIBSBML_OPERATION_SUCCESS) { cerr << "Unable to perform conversion due to the following:" << endl; document->printErrors(cerr); return errors; } else { cout << "Conversion completed." << endl; writeSBML(document, outputFile); } return 0; }
END_TEST START_TEST (test_conversion_ruleconverter_with_alg) { // create test model SBMLDocument doc; Model* model = doc.createModel(); model->setId("m"); Parameter* parameter1 = model->createParameter(); parameter1->setId("s"); parameter1->setConstant(false); parameter1->setValue(0); Parameter* parameter = model->createParameter(); parameter->setId("p"); parameter->setConstant(false); parameter->setValue(0); Parameter* parameter2 = model->createParameter(); parameter2->setId("k"); parameter2->setConstant(false); parameter2->setValue(0); AlgebraicRule* rule0 = model->createAlgebraicRule(); rule0->setFormula("k + 2"); rule0->setMetaId("m0"); AssignmentRule* rule1 = model->createAssignmentRule(); rule1->setVariable("s"); rule1->setFormula("p + 1"); rule1->setMetaId("m1"); AssignmentRule* rule2 = model->createAssignmentRule(); rule2->setVariable("p"); rule2->setFormula("1"); rule2->setMetaId("m2"); ConversionProperties props; props.addOption("sortRules", true, "sort rules"); SBMLConverter* converter = new SBMLRuleConverter(); converter->setProperties(&props); converter->setDocument(&doc); fail_unless (converter->convert() == LIBSBML_OPERATION_SUCCESS); fail_unless (model->getNumRules() == 3); fail_unless (model->getRule(0)->getMetaId() == "m2"); fail_unless (model->getRule(1)->getMetaId() == "m1"); fail_unless (model->getRule(2)->getMetaId() == "m0"); delete converter; }
ConversionProperties SBMLFunctionDefinitionConverter::getDefaultProperties() const { static ConversionProperties prop; prop.addOption("expandFunctionDefinitions", true, "Expand all function definitions in the model"); prop.addOption("skipIds", "", "Comma separated list of ids to skip during expansion"); return prop; }
END_TEST START_TEST (test_comp_flatten_exchange5) { string filename(TestDataDirectory); //string filename("C:\\Development\\libsbml\\src\\sbml\\packages\\comp\\util\\test\\test-data\\"); // load document string cfile = filename + "CompTest_A.xml"; SBMLDocument* doc = readSBMLFromFile(cfile.c_str()); Model* model = doc->getModel(); // fail if there is no model (readSBMLFromFile always returns a valid document) fail_unless(model != NULL); // SK - since I made the flattenModel package protected // this will no longer work // =========== //CompModelPlugin* cmp = static_cast<CompModelPlugin*>(model->getPlugin("comp")); //Model* flatmod = cmp->flattenModel(); //fail_unless(flatmod != NULL); //CompPkgNamespaces csbmlns(3,1,1,"comp"); //SBMLDocument flatdoc(&csbmlns); //flatdoc.setPackageRequired("comp", true); //flatdoc.setModel(flatmod); //writeSBMLToFile(&flatdoc, "CompTest_flat_ports.xml"); //string newModel = writeSBMLToString(&flatdoc); //=========== // replace with ConversionProperties* props = new ConversionProperties(); props->addOption("flatten comp"); props->addOption("leavePorts", true); SBMLConverter* converter = SBMLConverterRegistry::getInstance().getConverterFor(*props); converter->setDocument(doc); int result = converter->convert(); // fail if conversion was not valid fail_unless(result == LIBSBML_OPERATION_SUCCESS); string newModel = writeSBMLToString(doc); string ffile = filename + "CompTest_flat_ports.xml"; SBMLDocument* fdoc = readSBMLFromFile(ffile.c_str()); string flatModel = writeSBMLToString(fdoc); fail_unless(flatModel == newModel); delete doc; delete fdoc; }
ConversionProperties SBMLLevelVersionConverter::getDefaultProperties() const { static ConversionProperties prop; prop.setTargetNamespaces(new SBMLNamespaces()); // default namespaces prop.addOption("strict", true, "Whether validity should be strictly preserved"); prop.addOption("setLevelAndVersion", true, "Convert the model to a given Level and Version of SBML"); return prop; }
SBMLDocument* TestFlattenedUnknownAbortNone(string file1, string file2) { string filename(TestDataDirectory); //string filename("C:\\Development\\libsbml\\src\\sbml\\packages\\comp\\util\\test\\test-data\\"); ConversionProperties props; props.addOption("flatten comp"); props.addOption("basePath", filename); props.addOption("performValidation", false); props.addOption("abortIfUnflattenable", "none"); SBMLConverter* converter = SBMLConverterRegistry::getInstance().getConverterFor(props); // load document string cfile = filename + file1; SBMLDocument* doc = readSBMLFromFile(cfile.c_str()); // fail if there is no model (readSBMLFromFile always returns a valid document) fail_unless(doc->getModel() != NULL); converter->setDocument(doc); int result = converter->convert(); // fail if conversion was not valid fail_unless(result == LIBSBML_OPERATION_SUCCESS); //For use in debugging the above statement. /* SBMLErrorLog* errors = doc->getErrorLog(); if (errors->getNumFailsWithSeverity(LIBSBML_SEV_ERROR) != 0) { fail_unless(false); for (unsigned long e=0; e<errors->getNumErrors(); e++) { const SBMLError* error = errors->getError(e); if (error->getSeverity() == LIBSBML_SEV_ERROR) { cout << error->getMessage() << endl; } } } */ string newModel = writeSBMLToStdString(doc); //string outfile = filename + "unknown_flat.xml"; //writeSBMLToFile(doc, outfile.c_str()); string ffile = filename + file2; SBMLDocument* fdoc = readSBMLFromFile(ffile.c_str()); string flatModel = writeSBMLToStdString(fdoc); fail_unless(flatModel == newModel); delete fdoc; delete converter; return doc; }
ConversionProperties SBMLIdConverter::getDefaultProperties() const { static ConversionProperties prop; prop.addOption("renameSIds", true, "Rename all SIds specified in the 'currentIds' option to the ones specified in 'newIds'"); prop.addOption("currentIds", "", "Comma separated list of ids to rename"); prop.addOption("newIds", "", "Comma separated list of the new ids"); return prop; }
END_TEST START_TEST (test_conversion_ruleconverter_sortIA) { // create test model SBMLDocument doc; Model* model = doc.createModel(); model->setId("m"); Parameter* parameter1 = model->createParameter(); parameter1->setId("s"); parameter1->setConstant(false); parameter1->setValue(0); Parameter* parameter = model->createParameter(); parameter->setId("p"); parameter->setConstant(false); parameter->setValue(0); InitialAssignment* ia1 = model->createInitialAssignment(); ia1->setSymbol("s"); ASTNode * math = SBML_parseFormula("p + 1"); ia1->setMath(math); delete math; ia1->setMetaId("m1"); InitialAssignment* ia2 = model->createInitialAssignment(); ia2->setSymbol("p"); math = SBML_parseFormula("1"); ia2->setMath(math); delete math; ia2->setMetaId("m2"); ConversionProperties props; props.addOption("sortRules", true, "sort rules"); SBMLConverter* converter = new SBMLRuleConverter(); converter->setProperties(&props); converter->setDocument(&doc); fail_unless (converter->convert() == LIBSBML_OPERATION_SUCCESS); fail_unless (model->getNumInitialAssignments() == 2); fail_unless (model->getInitialAssignment(0)->getMetaId() == "m2"); fail_unless (model->getInitialAssignment(1)->getMetaId() == "m1"); delete converter; }
LIBSBML_CPP_NAMESPACE_USE int main (int argc, char* argv[]) { if (argc != 3) { cout << endl << "Usage: inferUnits input-filename output-filename" << endl << endl; return 2; } SBMLDocument *d = readSBML(argv[1]); d->checkConsistency(); if ( d->getNumErrors(LIBSBML_SEV_ERROR) > 0) { d->printErrors(); } else { /* create a new conversion properties structure */ ConversionProperties* props = new ConversionProperties(); /* add an option that we want to infer units */ props->addOption("inferUnits"); SBMLConverter* converter = SBMLConverterRegistry::getInstance().getConverterFor(*props); converter->setDocument(d); /* perform the conversion */ if (converter->convert() != LIBSBML_OPERATION_SUCCESS) { cout<< "conversion failed ... " << endl; return 3; } d->getErrorLog()->clearLog(); d->validateSBML(); d->printErrors(cout); writeSBML(d, argv[2]); } return 0; }
bool FbcToCobraConverter::matchesProperties(const ConversionProperties &props) const { if (&props == NULL || !props.hasOption("convert fbc to cobra")) return false; return true; }
bool SBMLIdConverter::matchesProperties(const ConversionProperties &props) const { if (!props.hasOption("renameSIds")) return false; return true; }
bool SBMLLevelVersionConverter::matchesProperties(const ConversionProperties &props) const { if (&props == NULL || !props.hasOption("setLevelAndVersion")) return false; return true; }
bool SBMLLevel1Version1Converter::matchesProperties(const ConversionProperties &props) const { if (!props.hasOption("convertToL1V1")) return false; return true; }
bool SBMLFunctionDefinitionConverter::matchesProperties(const ConversionProperties &props) const { if (!props.hasOption("expandFunctionDefinitions")) return false; return true; }
bool SBMLInitialAssignmentConverter::matchesProperties(const ConversionProperties &props) const { if (!props.hasOption("expandInitialAssignments")) return false; return true; }
END_TEST START_TEST (test_comp_flatten_unknown_21) { string filename(TestDataDirectory); //string filename("C:\\Development\\libsbml\\src\\sbml\\packages\\comp\\util\\test\\test-data\\"); ConversionProperties props; props.addOption("flatten comp"); props.addOption("basePath", filename); props.addOption("performValidation", false); SBMLConverter* converter = SBMLConverterRegistry::getInstance().getConverterFor(props); // load document string cfile = filename + "flatten_fail_unknown.xml"; SBMLDocument* doc = readSBMLFromFile(cfile.c_str()); // fail if there is no model (readSBMLFromFile always returns a valid document) fail_unless(doc->getModel() != NULL); // write the doc before we attempt conversion string newModel = writeSBMLToStdString(doc); converter->setDocument(doc); int result = converter->convert(); // we should fail because we are testing the restoreNamespaces function fail_unless(result == LIBSBML_OPERATION_FAILED); string flatModel = writeSBMLToStdString(doc); fail_unless(flatModel == newModel); delete converter; SBMLErrorLog* errors = doc->getErrorLog(); fail_unless(errors->getNumErrors() == 2); fail_unless(errors->contains(RequiredPackagePresent) == true); fail_unless(errors->contains(CompFlatteningNotRecognisedReqd) == true); //fail_unless(errors->contains(CompModelFlatteningFailed) == true); //fail_unless(errors->contains(CompSubmodelMustReferenceModel) == true); delete doc; }
END_TEST START_TEST (test_comp_model_flattening_with_ports) { string filename(TestDataDirectory); string cfile = filename + "test14_A.xml"; SBMLDocument* doc = readSBMLFromFile(cfile.c_str()); Model* model = doc->getModel(); fail_unless(model != NULL); // SK - since I made the flattenModel package protected // this will no longer work // =========== //CompModelPlugin* cmp = static_cast<CompModelPlugin*>(model->getPlugin("comp")); //Model* flatmod = cmp->flattenModel(); //fail_unless(flatmod != NULL); //SBMLNamespaces sbmlns(3,1,"comp",1); //SBMLDocument doc2(&sbmlns); //doc2.setPackageRequired("comp", true); //doc2.setModel(flatmod); //string newModel = writeSBMLToString(&doc2); //=========== // replace with ConversionProperties* props = new ConversionProperties(); props->addOption("flatten comp"); props->addOption("leavePorts", true); SBMLConverter* converter = SBMLConverterRegistry::getInstance().getConverterFor(*props); converter->setDocument(doc); int result = converter->convert(); // fail if conversion was not valid fail_unless(result == LIBSBML_OPERATION_SUCCESS); string newModel = writeSBMLToString(doc); string ffile = filename + "test14_A_flat_ports.xml"; SBMLDocument* fdoc = readSBMLFromFile(ffile.c_str()); string flatModel = writeSBMLToString(fdoc); fail_unless(flatModel == newModel); delete doc; }
bool CompFlatteningConverter::matchesProperties (const ConversionProperties &props) const { if (!props.hasOption("flatten comp")) return false; return true; }
ConversionProperties SBMLInitialAssignmentConverter::getDefaultProperties() const { static ConversionProperties prop; static bool init = false; if (init) { return prop; } else { prop.addOption("expandInitialAssignments", true, "Expand initial assignments in the model"); init = true; return prop; } }
END_TEST START_TEST(test_comp_flatten_abort_none_4) { ConversionProperties* props = new ConversionProperties(); props->addOption("flatten comp"); // checking for none props->addOption("abortIfUnflattenable", "none"); props->addOption("stripUnflattenablePackages", false); SBMLConverter* converter = SBMLConverterRegistry::getInstance().getConverterFor(*props); // load document string dir(TestDataDirectory); string fileName = dir + "unknown1.xml"; SBMLDocument* doc = readSBMLFromFile(fileName.c_str()); // fail if there is no model //(but we have the unrecognised package error) fail_unless(doc->getNumErrors() == 1); fail_unless(doc->getModel() != NULL); fail_unless(doc->getErrorLog()->contains(UnrequiredPackagePresent) == true); converter->setDocument(doc); int result = converter->convert(); fail_unless( result == LIBSBML_OPERATION_SUCCESS); string newModel = writeSBMLToString(doc); string ffile = dir + "unknown1_flat_stay.xml"; SBMLDocument* fdoc = readSBMLFromFile(ffile.c_str()); string flatModel = writeSBMLToString(fdoc); fail_unless(flatModel == newModel); delete doc; delete fdoc; delete converter; }
END_TEST START_TEST (test_conversion_inlineIA_bug) { std::string filename = "/ia-ternary-lt.xml"; filename = TestDataDirectory + filename; SBMLDocument* doc = readSBMLFromFile(filename.c_str()); ConversionProperties props; props.addOption("expandInitialAssignments", "true"); fail_unless(doc->getModel() != NULL); fail_unless(doc->convert(props) == LIBSBML_OPERATION_SUCCESS); fail_unless(doc->getModel()->getNumInitialAssignments() == 0); fail_unless(doc->getModel()->getParameter("x")->isSetValue()); fail_unless(doc->getModel()->getParameter("x")->getValue() == 3); delete doc; }
END_TEST START_TEST (test_conversion_inlineFD_bug) { std::string filename = "/inline_bug_minimal.xml"; filename = TestDataDirectory + filename; SBMLDocument* doc = readSBMLFromFile(filename.c_str()); ConversionProperties props; props.addOption("expandFunctionDefinitions", "true"); fail_unless(doc->getModel() != NULL); fail_unless(doc->convert(props) == LIBSBML_OPERATION_SUCCESS); fail_unless(doc->getModel()->getNumReactions() == 1); fail_unless(doc->getModel()->getReaction(0)->isSetKineticLaw()); fail_unless(doc->getModel()->getReaction(0)->getKineticLaw()->getMath() != NULL); // all seems good ... write it const ASTNode * node = doc->getModel()->getReaction(0)->getKineticLaw()->getMath(); #ifndef LIBSBML_USE_LEGACY_MATH fail_unless(node->ASTBase::isChild() == false); #endif std::string math = writeMathMLToString(node); ASTNode* test = readMathMLFromString(math.c_str()); fail_unless(test != NULL); // additional test where the node being converted is the top-level fail_unless(doc->getModel()->getNumRules() == 1); fail_unless(doc->getModel()->getRule(0)->isSetMath()); fail_unless(doc->getModel()->getRule(0)->getMath() != NULL); node = doc->getModel()->getRule(0)->getMath(); #ifndef LIBSBML_USE_LEGACY_MATH fail_unless(node->ASTBase::isChild() == false); #endif math = writeMathMLToString(node); test = readMathMLFromString(math.c_str()); fail_unless(test != NULL); delete test; delete doc; }
END_TEST START_TEST(test_FbcExtension_convert_and_write) { string file(TestDataDirectory); file += "/fbc_ga_example.xml"; SBMLDocument* document = readSBMLFromFile(file.c_str()); document->printErrors(); fail_unless(document->getNumErrors(LIBSBML_SEV_ERROR) == 0); fail_unless(document->getModel() != NULL); // convert to v2 { ConversionProperties props; props.addOption("convert fbc v1 to fbc v2", true); props.addOption("strict", true); int result = document->convert(props); // ensure that all is well with the model fail_unless(result == LIBSBML_OPERATION_SUCCESS); fail_unless(document->getLevel() == 3); fail_unless(document->getVersion() == 1); fail_unless(document->getPlugin("fbc") != NULL); fail_unless(document->getPlugin("fbc")->getPackageVersion() == 2); } // ensure that all the v1 stuff is no longer there FbcModelPlugin* mplug = dynamic_cast<FbcModelPlugin*>( document->getModel()->getPlugin("fbc")); fail_unless(mplug != NULL); fail_unless(mplug->isSetStrict()); fail_unless(mplug->getNumGeneAssociations() == 0); fail_unless(mplug->getNumFluxBounds() == 0); delete document; }