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_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_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_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_coverage(self): from libcellml import Issue from libcellml import Parser from test_resources import file_contents self.assertRaises(AttributeError, Issue) p = Parser() p.parseModel(file_contents('invalid_cellml_2.0.xml')) self.assertEqual(2, p.issueCount()) i = p.issue(0) self.assertEqual(Issue.Level.ERROR, i.level()) self.assertNotEqual(None, i.item()) self.assertEqual("1.2.1", i.referenceHeading()) self.assertEqual(1, i.referenceRule()) self.assertEqual( "https://cellml-specification.readthedocs.io/en/latest/reference/formal_and_informative/specA02.html?issue=XML", i.url()) self.assertEqual(2, p.errorCount()) self.assertEqual(None, p.error(4)) self.assertEqual(0, p.warningCount()) self.assertEqual(None, p.warning(0)) self.assertEqual(0, p.messageCount()) self.assertEqual(None, p.message(0))
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_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_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())
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_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_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_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_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_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())
def test_assign_by_type(self): from libcellml import Annotator, Parser, Variable, CellmlElementType from libcellml import UnitsItem, VariablePair annotator = Annotator() parser = Parser() model_string = file_contents("annotator/no_ids.cellml") model = parser.parseModel(model_string) annotator.setModel(model) c = model.component(0) self.assertEqual("", model.id()) annotator.assignId(model) self.assertEqual("b4da55", model.id()) self.assertEqual("", model.encapsulationId()) annotator.assignId(model, CellmlElementType.ENCAPSULATION) self.assertEqual("b4da56", model.encapsulationId()) self.assertEqual("", c.id()) annotator.assignId(c) self.assertEqual("b4da57", c.id()) self.assertEqual("", c.encapsulationId()) annotator.assignId(c, CellmlElementType.COMPONENT_REF) self.assertEqual("b4da58", c.encapsulationId()) c2v1 = model.component("component2").variable("variable1") c3v1 = model.component("component3").variable("variable1") self.assertEqual("", Variable.equivalenceConnectionId(c2v1, c3v1)) annotator.assignId(VariablePair(c2v1, c3v1), CellmlElementType.CONNECTION) self.assertEqual("b4da59", Variable.equivalenceConnectionId(c2v1, c3v1)) self.assertEqual("", Variable.equivalenceMappingId(c2v1, c3v1)) annotator.assignId(VariablePair(c2v1, c3v1)) self.assertEqual("b4da5a", Variable.equivalenceMappingId(c2v1, c3v1)) c3v2 = model.component("component3").variable("variable2") self.assertEqual("", c3v2.id()) annotator.assignId(c3v2) self.assertEqual("b4da5b", c3v2.id()) u = model.units(1) self.assertEqual("", u.id()) annotator.assignId(u) self.assertEqual("b4da5c", u.id()) r = model.component("component2").reset(0) self.assertEqual("", r.id()) annotator.assignId(r) self.assertEqual("b4da5d", r.id()) self.assertEqual("", r.testValueId()) annotator.assignId(r, CellmlElementType.TEST_VALUE) self.assertEqual("b4da5e", r.testValueId()) self.assertEqual("", r.resetValueId()) annotator.assignId(r, CellmlElementType.RESET_VALUE) self.assertEqual("b4da5f", r.resetValueId()) i = model.component("component1").importSource() self.assertEqual("", i.id()) annotator.assignId(i) self.assertEqual("b4da60", i.id()) self.assertEqual("", u.unitId(0)) annotator.assignId(UnitsItem(u, 0)) self.assertEqual("b4da61", u.unitId(0))
def test_any_cellml_element(self): from libcellml import Annotator, AnyCellmlElement, Parser from libcellml.enums import CellmlElementType self.assertRaises(AttributeError, AnyCellmlElement) parser = Parser() model = parser.parseModel(file_contents('annotator/unique_ids.cellml')) annotator = Annotator() annotator.setModel(model) item = annotator.item('component_1') self.assertEqual(CellmlElementType.COMPONENT, item.type()) self.assertEqual('component1', item.component().name()) item = annotator.item('component_ref_1') self.assertEqual(CellmlElementType.COMPONENT_REF, item.type()) self.assertEqual('component2', item.component().name()) item = annotator.item('connection_1') self.assertEqual(CellmlElementType.CONNECTION, item.type()) self.assertEqual('variable1', item.variablePair().variable1().name()) self.assertEqual('variable1', item.variablePair().variable2().name()) self.assertTrue(item.variablePair().isValid()) item = annotator.item('encapsulation_1') self.assertEqual(CellmlElementType.ENCAPSULATION, item.type()) self.assertEqual('everything', item.model().name()) item = annotator.item('import_1') self.assertEqual(CellmlElementType.IMPORT, item.type()) self.assertEqual('some-other-model.xml', item.importSource().url()) item = annotator.item('map_variables_1') self.assertEqual(CellmlElementType.MAP_VARIABLES, item.type()) self.assertEqual('variable1', item.variablePair().variable1().name()) self.assertEqual('variable1', item.variablePair().variable2().name()) self.assertTrue(item.variablePair().isValid()) item = annotator.item('model_1') self.assertEqual(CellmlElementType.MODEL, item.type()) self.assertEqual('everything', item.model().name()) resetItem = annotator.item('reset_1') self.assertEqual(CellmlElementType.RESET, resetItem.type()) self.assertEqual(1, resetItem.reset().order()) item = annotator.item('reset_value_1') self.assertEqual(CellmlElementType.RESET_VALUE, item.type()) self.assertEqual(resetItem.reset().resetValue(), item.reset().resetValue()) item = annotator.item('test_value_1') self.assertEqual(CellmlElementType.TEST_VALUE, item.type()) self.assertEqual(resetItem.reset().testValue(), item.reset().testValue()) item = annotator.item('unit_1') self.assertEqual(CellmlElementType.UNIT, item.type()) self.assertEqual('units2', item.unitsItem().units().name()) self.assertTrue(item.unitsItem().isValid()) item = annotator.item('units_1') self.assertEqual(CellmlElementType.UNITS, item.type()) self.assertEqual('units1', item.units().name()) item = annotator.item('variable_1') self.assertEqual(CellmlElementType.VARIABLE, item.type()) self.assertEqual('variable1', item.variable().name())
def test_list_duplicate_ids(self): from libcellml import Annotator, CellmlElementType, Parser model_string = file_contents("annotator/lots_of_duplicate_ids.cellml") parser = Parser() annotator = Annotator() model = parser.parseModel(model_string) annotator.setModel(model) id_list = annotator.duplicateIds() expected_ids = ('duplicateId1', 'duplicateId2', 'duplicateId3', 'duplicateId4') self.assertEqual(expected_ids, id_list) # Get the collections by duplicated id. c2v1 = model.component("component2").variable("variable1") c2v2 = model.component("component2").variable("variable2") c3v1 = model.component("component2").component("component3").variable( "variable1") c3v2 = model.component("component2").component("component3").variable( "variable2") c4v1 = model.component("component4").variable("variable1") c4v2 = model.component("component4").variable("variable2") expected_items = { "duplicateId1": ( (CellmlElementType.UNITS, model.units("units2")), (CellmlElementType.IMPORT, model.importSource(0)), (CellmlElementType.MAP_VARIABLES, (c4v1, c2v1)), (CellmlElementType.COMPONENT, model.component("component2")), (CellmlElementType.CONNECTION, (c2v1, c3v1)), (CellmlElementType.TEST_VALUE, model.component("component2").reset(0)), (CellmlElementType.COMPONENT_REF, model.component("component2").component("component3")), (CellmlElementType.VARIABLE, model.component("component2").component( "component3").variable("variable2")), ), "duplicateId2": ( (CellmlElementType.MODEL, model), (CellmlElementType.UNITS, model.units("units1")), (CellmlElementType.UNITS, model.units("blob")), (CellmlElementType.CONNECTION, (c4v2, c2v2)), (CellmlElementType.VARIABLE, c4v2), (CellmlElementType.COMPONENT_REF, model.component("component2")), (CellmlElementType.RESET, model.component("component2").reset(0)), (CellmlElementType.VARIABLE, c3v1), ), "duplicateId3": ( (CellmlElementType.IMPORT, model.importSource(1)), (CellmlElementType.UNITS, model.units("units3")), (CellmlElementType.VARIABLE, c4v1), (CellmlElementType.VARIABLE, c2v2), (CellmlElementType.MAP_VARIABLES, (c2v2, c4v2)), (CellmlElementType.COMPONENT, model.component("component2").component("component3")), (CellmlElementType.ENCAPSULATION, model), ), "duplicateId4": ( (CellmlElementType.UNIT, ((model.units("units2"), 0))), (CellmlElementType.COMPONENT, model.component("component1")), (CellmlElementType.COMPONENT, model.component("component4")), (CellmlElementType.MAP_VARIABLES, (c2v1, c3v1)), (CellmlElementType.VARIABLE, c2v1), (CellmlElementType.MAP_VARIABLES, (c2v2, c4v2)), (CellmlElementType.RESET_VALUE, model.component("component2").reset(0)), ) } for id in expected_ids: items_with_id = annotator.items(id) count = 0 for item in items_with_id: self.assertEqual(item[0], expected_items[id][count][0]) # SWIG copies the pointers so can't expect a comparison to be true. Not sure how to # compare these ... # self.assertEqual(item[1], expected_items[id][count][1]) count = count + 1
def test_auto_id_individual(self): from libcellml import Annotator, CellmlElementType, Parser, Variable from libcellml import Unit, VariablePair annotator = Annotator() parser = Parser() model_string = file_contents("annotator/no_ids.cellml") model = parser.parseModel(model_string) annotator.setModel(model) self.assertEqual( "b4da55", annotator.assignId(model.component(0), CellmlElementType.COMPONENT)) self.assertEqual("b4da55", model.component(0).id()) self.assertEqual( "b4da56", annotator.assignId(model.component("component2"), CellmlElementType.COMPONENT_REF)) self.assertEqual("b4da56", model.component("component2").encapsulationId()) self.assertEqual( "b4da57", annotator.assignId( VariablePair( model.component("component2").variable("variable1"), model.component("component2").variable( "variable1").equivalentVariable(0)), CellmlElementType.CONNECTION)) self.assertEqual( "b4da57", Variable.equivalenceConnectionId( model.component("component2").variable("variable1"), model.component("component2").variable( "variable1").equivalentVariable(0))) self.assertEqual("b4da58", annotator.assignId(model.importSource(0))) self.assertEqual("b4da58", model.importSource(0).id()) self.assertEqual( "b4da59", annotator.assignId( VariablePair( model.component("component2").variable("variable2"), model.component("component2").variable( "variable2").equivalentVariable(0)), CellmlElementType.MAP_VARIABLES)) self.assertEqual( "b4da59", Variable.equivalenceMappingId( model.component("component2").variable("variable2"), model.component("component2").variable( "variable2").equivalentVariable(0))) self.assertEqual("b4da5a", annotator.assignId(model, CellmlElementType.MODEL)) self.assertEqual("b4da5a", model.id()) self.assertEqual( "b4da5b", annotator.assignId( model.component("component2").reset(0), CellmlElementType.RESET)) self.assertEqual("b4da5b", model.component("component2").reset(0).id()) self.assertEqual( "b4da5c", annotator.assignId( model.component("component2").reset(0), CellmlElementType.RESET_VALUE)) self.assertEqual("b4da5c", model.component("component2").reset(0).resetValueId()) self.assertEqual( "b4da5d", annotator.assignId( model.component("component2").reset(0), CellmlElementType.TEST_VALUE)) self.assertEqual("b4da5d", model.component("component2").reset(0).testValueId()) self.assertEqual("b4da5e", annotator.assignId(Unit(model.units(1), 0))) self.assertEqual("b4da5e", model.units(1).unitId(0)) self.assertEqual("b4da5f", annotator.assignId(model.units(1))) self.assertEqual("b4da5f", model.units(1).id()) self.assertEqual("b4da60", annotator.assignId(model.component(1).variable(0))) self.assertEqual("b4da60", model.component(1).variable(0).id()) self.assertEqual( "b4da61", annotator.assignId(model, CellmlElementType.ENCAPSULATION)) self.assertEqual("b4da61", model.encapsulationId())
def test_type_based_retrieval(self): from libcellml import Annotator, Model, Parser annotator = Annotator() model = Model() parser = Parser() model_string = file_contents("annotator/unique_ids.cellml") model = parser.parseModel(model_string) annotator.setModel(model) v1v1 = (model.component("component2").variable("variable1"), model.component("component2").component("component3").variable( "variable1")) v2v2 = (model.component("component2").variable("variable2"), model.component("component2").component("component3").variable( "variable2")) self.assertEqual(model.name(), annotator.model("model_1").name()) self.assertEqual(model.name(), annotator.encapsulation("encapsulation_1").name()) self.assertEqual( model.component("component1").name(), annotator.component("component_1").name()) self.assertEqual( model.component("component2").name(), annotator.component("component_2").name()) self.assertEqual( model.component("component2").name(), annotator.component("component_ref_1").name()) self.assertEqual( model.component("component2").component("component3").name(), annotator.component("component_3").name()) self.assertEqual( model.component("component2").component("component3").name(), annotator.componentRef("component_ref_2").name()) self.assertEqual( model.component("component1").importSource().url(), annotator.importSource("import_1").url()) self.assertEqual( model.units("units1").name(), annotator.units("units_1").name()) self.assertEqual( model.units("units1").importSource().url(), annotator.importSource("import_2").url()) self.assertEqual( model.units("units2").name(), annotator.units("units_2").name()) self.assertEqual( model.units("units2").name(), annotator.unit("unit_1").units().name()) self.assertEqual(0, annotator.unit("unit_1").index()) self.assertEqual( model.component("component2").variable("variable1").name(), annotator.variable("variable_1").name()) self.assertEqual( model.component("component2").variable("variable2").name(), annotator.variable("variable_2").name()) self.assertEqual( model.component("component2").reset(0).variable().name(), annotator.reset("reset_1").variable().name()) self.assertEqual( model.component("component2").reset(0).testVariable().name(), annotator.reset("reset_1").testVariable().name()) self.assertEqual( model.component("component2").reset(0).testValue(), annotator.testValue("test_value_1").testValue()) self.assertEqual( model.component("component2").reset(0).resetValue(), annotator.resetValue("reset_value_1").resetValue()) self.assertEqual( model.component("component2").component("component3").variable( "variable1").name(), annotator.variable("variable_3").name()) self.assertEqual( model.component("component2").component("component3").variable( "variable2").name(), annotator.variable("variable_4").name()) self.assertEqual( v1v1[0].name(), annotator.connection("connection_1").variable1().name()) self.assertEqual( v1v1[1].name(), annotator.connection("connection_1").variable2().name()) self.assertEqual( v1v1[0].name(), annotator.mapVariables("map_variables_1").variable1().name()) self.assertEqual( v1v1[1].name(), annotator.mapVariables("map_variables_1").variable2().name()) self.assertEqual( v2v2[0].name(), annotator.mapVariables("map_variables_2").variable1().name()) self.assertEqual( v2v2[1].name(), annotator.mapVariables("map_variables_2").variable2().name()) self.assertIsNone(annotator.model("i_dont_exist")) self.assertIsNone(annotator.component("i_dont_exist")) self.assertIsNone(annotator.variable("i_dont_exist")) self.assertIsNone(annotator.units("i_dont_exist")) self.assertIsNone(annotator.unit("i_dont_exist")) self.assertIsNone(annotator.reset("i_dont_exist")) self.assertIsNone(annotator.resetValue("i_dont_exist")) self.assertIsNone(annotator.testValue("i_dont_exist")) self.assertIsNone(annotator.componentRef("i_dont_exist")) self.assertIsNone(annotator.connection("i_dont_exist")) self.assertIsNone(annotator.importSource("i_dont_exist"))
def test_assign_by_type(self): from libcellml import Annotator, Parser, Variable from libcellml import Unit, VariablePair annotator = Annotator() parser = Parser() model_string = file_contents("annotator/no_ids.cellml") model = parser.parseModel(model_string) annotator.setModel(model) c = model.component(0) self.assertEqual("", model.id()) annotator.assignModelId(model) self.assertEqual("b4da55", model.id()) self.assertEqual("", model.encapsulationId()) annotator.assignEncapsulationId(model) self.assertEqual("b4da56", model.encapsulationId()) self.assertEqual("", c.id()) annotator.assignComponentId(c) self.assertEqual("b4da57", c.id()) self.assertEqual("", c.encapsulationId()) annotator.assignComponentRefId(c) self.assertEqual("b4da58", c.encapsulationId()) c2v1 = model.component("component2").variable("variable1") c3v1 = model.component("component3").variable("variable1") self.assertEqual("", Variable.equivalenceConnectionId(c2v1, c3v1)) annotator.assignConnectionId(VariablePair(c2v1, c3v1)) self.assertEqual("b4da59", Variable.equivalenceConnectionId(c2v1, c3v1)) self.assertEqual("", Variable.equivalenceMappingId(c2v1, c3v1)) annotator.assignMapVariablesId(VariablePair(c2v1, c3v1)) self.assertEqual("b4da5a", Variable.equivalenceMappingId(c2v1, c3v1)) c3v2 = model.component("component3").variable("variable2") self.assertEqual("", c3v2.id()) annotator.assignVariableId(c3v2) self.assertEqual("b4da5b", c3v2.id()) u = model.units(1) self.assertEqual("", u.id()) annotator.assignUnitsId(u) self.assertEqual("b4da5c", u.id()) r = model.component("component2").reset(0) self.assertEqual("", r.id()) annotator.assignResetId(r) self.assertEqual("b4da5d", r.id()) self.assertEqual("", r.testValueId()) annotator.assignTestValueId(r) self.assertEqual("b4da5e", r.testValueId()) self.assertEqual("", r.resetValueId()) annotator.assignResetValueId(r) self.assertEqual("b4da5f", r.resetValueId()) i = model.importSource(0) self.assertEqual("", i.id()) annotator.assignImportSourceId(i) self.assertEqual("b4da60", i.id()) self.assertEqual("", u.unitId(0)) annotator.assignUnitId(Unit(u, 0)) self.assertEqual("b4da61", u.unitId(0))