END_TEST START_TEST (test_SBMLConvert_convertToL1_Species_Amount) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 4); Model_t *m = SBMLDocument_createModel(d); const char *sid = "C"; Compartment_t *c = Compartment_create(2, 4); Species_t *s = Species_create(2, 4); Compartment_setId ( c, sid ); Model_addCompartment( m, c ); Species_setCompartment ( s, sid ); Species_setInitialAmount( s, 2.34 ); Model_addSpecies ( m, s ); fail_unless( SBMLDocument_setLevelAndVersion(d, 1, 2) == 1, NULL ); fail_unless( Species_getInitialAmount(s) == 2.34, NULL ); SBMLDocument_free(d); }
int main (int argc, char *argv[]) { SBMLDocument_t *d; Model_t *m; if (argc != 3) { printf("\n usage: drawMath <sbml filename> <output dot filename>\n\n"); return 1; } d = readSBML(argv[1]); m = SBMLDocument_getModel(d); SBMLDocument_printErrors(d, stdout); if ((fout = fopen( argv[2], "w" )) == NULL ) { printf( "The output file was not opened\n" ); } else { printMath(m); fclose(fout); } SBMLDocument_free(d); return 0; }
/** C.0: Loads, validates and parses an SBML file, also converts SBML level 1 to level 2 files, return NULL if errors were encountered during libSBML validation and consistency check, stores libSBML warngings */ SBMLDocument_t * parseModel(char *file, int printMessage, int validate, char *schemaPath, char *schema11FileName, char *schema12FileName, char *schema21FileName) { unsigned int i, errors ; SBMLDocument_t *d; SBMLDocument_t *d2; SBMLReader_t *sr; if ( validate ) { if ( printMessage ) { fprintf(stderr, "Validating SBML.\n"); fprintf(stderr, "This can take a while for SBML level 2.\n"); } sr = newSBMLReader(schemaPath, schema11FileName, schema12FileName, schema21FileName); } else { sr = SBMLReader_create(); } d = SBMLReader_readSBML(sr, file); SBMLReader_free(sr); errors = 0; if ( validate ) { errors = SBMLDocument_getNumFatals(d) + SBMLDocument_getNumErrors(d); } if (SBMLDocument_getNumFatals(d) + SBMLDocument_getNumErrors(d) == 0) SBMLDocument_checkConsistency(d); /* AMF 9th Dec 2005 added back because inconsistent models can cause the solver to crash despite the consistancy check causing memory leaks - talk to Ben B! */ /* check for warnings and errors */ for (i =0 ; i != SBMLDocument_getNumWarnings(d); i++) storeSBMLError(WARNING_ERROR_TYPE, SBMLDocument_getWarning(d, i)); for (i =0 ; i != SBMLDocument_getNumErrors(d); i++) storeSBMLError(ERROR_ERROR_TYPE, SBMLDocument_getError(d, i)); for (i =0 ; i != SBMLDocument_getNumFatals(d); i++) storeSBMLError(FATAL_ERROR_TYPE, SBMLDocument_getFatal(d, i)); RETURN_ON_ERRORS_WITH(NULL); /* convert level 1 models to level 2 */ if ( SBMLDocument_getLevel(d) == 1 ) { d2 = convertModel(d); SBMLDocument_free(d); if ( printMessage ) fprintf(stderr, "SBML converted from level 1 to level 2.\n"); return (d2); } return (d); }
END_TEST START_TEST (test_SBMLConvertStrict_convertSBO) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 4); Model_t * m = SBMLDocument_createModel(d); /* create a compartment with SBO */ Compartment_t * c = Model_createCompartment(m); Compartment_setId(c, "c"); SBase_setSBOTerm((SBase_t *) (c), 240); fail_unless( SBMLDocument_setLevelAndVersionStrict(d, 2, 3) == 1 ); fail_unless( SBMLDocument_getLevel (d) == 2, NULL ); fail_unless( SBMLDocument_getVersion(d) == 3, NULL ); fail_unless( SBMLDocument_setLevelAndVersionStrict(d, 2, 2) == 1 ); fail_unless( SBMLDocument_getLevel (d) == 2, NULL ); fail_unless( SBMLDocument_getVersion(d) == 2, NULL ); /* check that sbo term has been removed */ Compartment_t *c1 = Model_getCompartment(SBMLDocument_getModel(d), 0); fail_unless (SBase_getSBOTerm((SBase_t *) (c1)) == -1, NULL ); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLDocument_setModel) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 4); Model_t *m1 = Model_create(2, 4); Model_t *m2 = Model_create(2, 4); Model_t *mout; fail_unless(SBMLDocument_getModel(d) == NULL); int i = SBMLDocument_setModel(d, m1); fail_unless ( i == LIBSBML_OPERATION_SUCCESS ); mout = SBMLDocument_getModel(d); fail_unless(mout != NULL); fail_unless(mout != m1); /* Reflexive case (pathological) */ i = SBMLDocument_setModel(d, SBMLDocument_getModel(d)); fail_unless ( i == LIBSBML_OPERATION_SUCCESS ); mout = SBMLDocument_getModel(d); fail_unless(mout != NULL); fail_unless(mout != m1); i = SBMLDocument_setModel(d, m2); fail_unless ( i == LIBSBML_OPERATION_SUCCESS ); mout = SBMLDocument_getModel(d); fail_unless(mout != NULL); fail_unless(mout != m2); SBMLDocument_free(d); /* m1 is freed by SBMLDocument_setModel(d, m2); */ }
END_TEST START_TEST (test_SBMLDocument_free_NULL) { SBMLDocument_free(NULL); }
END_TEST START_TEST (test_SBMLDocument_setLevelAndVersion_UnitsError) { SBMLDocument_t *d = SBMLDocument_create(); SBMLDocument_setLevelAndVersionNonStrict(d, 2, 4); Model_t *m1 = SBMLDocument_createModel(d); Compartment_t *c = Model_createCompartment(m1); Compartment_setId(c, "c"); Parameter_t *p = Model_createParameter(m1); Parameter_setId(p, "p"); Parameter_setUnits(p, "mole"); Rule_t * r = Model_createAssignmentRule(m1); Rule_setVariable(r, "c"); Rule_setFormula(r, "p*p"); fail_unless(SBMLDocument_setLevelAndVersionNonStrict(d,2,2) == 1); fail_unless(SBMLDocument_setLevelAndVersionNonStrict(d,2,3) == 1); fail_unless(SBMLDocument_setLevelAndVersionNonStrict(d,1,2) == 1); fail_unless(SBMLDocument_setLevelAndVersionNonStrict(d,1,1) == 0); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLDocument_setLevelAndVersion_Error) { SBMLDocument_t *d = SBMLDocument_create(); SBMLDocument_setLevelAndVersion(d, 2, 1); Model_t *m1 = Model_create(2, 1); /* add unitDefinition */ Unit_t * u = Unit_create(2, 1); Unit_setKind(u, UnitKind_forName("mole")); Unit_setOffset(u, 3.2); UnitDefinition_t *ud = UnitDefinition_create(2, 1); UnitDefinition_setId(ud, "ud"); UnitDefinition_addUnit(ud, u); Model_addUnitDefinition(m1, ud); SBMLDocument_setModel(d, m1); fail_unless(SBMLDocument_setLevelAndVersionStrict(d,2,2) == 0); fail_unless(SBMLDocument_setLevelAndVersionStrict(d,2,3) == 0); fail_unless(SBMLDocument_setLevelAndVersionStrict(d,1,2) == 0); fail_unless(SBMLDocument_setLevelAndVersionStrict(d,1,1) == 0); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL2v4_DuplicateAnnotations_model) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 1); Model_t * m = SBMLDocument_createModel(d); char * annotation = "<rdf/>\n<rdf/>"; int i = SBase_setAnnotationString((SBase_t *) (m), annotation); fail_unless( SBMLDocument_getLevel (d) == 2, NULL ); fail_unless( SBMLDocument_getVersion(d) == 1, NULL ); fail_unless( XMLNode_getNumChildren(SBase_getAnnotation((SBase_t *) (m))) == 2); fail_unless( SBMLDocument_setLevelAndVersion(d, 2, 4) == 1, NULL ); fail_unless( SBMLDocument_getLevel (d) == 2, NULL ); fail_unless( SBMLDocument_getVersion(d) == 4, NULL ); m = SBMLDocument_getModel(d); fail_unless( XMLNode_getNumChildren(SBase_getAnnotation((SBase_t *) (m))) == 1); SBMLDocument_free(d); }
int main (int argc, char *argv[]){ int i, j; char *model; double time; double printstep; /* libSBML types */ SBMLDocument_t *d; SBMLReader_t *sr; Model_t *m; /* SOSlib types */ SBMLResults_t *results; timeCourse_t *tc; cvodeSettings_t *set; /* parsing command-line arguments */ if (argc < 4 ) { fprintf(stderr, "usage %s sbml-model-file simulation-time time-steps\n", argv[0]); exit(EXIT_FAILURE); } model = argv[1]; time = atof(argv[2]); printstep = atoi(argv[3]); /* parsing the SBML model with libSBML */ sr = SBMLReader_create(); d = SBMLReader_readSBML(sr, model); SBMLReader_free(sr); /* Setting SBML ODE Solver integration parameters */ set = CvodeSettings_create(); CvodeSettings_setTime(set, time, printstep); CvodeSettings_setErrors(set, 1e-9, 1e-4, 1000); /* calling the SBML ODE Solver which returns SBMLResults */ results = SBML_odeSolver(d, set); if ( SolverError_getNum(FATAL_ERROR_TYPE) ) { printf("Integration not sucessful!\n"); SolverError_dumpAndClearErrors(); return(EXIT_FAILURE); } /* now we have the results and can free the inputs */ CvodeSettings_free(set); SBMLDocument_free(d); /* print results */ printf("### RESULTS \n"); SBMLResults_dump(results); SolverError_dumpAndClearErrors(); /* now we can also free the result structure */ SBMLResults_free(results); return (EXIT_SUCCESS); }
int main (int argc, char *argv[]) { const char *filename; SBMLDocument_t *d; Model_t *m; unsigned int level, version; if (argc != 2) { printf("Usage: printSBML filename\n"); return 2; } filename = argv[1]; d = readSBML(filename); SBMLDocument_printErrors(d, stdout); m = SBMLDocument_getModel(d); level = SBMLDocument_getLevel (d); version = SBMLDocument_getVersion(d); printf("\n"); printf("File: %s (Level %u, version %u)\n", filename, level, version); if (m == NULL) { printf("No model present."); return 1; } printf(" "); printf(" model id: %s\n", Model_isSetId(m) ? Model_getId(m) : "(empty)"); printf( "functionDefinitions: %d\n", Model_getNumFunctionDefinitions(m) ); printf( " unitDefinitions: %d\n", Model_getNumUnitDefinitions (m) ); printf( " compartmentTypes: %d\n", Model_getNumCompartmentTypes (m) ); printf( " specieTypes: %d\n", Model_getNumSpeciesTypes (m) ); printf( " compartments: %d\n", Model_getNumCompartments (m) ); printf( " species: %d\n", Model_getNumSpecies (m) ); printf( " parameters: %d\n", Model_getNumParameters (m) ); printf( " initialAssignments: %d\n", Model_getNumInitialAssignments (m) ); printf( " rules: %d\n", Model_getNumRules (m) ); printf( " constraints: %d\n", Model_getNumConstraints (m) ); printf( " reactions: %d\n", Model_getNumReactions (m) ); printf( " events: %d\n", Model_getNumEvents (m) ); printf( "\n" ); SBMLDocument_free(d); return 0; }
END_TEST START_TEST (test_SBMLConvert_addModifiersToReaction) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(1, 2); Model_t *m = SBMLDocument_createModel(d); Reaction_t *r = Model_createReaction(m); KineticLaw_t *kl = Reaction_createKineticLaw(r); KineticLaw_setFormula(kl, "k1*S1*S2*S3*S4*S5"); SpeciesReference_t *ssr1; SpeciesReference_t *ssr2; Species_t *s1 = Model_createSpecies( m ); Species_setId( s1, "S1" ); Species_t *s2 = Model_createSpecies( m ); Species_setId( s2, "S2"); Species_t *s3 = Model_createSpecies( m ); Species_setId( s3, "S3"); Species_t *s4 = Model_createSpecies( m ); Species_setId( s4, "S4"); Species_t *s5 = Model_createSpecies( m ); Species_setId( s5, "S5"); SpeciesReference_t *sr1 = Reaction_createReactant( r ); SpeciesReference_t *sr2 = Reaction_createReactant( r ); SpeciesReference_t *sr3 = Reaction_createProduct ( r ); SpeciesReference_setSpecies(sr1, "S1"); SpeciesReference_setSpecies(sr2, "S2"); SpeciesReference_setSpecies(sr3, "S5"); fail_unless( Reaction_getNumModifiers(r) == 0, NULL ); fail_unless( SBMLDocument_setLevelAndVersionNonStrict(d, 2, 1) == 1, NULL ); fail_unless( SBMLDocument_getLevel (d) == 2, NULL ); fail_unless( SBMLDocument_getVersion(d) == 1, NULL ); fail_unless( Reaction_getNumModifiers(Model_getReaction(m, 0)) == 2, NULL ); ssr1 = (SpeciesReference_t *) Reaction_getModifier(Model_getReaction(m, 0), 0); ssr2 = (SpeciesReference_t *) Reaction_getModifier(Model_getReaction(m, 0), 1); fail_unless( !strcmp(SpeciesReference_getSpecies(ssr1), "S3"), NULL ); fail_unless( !strcmp(SpeciesReference_getSpecies(ssr2), "S4"), NULL ); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL3_defaultUnits) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(1, 2); Model_t *m = SBMLDocument_createModel(d); const char *sid = "C"; Compartment_t *c = Model_createCompartment(m); Compartment_setId ( c, sid ); Compartment_setSize ( c, 1.2 ); Compartment_setUnits( c, "volume"); fail_unless(Model_getNumUnitDefinitions(m) == 0); fail_unless( SBMLDocument_setLevelAndVersion(d, 3, 1) == 1, NULL); fail_unless(Model_getNumUnitDefinitions(m) == 2); UnitDefinition_t *ud = Model_getUnitDefinition(m, 0); fail_unless (ud != NULL); fail_unless (!strcmp(UnitDefinition_getId( ud), "volume")); fail_unless(UnitDefinition_getNumUnits(ud) == 1); Unit_t * u = UnitDefinition_getUnit(ud, 0); fail_unless(Unit_getKind(u) == UNIT_KIND_LITRE); fail_unless(Unit_getExponent(u) == 1); fail_unless(Unit_getMultiplier(u) == 1); fail_unless(Unit_getScale(u) == 0); ud = Model_getUnitDefinition(m, 1); fail_unless (ud != NULL); fail_unless (!strcmp(UnitDefinition_getId( ud), "time")); fail_unless(UnitDefinition_getNumUnits(ud) == 1); u = UnitDefinition_getUnit(ud, 0); fail_unless(Unit_getKind(u) == UNIT_KIND_SECOND); fail_unless(Unit_getExponent(u) == 1); fail_unless(Unit_getMultiplier(u) == 1); fail_unless(Unit_getScale(u) == 0); fail_unless(!strcmp(Model_getTimeUnits(m), "time")); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL1_SBMLDocument) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 1); fail_unless( SBMLDocument_setLevelAndVersionNonStrict(d, 1, 2) == 1, NULL); fail_unless( SBMLDocument_getLevel (d) == 1, NULL ); fail_unless( SBMLDocument_getVersion(d) == 2, NULL ); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLDocument_setModel2) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 2); Model_t *m1 = Model_create(1, 2); int i = SBMLDocument_setModel(d, m1); fail_unless ( i == LIBSBML_LEVEL_MISMATCH); fail_unless (SBMLDocument_getModel(d) == 0); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLDocument_setModel3) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 2); Model_t *m1 = Model_create(2, 2); int i = SBMLDocument_setModel(d, m1); fail_unless ( i == LIBSBML_OPERATION_SUCCESS); fail_unless (SBMLDocument_getModel(d) != 0); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvertStrict_convertNonStrictSBO) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 4); Model_t * m = SBMLDocument_createModel(d); /* create a compartment with SBO */ Compartment_t * c = Model_createCompartment(m); Compartment_setId(c, "c"); Compartment_setConstant(c, 0); SBase_setSBOTerm((SBase_t *) (c), 64); /* conversion to L2V3 and L2V2 should fail due to bad SBO * but to L2V1 and L1 should pass as sbo terms not applicable */ fail_unless( SBMLDocument_setLevelAndVersionStrict(d, 2, 3) == 0 ); fail_unless( SBMLDocument_getLevel (d) == 2, NULL ); fail_unless( SBMLDocument_getVersion(d) == 4, NULL ); fail_unless( SBMLDocument_setLevelAndVersionStrict(d, 2, 2) == 0 ); fail_unless( SBMLDocument_getLevel (d) == 2, NULL ); fail_unless( SBMLDocument_getVersion(d) == 4, NULL ); fail_unless( SBMLDocument_setLevelAndVersionStrict(d, 2, 1) == 1 ); fail_unless( SBMLDocument_getLevel (d) == 2, NULL ); fail_unless( SBMLDocument_getVersion(d) == 1, NULL ); /* check that sbo term has been removed */ Compartment_t *c1 = Model_getCompartment(SBMLDocument_getModel(d), 0); fail_unless (SBase_getSBOTerm((SBase_t *) (c1)) == -1, NULL ); fail_unless( SBMLDocument_setLevelAndVersionStrict(d, 1, 2) == 1 ); fail_unless( SBMLDocument_getLevel (d) == 1, NULL ); fail_unless( SBMLDocument_getVersion(d) == 2, NULL ); /* check that sbo term has been removed */ Compartment_t *c2 = Model_getCompartment(SBMLDocument_getModel(d), 0); fail_unless (SBase_getSBOTerm((SBase_t *) (c2)) == -1, NULL ); SBMLDocument_free(d); }
int main (int argc, char *argv[]) { const char *filename; #ifdef __BORLANDC__ unsigned long start, stop; #else unsigned long long start, stop; #endif unsigned long size; unsigned int errors = 0; SBMLDocument_t *d; if (argc != 2) { printf("Usage: validateSBML filename\n"); return 2; } filename = argv[1]; start = getCurrentMillis(); d = readSBML(filename); stop = getCurrentMillis(); errors = SBMLDocument_getNumErrors(d); errors += SBMLDocument_checkConsistency(d); size = getFileSize(filename); printf( "\n" ); printf( " filename: %s\n" , filename ); printf( " file size: %lu\n", size ); printf( " read time (ms): %llu\n", stop - start ); printf( " error(s): %u\n" , errors ); if (errors > 0) SBMLDocument_printErrors(d, stdout); printf("\n"); SBMLDocument_free(d); return errors; }
END_TEST START_TEST (test_SBMLDocument_setLevelAndVersion) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 2); Model_t *m1 = Model_create(2, 2); SBMLDocument_setModel(d, m1); fail_unless(SBMLDocument_setLevelAndVersionNonStrict(d,2,3) == 1); fail_unless(SBMLDocument_setLevelAndVersionNonStrict(d,2,1) == 1); fail_unless(SBMLDocument_setLevelAndVersionNonStrict(d,1,2) == 1); fail_unless(SBMLDocument_setLevelAndVersionNonStrict(d,1,1) == 0); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL3_event) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 2); Model_t *m = SBMLDocument_createModel(d); Event_t *e = Model_createEvent(m); Event_t *e1; fail_unless( SBMLDocument_setLevelAndVersionNonStrict(d, 3, 1) == 1, NULL); e1 = Model_getEvent(m, 0); fail_unless(Event_hasRequiredAttributes(e1) == 1); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLDocument_createWith) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(1, 2); fail_unless( SBase_getTypeCode ((SBase_t *) d) == SBML_DOCUMENT ); fail_unless( SBase_getNotes ((SBase_t *) d) == NULL ); fail_unless( SBase_getAnnotation((SBase_t *) d) == NULL ); fail_unless( SBMLDocument_getLevel (d) == 1); fail_unless( SBMLDocument_getVersion(d) == 2); fail_unless( SBMLDocument_getNumErrors (d) == 0 ); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL1_Species_Concentration) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 1); Model_t *m = SBMLDocument_createModel(d); const char *sid = "C"; Compartment_t *c = Compartment_create(2, 1); Species_t *s = Species_create(2, 1); Compartment_setId ( c, sid ); Compartment_setSize ( c, 1.2 ); Model_addCompartment( m, c ); Species_setId ( s, "s" ); Species_setCompartment ( s, sid ); Species_setInitialConcentration( s, 2.34 ); Model_addSpecies ( m, s ); fail_unless( SBMLDocument_setLevelAndVersion(d, 1, 2) == 1, NULL); /** * These tests will fail under Cygwin because of a minimal * setlocale() implementation (see setlocale manpage). */ #ifndef CYGWIN fail_unless( Species_getInitialAmount(Model_getSpecies(m, 0)) == 2.808, NULL ); #endif Species_t * s1 = Model_getSpecies(m, 0); fail_unless (s1 != NULL); fail_unless (!strcmp(Species_getCompartment(s1), "C")); fail_unless(Compartment_getSize(Model_getCompartmentById(m, "C")) == 1.2); fail_unless(Species_getInitialConcentration(s1) == 2.34); fail_unless(Species_isSetInitialConcentration(s1) == 1); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL3_reaction) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 2); Model_t *m = SBMLDocument_createModel(d); const char *sid = "C"; Reaction_t *r = Model_createReaction(m); Reaction_setId ( r, sid ); fail_unless( SBMLDocument_setLevelAndVersionNonStrict(d, 3, 1) == 1, NULL); Reaction_t *r1 = Model_getReaction(m, 0); fail_unless(Reaction_hasRequiredAttributes(r1) == 1); SBMLDocument_free(d); }
LIBSBML_CPP_NAMESPACE_USE BEGIN_C_DECLS START_TEST (test_SBMLDocument_create) { SBMLDocument_t *d = SBMLDocument_create(); fail_unless( SBase_getTypeCode ((SBase_t *) d) == SBML_DOCUMENT ); fail_unless( SBase_getNotes ((SBase_t *) d) == NULL ); fail_unless( SBase_getAnnotation((SBase_t *) d) == NULL ); fail_unless( SBMLDocument_getLevel (d) == 3); fail_unless( SBMLDocument_getVersion(d) == 1); fail_unless( SBMLDocument_getNumErrors (d) == 0 ); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL3_stoichiometryMath) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 1); Model_t *m = SBMLDocument_createModel(d); Compartment_t *c = Model_createCompartment(m); Compartment_setId ( c, "c" ); Species_t *s = Model_createSpecies(m); Species_setId(s, "s"); Species_setCompartment(s, "c"); Reaction_t * r = Model_createReaction(m); SpeciesReference_t *sr = Reaction_createReactant(r); SpeciesReference_setSpecies(sr, "s"); StoichiometryMath_t *sm = SpeciesReference_createStoichiometryMath(sr); ASTNode_t * ast = SBML_parseFormula("c*2"); StoichiometryMath_setMath(sm, ast); fail_unless(Model_getNumRules(m) == 0); fail_unless(SpeciesReference_isSetId(sr) == 0); fail_unless( SBMLDocument_setLevelAndVersionNonStrict(d, 3, 1) == 1); m = SBMLDocument_getModel(d); r = Model_getReaction(m, 0); sr = Reaction_getReactant(r, 0); fail_unless(Model_getNumRules(m) == 1); fail_unless(SpeciesReference_isSetId(sr) == 1); Rule_t *rule = Model_getRule(m, 0); fail_unless( strcmp(SpeciesReference_getId(sr), Rule_getVariable(rule)) == 0 ); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvertStrict_convertToL1) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 4); /* create model with metaid */ Model_t * m = SBMLDocument_createModel(d); SBase_setMetaId((SBase_t *) (m), "_m"); /* create a compartment with sbo*/ Compartment_t * c = Model_createCompartment(m); Compartment_setId(c, "c"); SBase_setSBOTerm((SBase_t *) (c), 240); /* create a species with hasOnlySubstanceUnits = true*/ Species_t *s = Model_createSpecies(m); Species_setId(s, "s"); Species_setCompartment(s, "c"); Species_setHasOnlySubstanceUnits(s, 1); fail_unless( SBMLDocument_setLevelAndVersionStrict(d, 1, 2) == 1 ); fail_unless( SBMLDocument_getLevel (d) == 1, NULL ); fail_unless( SBMLDocument_getVersion(d) == 2, NULL ); ///* check that attributes that are no longer valid have been removed */ Model_t * m1 = SBMLDocument_getModel(d); fail_unless (SBase_getMetaId((SBase_t *) (m1)) == NULL); Compartment_t *c1 = Model_getCompartment(m1, 0); fail_unless (SBase_getSBOTerm((SBase_t *) (c1)) == -1, NULL ); Species_t *s1 = Model_getSpecies(m1, 0); fail_unless (Species_getHasOnlySubstanceUnits(s1) == 0); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL3_trigger) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 2); Model_t *m = SBMLDocument_createModel(d); Event_t *e = Model_createEvent(m); Trigger_t *t = Event_createTrigger(e); Trigger_t *t1; fail_unless( SBMLDocument_setLevelAndVersionNonStrict(d, 3, 1) == 1, NULL); t1 = Event_getTrigger(Model_getEvent(m, 0)); fail_unless(Trigger_hasRequiredAttributes(t1) == 1); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL3_unit) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 2); Model_t *m = SBMLDocument_createModel(d); const char *sid = "C"; UnitDefinition_t *ud = Model_createUnitDefinition(m); UnitDefinition_setId ( ud, sid ); Unit_t *u = UnitDefinition_createUnit(ud); Unit_setKind(u, UNIT_KIND_MOLE); fail_unless( SBMLDocument_setLevelAndVersionNonStrict(d, 3, 1) == 1, NULL); Unit_t *u1 = UnitDefinition_getUnit(Model_getUnitDefinition(m, 0), 0); fail_unless(Unit_hasRequiredAttributes(u1) == 1); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL3_parameter) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 2); Model_t *m = SBMLDocument_createModel(d); const char *sid = "C"; Parameter_t *p = Model_createParameter(m); Parameter_t *p1; Parameter_setId ( p, sid ); fail_unless( SBMLDocument_setLevelAndVersionNonStrict(d, 3, 1) == 1, NULL); p1 = Model_getParameter(m, 0); fail_unless(Parameter_hasRequiredAttributes(p1) == 1); SBMLDocument_free(d); }
END_TEST START_TEST (test_SBMLConvert_convertToL3_product) { SBMLDocument_t *d = SBMLDocument_createWithLevelAndVersion(2, 2); Model_t *m = SBMLDocument_createModel(d); Reaction_t *r = Model_createReaction(m); SpeciesReference_t *sr = Reaction_createProduct(r); SpeciesReference_t *sr1; SpeciesReference_setSpecies ( sr, "s" ); fail_unless( SBMLDocument_setLevelAndVersionNonStrict(d, 3, 1) == 1, NULL); sr1 = Reaction_getProduct(Model_getReaction(m, 0), 0); fail_unless(SpeciesReference_hasRequiredAttributes(sr1) == 1); SBMLDocument_free(d); }