def test_add_units(self): from libcellml import Model, Units # void addUnits(const UnitsPtr &units) m = Model() u = Units() m.addUnits(u)
def test_create_destroy(self): from libcellml import Model x = Model() del(x) y = Model() z = Model(y) del(y, z)
def test_model(self): from libcellml import ImportSource, Model model = Model() model.setName('bert') x = ImportSource() self.assertIsNone(x.model()) x.setModel(model) self.assertEqual(x.model().name(), model.name()) x.setModel(None) self.assertIsNone(x.model())
def test_encapsulation(self): from libcellml import Issue, Model e = Issue() self.assertIsNone(e.model()) name = 'moodle' m = Model() m.setName(name) e.setEncapsulation(m) self.assertIsInstance(e.encapsulation(), Model) self.assertEqual(e.encapsulation().name(), name)
def test_ids(self): from libcellml import Model m = Model() self.assertEqual('', m.id()) self.assertEqual('', m.encapsulationId()) m.setId('main_model') m.setEncapsulationId('model_encapsulation') self.assertEqual('main_model', m.id()) self.assertEqual('model_encapsulation', m.encapsulationId())
def test_parent(self): from libcellml import Model, Component x = Model("model") self.assertIsNone(x.parent()) c = Component() self.assertIsNone(c.parent()) c.setParent(x) self.assertEqual("model", c.parent().name()) self.assertEqual(0, x.componentCount())
def test_get_model(self): from libcellml import Error, Model # ModelPtr getModel() e = Error() self.assertIsNone(e.getModel()) name = 'moodle' m = Model() m.setName(name) e.setModel(m) self.assertIsInstance(e.getModel(), Model) self.assertEqual(e.getModel().getName(), name)
def test_create_destroy(self): import libcellml from libcellml import Model x = Model() del x y = Model('bob') self.assertEqual('bob', y.name()) z = libcellml.Model() del z
def test_model(self): from libcellml import Issue, Model # ModelPtr model() e = Issue() self.assertIsNone(e.model()) name = 'moodle' m = Model() m.setName(name) e.setModel(m) self.assertIsInstance(e.model(), Model) self.assertEqual(e.model().name(), name)
def test_get_model(self): from libcellml import ImportSource, Model # libcellml::ModelPtr getModel() const; model = Model() model.setName('bert') x = ImportSource() self.assertIsNone(x.getModel()) x.setModel(model) self.assertEqual(x.getModel().getName(), model.getName()) x.setModel(None) self.assertIsNone(x.getModel())
def test_create_destroy(self): from libcellml import Component from libcellml import Issue from libcellml import ImportSource from libcellml import Model from libcellml import Reset from libcellml import Units from libcellml import Variable e1 = Issue() del (e1) c = Component() e2 = Issue(c) del (e2) i = ImportSource() e3 = Issue(i) del (e3) m = Model() e4 = Issue(m) del (e4) r = Reset() e5 = Issue(r) del (e5) u = Units() e6 = Issue(u) del (e6) v = Variable() e7 = Issue(v) del (e7)
def test_create_destroy(self): from libcellml import AnalyserExternalVariable from libcellml import Component from libcellml import Model from libcellml import Variable m = Model('model') c = Component('component') v = Variable('test') self.assertTrue(m.addComponent(c)) self.assertTrue(c.addVariable(v)) aev = AnalyserExternalVariable(v) self.assertEqual(v.name(), aev.variable().name()) d0 = Variable('d0') d1 = Variable('d1') d2 = Variable('d2') d3 = Variable('d3') c.addVariable(d0) c.addVariable(d1) c.addVariable(d2) c.addVariable(d3) self.assertTrue(aev.addDependency(d0)) self.assertTrue(aev.addDependency(d1)) self.assertTrue(aev.addDependency(d2)) self.assertTrue(aev.addDependency(d3)) self.assertEqual(4, aev.dependencyCount()) self.assertIsNotNone(aev.dependency(0)) self.assertIsNotNone(aev.dependency(m, c.name(), d1.name())) self.assertIsNotNone(aev.dependencies()) self.assertTrue(aev.containsDependency(d0)) self.assertTrue(aev.containsDependency(m, c.name(), d1.name())) self.assertTrue(aev.removeDependency(1)) self.assertTrue(aev.removeDependency(d0)) self.assertTrue(aev.removeDependency(m, c.name(), d2.name())) aev.removeAllDependencies()
def test_set_model(self): from libcellml import ImportSource, Model # void setModel(const ModelPtr &model); x = ImportSource() x.setModel(None) x.setModel(Model()) x.setModel(None)
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_id(self): from libcellml import Model # std::string id() x = Model() self.assertEqual(x.id(), '') # void setId(const std::string &id) idx = 'test' x.setId(idx) self.assertEqual(x.id(), idx) x.removeId() self.assertEqual(x.id(), '')
def test_remove_parent(self): from libcellml import Model, Component m = Model() c = Component() c.setParent(m) self.assertIsNotNone(c.parent()) c.removeParent() self.assertIsNone(c.parent())
def test_has_model(self): from libcellml import ImportSource, Model x = ImportSource() model = Model() self.assertFalse(x.hasModel()) x.setModel(model) self.assertTrue(x.hasModel()) x.removeModel() self.assertFalse(x.hasModel())
def test_has_model(self): from libcellml import ImportSource, Model # bool hasModel() const; x = ImportSource() self.assertFalse(x.hasModel()) x.setModel(Model()) self.assertTrue(x.hasModel()) x.setModel(None) self.assertFalse(x.hasModel())
def test_add_component(self): from libcellml import Model, Component m = Model() c = Component() self.assertEqual(0, m.componentCount()) m.addComponent(c) self.assertTrue(m.containsComponent(c)) self.assertEqual(1, m.componentCount())
def test_auto_ids_group(self): from libcellml import Annotator, Component, Model from libcellml.enums import CellmlElementType_COMPONENT annotator = Annotator() model = Model() component1 = Component("c1") component2 = Component("c2") component3 = Component("c3") model.addComponent(component1) model.addComponent(component2) component2.addComponent(component3) annotator.setModel(model) self.assertEqual("", model.id()) self.assertEqual("", component1.id()) self.assertEqual("", component2.id()) self.assertEqual("", component3.id()) annotator.assignIds(CellmlElementType_COMPONENT) self.assertEqual("", model.id()) self.assertEqual("b4da55", component1.id()) self.assertEqual("b4da56", component2.id()) self.assertEqual("b4da57", component3.id())
def test_set_parent(self): from libcellml import Entity, Model, Component m = Model() x = Entity() x.setParent(m) self.assertIsNotNone(x.parent()) # TODO: Check equivalence c = Component() x = Entity() x.setParent(c) self.assertIsNotNone(x.parent())
def test_has_unresolved_imports(self): from libcellml import Model, Component, ImportSource # bool hasUnresolvedImports(); m = Model() self.assertFalse(m.hasUnresolvedImports()) c = Component() m.addComponent(c) self.assertFalse(m.hasUnresolvedImports()) c.setImportSource(ImportSource()) self.assertTrue(m.hasUnresolvedImports())
def test_inheritance(self): import libcellml from libcellml import Model x = Model() self.assertIsInstance(x, libcellml.componententity.ComponentEntity) self.assertIsInstance(x, libcellml.namedentity.NamedEntity) self.assertIsInstance(x, libcellml.entity.Entity) # Test access to inherited methods x = Model() idx = 'test' self.assertEqual(x.id(), '') x.setId(idx) self.assertEqual(x.id(), idx)
def test_has_units(self): from libcellml import Model, Units # bool hasUnits(const std::string &name) name = 'loud' m = Model() u = Units() u.setName(name) m.addUnits(u) self.assertFalse(m.hasUnits('hi')) self.assertTrue(m.hasUnits(name)) # bool hasUnits(const UnitsPtr &units) self.assertTrue(m.hasUnits(u)) v = Units() self.assertFalse(m.hasUnits(v))
def test_clear_parent(self): from libcellml import Entity, Model, Component # void clearParent() x = Entity() self.assertIsNone(x.getParent()) x.setParent(Model()) self.assertIsNotNone(x.getParent()) x.clearParent() self.assertIsNone(x.getParent()) x.setParent(Component()) self.assertIsNotNone(x.getParent()) x.clearParent() self.assertIsNone(x.getParent())
def test_remove_all_units(self): from libcellml import Model, Units # void removeAllUnits() m = Model() u1 = Units() u2 = Units() m.addUnits(u1) m.addUnits(u2) m.removeAllUnits() self.assertFalse(m.removeUnits(u1)) self.assertFalse(m.removeUnits(u2)) del [m, u1, u2]
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_imports(self): from libcellml import Model, Importer, ImportSource, Units m = Model() u = Units() im = Importer() u.setImportSource(ImportSource()) m.addUnits(u) self.assertTrue(m.hasImports()) self.assertEqual(0, im.importSourceCount()) i = ImportSource() i.setUrl('actual_url') im.addImportSource(i) self.assertEqual(1, im.importSourceCount()) i1 = im.importSource(0) self.assertTrue(im.hasImportSource(i)) im.removeImportSource(0) i2 = ImportSource() self.assertEqual(0, im.importSourceCount()) im.addImportSource(i2) self.assertEqual(1, im.importSourceCount()) im.removeAllImportSources() self.assertEqual(0, im.importSourceCount())
def test_analyse_model(self): from libcellml import Analyser from libcellml import AnalyserModel from libcellml import Model # Analyse an empty model and make sure that we get no errors and an # UNKNOWN type for the analyser model. m = Model('my_model') a = Analyser() a.analyseModel(m) self.assertEqual(0, a.errorCount()) self.assertEqual(AnalyserModel.Type.UNKNOWN, a.model().type())