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;
  }
}
Example #4
0
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;
}
Example #9
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;
}
Example #15
0
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;
}
Example #16
0
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;
}
Example #28
0
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;
}