def test_replace_model(self): from libcellml import Component, Importer, Model, Parser parser = Parser() model = parser.parseModel( file_contents("importer/generic_no_source.cellml")) importer = Importer() wrongSourceModel = Model("wrong") rightSourceModel = Model("right") rightSourceModel.addComponent(Component("a")) rightSourceModel.addComponent(Component("b")) rightSourceModel.addComponent(Component("c")) rightSourceModel.addComponent(Component("d")) self.assertTrue( importer.addModel(wrongSourceModel, "i_dont_exist.cellml")) self.assertFalse( importer.replaceModel(rightSourceModel, "not_in_library")) self.assertTrue( importer.replaceModel(rightSourceModel, "i_dont_exist.cellml")) importer.resolveImports(model, "") self.assertEqual(0, importer.issueCount()) self.assertFalse(model.hasUnresolvedImports())
def test_replace_model(self): from libcellml import Component, Importer, Model, Parser parser = Parser() model = parser.parseModel( file_contents('importer/generic_no_source.cellml')) importer = Importer() wrongSourceModel = Model('wrong') rightSourceModel = Model('right') rightSourceModel.addComponent(Component('a')) rightSourceModel.addComponent(Component('b')) rightSourceModel.addComponent(Component('c')) rightSourceModel.addComponent(Component('d')) self.assertTrue( importer.addModel(wrongSourceModel, 'i_dont_exist.cellml')) self.assertFalse( importer.replaceModel(rightSourceModel, 'not_in_library')) self.assertTrue( importer.replaceModel(rightSourceModel, 'i_dont_exist.cellml')) importer.resolveImports(model, '') self.assertEqual(0, importer.issueCount()) self.assertFalse(model.hasUnresolvedImports())
def test_importer(self): from libcellml import Importer, Parser, Printer parser = Parser() i = Importer() m = parser.parseModel(file_contents('importer/diamond.cellml')) printer = Printer() i.resolveImports(m, resource_path('importer/')) self.assertFalse(m.hasUnresolvedImports()) # Library should contain left, right, and one instance (not two) of the point. self.assertEqual(3, i.libraryCount()) self.assertEqual(resource_path('importer/diamond_left.cellml'), i.key(0)) self.assertEqual(resource_path('importer/diamond_point.cellml'), i.key(1)) self.assertEqual(resource_path('importer/diamond_right.cellml'), i.key(2)) # Access library items by their URL. left = i.library(resource_path('importer/diamond_left.cellml')) self.assertEqual(file_contents('importer/diamond_left.cellml'), printer.printModel(left))
def test_parse_model(self): import libcellml from libcellml import Parser # ModelPtr parseModel(const std::string &input) p = Parser() self.assertIsInstance(p.parseModel('rubbish'), libcellml.Model)
def test_create_destroy(self): from libcellml import Parser x = Parser() del (x) y = Parser() z = Parser(y) del (y, z)
def test_ids(self): from libcellml import Annotator, Parser annotator = Annotator() parser = Parser() model = parser.parseModel(file_contents("annotator/unique_ids.cellml")) annotator.setModel(model) self.assertEqual(24, len(annotator.ids()))
def test_duplicate_count(self): from libcellml import Annotator, Parser annotator = Annotator() parser = Parser() model = parser.parseModel(file_contents("annotator/lots_of_duplicate_ids.cellml")) annotator.setModel(model) self.assertEqual(8, annotator.itemCount("duplicateId1")) self.assertEqual(7, annotator.itemCount("duplicateId3"))
def test_inheritance(self): import libcellml from libcellml import Parser x = Parser() self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods self.assertIsNone(x.issue(0)) self.assertIsNone(x.issue(-1)) self.assertEqual(x.issueCount(), 0)
def test_has_model(self): from libcellml import Annotator, Parser annotator = Annotator() parser = Parser() self.assertFalse(annotator.hasModel()) model = parser.parseModel(file_contents("annotator/unique_ids.cellml")) annotator.setModel(model) self.assertTrue(annotator.hasModel())
def test_remove_all_models(self): from libcellml import Parser, Importer parser = Parser() model = parser.parseModel(file_contents('importer/diamond.cellml')) importer = Importer() importer.resolveImports(model, resource_path('importer/')) self.assertEqual(3, importer.libraryCount()) importer.removeAllModels() self.assertEqual(0, importer.libraryCount())
def test_flatten(self): from libcellml import Importer, Parser parser = Parser() importer = Importer() model = parser.parseModel(file_contents('importer/diamond.cellml')) importer.resolveImports(model, resource_path('importer/')) flattenedModel = importer.flattenModel(model) self.assertEqual(2, flattenedModel.componentCount())
def test_auto_ids(self): from libcellml import Annotator, Parser, Variable annotator = Annotator() parser = Parser() model_string = file_contents("annotator/unique_ids.cellml") model = parser.parseModel(model_string) annotator.setModel(model) annotator.clearAllIds() annotator.assignAllIds() self.assertEqual("b4da55", model.id()) self.assertEqual("b4da56", model.importSource(0).id()) self.assertEqual("b4da57", model.importSource(1).id()) self.assertEqual("b4da58", model.units(0).id()) self.assertEqual("b4da59", model.units(1).id()) self.assertEqual("b4da5a", model.units(2).id()) self.assertEqual("b4da5b", model.units(3).id()) self.assertEqual("b4da5c", model.units(1).unitId(0)) self.assertEqual("b4da5d", model.component(0).id()) self.assertEqual("b4da5e", model.component(1).id()) self.assertEqual("b4da5f", model.component(1).component(0).id()) self.assertEqual("b4da60", model.component(1).variable(0).id()) self.assertEqual("b4da61", model.component(1).variable(1).id()) self.assertEqual("b4da62", model.component(1).component(0).variable(0).id()) self.assertEqual("b4da63", model.component(1).component(0).variable(1).id()) self.assertEqual("b4da64", model.component(1).reset(0).id()) self.assertEqual("b4da65", model.component(1).reset(0).resetValueId()) self.assertEqual("b4da66", model.component(1).reset(0).testValueId()) c2v1 = model.component("component2").variable("variable1") c2v2 = model.component("component2").variable("variable2") c3v1 = model.component("component3").variable("variable1") c3v2 = model.component("component3").variable("variable2") self.assertEqual("b4da67", Variable.equivalenceConnectionId(c2v1, c3v1)) self.assertEqual("b4da67", Variable.equivalenceConnectionId(c2v2, c3v2)) self.assertEqual("b4da68", Variable.equivalenceMappingId(c2v1, c3v1)) self.assertEqual("b4da69", Variable.equivalenceMappingId(c2v2, c3v2)) self.assertEqual("b4da6a", model.component("component2").encapsulationId()) self.assertEqual("b4da6b", model.component("component3").encapsulationId()) self.assertEqual("b4da6c", model.encapsulationId())
def test_raise_not_found_issue(self): from libcellml import Annotator, Parser annotator = Annotator() parser = Parser() message = 'Could not find an item with an id of \'i_dont_exist\' in the model.' model = parser.parseModel(file_contents('annotator/unique_ids.cellml')) annotator.setModel(model) annotator.item('i_dont_exist') self.assertEqual(1, annotator.issueCount()) self.assertEqual(message, annotator.issue(0).description())
def test_raise_non_unique_issue(self): from libcellml import Annotator, Parser annotator = Annotator() parser = Parser() non_unique_message = 'The identifier \'duplicateId\' occurs 29 times in the model so a unique item cannot be located.' model = parser.parseModel(file_contents('annotator/duplicate_ids.cellml')) annotator.setModel(model) annotator.item('duplicateId') self.assertEqual(1, annotator.issueCount()) self.assertEqual(non_unique_message, annotator.issue(0).description())
def test_algebraic_eqn_computed_var_on_rhs(self): from libcellml import Analyser from libcellml import AnalyserModel from libcellml import Generator from libcellml import GeneratorProfile from libcellml import Parser from test_resources import file_contents p = Parser() m = p.parseModel( file_contents( 'generator/algebraic_eqn_computed_var_on_rhs/model.cellml')) a = Analyser() a.analyseModel(m) am = a.model() self.assertEqual(AnalyserModel.Type.ALGEBRAIC, am.type()) g = Generator() self.assertIsNone(g.model()) g.setModel(am) self.assertIsNotNone(g.model()) self.assertEqual( file_contents( "generator/algebraic_eqn_computed_var_on_rhs/model.h"), g.interfaceCode()) self.assertEqual( file_contents( "generator/algebraic_eqn_computed_var_on_rhs/model.c"), g.implementationCode()) self.assertEqual(GeneratorProfile.Profile.C, g.profile().profile()) profile = GeneratorProfile(GeneratorProfile.Profile.PYTHON) g.setProfile(profile) self.assertEqual("", g.interfaceCode()) self.assertEqual( file_contents( "generator/algebraic_eqn_computed_var_on_rhs/model.py"), g.implementationCode()) self.assertEqual(GeneratorProfile.Profile.PYTHON, g.profile().profile())
def test_item(self): from libcellml import Annotator, CellmlElementType, Model, Parser annotator = Annotator() model = Model() parser = Parser() model_string = file_contents("annotator/unique_ids.cellml") model = parser.parseModel(model_string) annotator.setModel(model) self.assertEqual(CellmlElementType.UNDEFINED, annotator.item("not_an_id").type()) self.assertEqual(CellmlElementType.UNDEFINED, annotator.item("not_an_id", 3).type()) self.assertEqual(CellmlElementType.MAP_VARIABLES, annotator.item("map_variables_2").type())
def test_resolve_imports(self): from libcellml import Importer from libcellml import Parser i = Importer() p = Parser() m = p.parseModel(file_contents('sine_approximations_import.xml')) self.assertEqual(0, p.issueCount()) self.assertTrue(m.hasUnresolvedImports()) i.resolveImports(m, resource_path()) self.assertFalse(m.hasUnresolvedImports())
def test_is_unique(self): from libcellml import Annotator, Parser annotator = Annotator() parser = Parser() model = parser.parseModel(file_contents("annotator/unique_ids.cellml")) annotator.setModel(model) self.assertTrue(annotator.isUnique("variable_3")) model = parser.parseModel(file_contents("annotator/lots_of_duplicate_ids.cellml")) annotator.setModel(model) self.assertFalse(annotator.isUnique("duplicateId2"))
def test_is_resolved_component(self): from libcellml import Importer, Parser parser = Parser() importer = Importer() model = parser.parseModel( file_contents("importer/component_importer_unresolved.cellml")) self.assertEqual(0, parser.issueCount()) importer.resolveImports(model, resource_path("importer/")) self.assertEqual(1, importer.issueCount()) c = model.component(0) self.assertFalse(c.isResolved())
def test_clear_imports(self): from libcellml import Importer, Parser parser = Parser() importer = Importer() model = parser.parseModel( file_contents('importer/nested_components.cellml')) self.assertEqual(0, parser.issueCount()) importer.resolveImports(model, resource_path('importer/')) self.assertEqual(0, importer.issueCount()) self.assertFalse(model.hasUnresolvedImports()) importer.clearImports(model) self.assertTrue(model.hasUnresolvedImports())
def test_is_resolved_units(self): from libcellml import Importer, Parser parser = Parser() importer = Importer() model = parser.parseModel( file_contents("importer/master_units.cellml")) self.assertEqual(0, parser.issueCount()) importer.resolveImports(model, resource_path("importer/")) self.assertEqual(0, importer.issueCount()) u = model.units(0) self.assertTrue(u.isResolved())
def test_requirements(self): from libcellml import Parser, Importer keys = [ 'complicatedComponents.cellml', 'complicatedUnits.cellml', ] parser = Parser() model = parser.parseModel(file_contents('import-requirements/complicatedExample.cellml')) self.assertEqual(0, parser.issueCount()) requirements = model.importRequirements() i = 0 for r in requirements: self.assertEqual(keys[i], r) i += 1
def test_inheritance(self): import libcellml from libcellml import Parser x = Parser() self.assertIsInstance(x, libcellml.Logger) # Test access to inherited methods self.assertIsNone(x.getError(0)) self.assertIsNone(x.getError(-1)) self.assertEqual(x.errorCount(), 0) x.addError(libcellml.Error()) self.assertEqual(x.errorCount(), 1)
def test_add_model(self): from libcellml import Component, Importer, Model, Parser parser = Parser() importer = Importer() model = parser.parseModel( file_contents('importer/generic_no_source.cellml')) sourceModel = Model('source') sourceModel.addComponent(Component('a')) sourceModel.addComponent(Component('b')) sourceModel.addComponent(Component('c')) sourceModel.addComponent(Component('d')) # Add a model manually to the library, including the URL that it will replace in future imports. self.assertTrue(importer.addModel(sourceModel, 'i_dont_exist.cellml')) self.assertFalse(importer.addModel(sourceModel, 'i_dont_exist.cellml')) importer.resolveImports(model, '') self.assertEqual(0, importer.issueCount()) self.assertFalse(model.hasUnresolvedImports())
def test_resolve_imports(self): from libcellml import Importer from libcellml import Parser i = Importer() p = Parser() m1 = p.parseModel(file_contents('importer/units_imported.cellml')) m2 = p.parseModel(file_contents('importer/units_imported.cellml')) m3 = p.parseModel(file_contents('importer/units_imported.cellml')) self.assertEqual(0, p.issueCount()) self.assertTrue(m1.hasUnresolvedImports()) i.resolveImports(m1, resource_path('importer/')) self.assertFalse(m1.hasUnresolvedImports()) self.assertTrue(m2.hasUnresolvedImports()) i.resolveImports(m2, resource_path('importer')) self.assertFalse(m2.hasUnresolvedImports()) self.assertTrue(m3.hasUnresolvedImports()) i.resolveImports(m3, resource_path('importer\\')) self.assertFalse(m3.hasUnresolvedImports())
model_file = 'MembraneModel.cellml' if len(sys.argv) > 1: model_file = sys.argv[1] # STEP 1: Parse an existing model from a CellML file. # The Parser class is used to deserialise a CellML string into a Model instance. # This means that you're responsible for finding, opening and reading the.cellml # file into a single string. The Parser will then read that string and return a model. # 1.a # Read a CellML file into a std.string. with open(model_file) as f: content = f.read() # 1.b # Create a Parser item. parser = Parser() # 1.c # Use the parser to deserialise the contents of the string you've read and return the model. model = parser.parseModel(content) # 1.d # Print the parsed model to the terminal for viewing. print_model(model, False) # end 1 print('----------------------------------------------------------') print(' STEP 2: Resolve the imports and flatten ') print('----------------------------------------------------------')
from libcellml import Analyser, Importer, Model, Parser, Printer, Validator if __name__ == '__main__': # STEP 1 # Parse an existing CellML model from a file. read_file = open('debugAnalysisExample.cellml', 'r') parser = Parser() model = parser.parseModel(read_file.read()) # STEP 2 # Resolve any imports and flatten the model for analysis. importer = Importer() # Resolve the imports. importer.resolveImports(model, '') # Check for issues. print('The importer found {} issues.'.format(importer.issueCount())) for i in range(0, importer.issueCount()): issue = importer.issue(i) print(issue.description()) # Flatten the model. model = importer.flattenModel(model) # STEP 3 # Create an Validator instance and pass the model to it for processing. validator = Validator() validator.validateModel(model) # Print any issues to the terminal.
def test_create_destroy(self): from libcellml import Parser x = Parser() del x
def test_issue_types(self): from libcellml import Parser, Issue p = Parser() i1 = Issue() i1.setLevel(Issue.Level.ERROR) i1.setDescription("error error") p.addIssue(i1) i4 = Issue() i4.setLevel(Issue.Level.WARNING) i4.setDescription("warning warning") p.addIssue(i4) i2 = Issue() i2.setLevel(Issue.Level.HINT) i2.setDescription("hint hint") p.addIssue(i2) i3 = Issue() i3.setLevel(Issue.Level.MESSAGE) i3.setDescription("message message") p.addIssue(i3) self.assertEqual(1, p.errorCount()) error = p.error(0) self.assertEqual("error error", error.description()) self.assertEqual(1, p.warningCount()) warning = p.warning(0) self.assertEqual("warning warning", warning.description()) self.assertEqual(1, p.hintCount()) hint = p.hint(0) self.assertEqual("hint hint", hint.description()) self.assertEqual(1, p.messageCount()) message = p.message(0) self.assertEqual("message message", message.description()) self.assertEqual(4, p.issueCount()) p.removeAllIssues() self.assertEqual(0, p.issueCount())
def test_coverage(self): from libcellml import Analyser from libcellml import AnalyserEquation from libcellml import AnalyserEquationAst from libcellml import AnalyserExternalVariable from libcellml import AnalyserModel from libcellml import AnalyserVariable from libcellml import Model from libcellml import Parser from test_resources import file_contents # Try to create an analyser equation/model/variable, something that is not allowed. self.assertRaises(AttributeError, AnalyserEquation) self.assertRaises(AttributeError, AnalyserModel) self.assertRaises(AttributeError, AnalyserVariable) # Analyse a model, so we can then do some coverage. p = Parser() m = p.parseModel(file_contents('generator/noble_model_1962/model.cellml')) a = Analyser() a.analyseModel(m) # Ensure coverage for Analyser. c = m.component(1) v0 = c.variable(0) aev = AnalyserExternalVariable(v0) self.assertTrue(a.addExternalVariable(aev)) self.assertTrue(a.containsExternalVariable(aev)) self.assertTrue(a.containsExternalVariable(m, c.name(), v0.name())) self.assertEqual(aev.variable().name(), a.externalVariable(0).variable().name()) self.assertEqual(aev.variable().name(), a.externalVariable(m, c.name(), v0.name()).variable().name()) v2 = c.variable(2) self.assertTrue(a.addExternalVariable(AnalyserExternalVariable(c.variable(1)))) self.assertTrue(a.addExternalVariable(AnalyserExternalVariable(v2))) self.assertTrue(a.addExternalVariable(AnalyserExternalVariable(c.variable(3)))) self.assertEqual(4, a.externalVariableCount()) self.assertTrue(a.removeExternalVariable(1)) self.assertTrue(a.removeExternalVariable(aev)) self.assertTrue(a.removeExternalVariable(m, c.name(), v2.name())) a.removeAllExternalVariables() # Ensure coverage for AnalyserModel. am = a.model() self.assertTrue(am.isValid()) self.assertFalse(am.hasExternalVariables()) self.assertIsNotNone(am.voi()) self.assertEqual(4, am.stateCount()) self.assertIsNotNone(am.states()) self.assertIsNotNone(am.state(3)) self.assertEqual(17, am.variableCount()) self.assertIsNotNone(am.variables()) self.assertIsNotNone(am.variable(3)) self.assertEqual(16, am.equationCount()) self.assertIsNotNone(am.equations()) self.assertIsNotNone(am.equation(3)) self.assertFalse(am.needEqFunction()) self.assertFalse(am.needNeqFunction()) self.assertFalse(am.needLtFunction()) self.assertFalse(am.needLeqFunction()) self.assertFalse(am.needGtFunction()) self.assertFalse(am.needGeqFunction()) self.assertFalse(am.needAndFunction()) self.assertFalse(am.needOrFunction()) self.assertFalse(am.needXorFunction()) self.assertFalse(am.needNotFunction()) self.assertFalse(am.needMinFunction()) self.assertFalse(am.needMaxFunction()) self.assertFalse(am.needSecFunction()) self.assertFalse(am.needCscFunction()) self.assertFalse(am.needCotFunction()) self.assertFalse(am.needSechFunction()) self.assertFalse(am.needCschFunction()) self.assertFalse(am.needCothFunction()) self.assertFalse(am.needAsecFunction()) self.assertFalse(am.needAcscFunction()) self.assertFalse(am.needAcotFunction()) self.assertFalse(am.needAsechFunction()) self.assertFalse(am.needAcschFunction()) self.assertFalse(am.needAcothFunction()) self.assertTrue(am.areEquivalentVariables(am.voi().variable(), am.voi().variable())) # Ensure coverage for AnalyserVariable. av = am.variable(3) self.assertEqual(AnalyserVariable.Type.CONSTANT, av.type()) self.assertEqual(3, av.index()) self.assertIsNotNone(av.initialisingVariable()) self.assertIsNotNone(av.variable()) self.assertIsNone(av.equation()) # Ensure coverage for AnalyserEquation. ae = am.equation(3) self.assertEqual(AnalyserEquation.Type.RATE, ae.type()) self.assertIsNotNone(ae.ast()) self.assertIsNotNone(ae.dependencies()) self.assertTrue(ae.isStateRateBased()) self.assertIsNotNone(ae.variable()) # Ensure coverage for AnalyserEquationAst. aea = ae.ast() self.assertEqual(AnalyserEquationAst.Type.ASSIGNMENT, aea.type()) self.assertEqual('', aea.value()) self.assertIsNone(aea.variable()) self.assertIsNone(aea.parent()) self.assertIsNotNone(aea.leftChild()) self.assertIsNotNone(aea.rightChild()) aea.setType(AnalyserEquationAst.Type.EQ) aea.setValue(AnalyserTestCase.VALUE) aea.setVariable(av.variable()) aea.setParent(aea) aea.setLeftChild(None) aea.setRightChild(None) self.assertEqual(AnalyserEquationAst.Type.EQ, aea.type()) self.assertEqual(AnalyserTestCase.VALUE, aea.value()) self.assertIsNotNone(aea.variable()) self.assertIsNotNone(aea.parent()) self.assertIsNone(aea.leftChild()) self.assertIsNone(aea.rightChild())