def test_units(self):
from libcellml import Model, Units
# UnitsPtr units(size_t index)
name = 'naaame'
m = Model()
u = Units()
u.setName(name)
self.assertIsNone(m.units(0))
self.assertIsNone(m.units(1))
self.assertIsNone(m.units(-1))
m.addUnits(u)
self.assertIsNone(m.units(1))
self.assertIsNone(m.units(-1))
self.assertIsNotNone(m.units(0))
self.assertEqual(m.units(0).name(), name)
del [m, u, name]
# UnitsPtr units(const std::string &name)
name = 'kermit'
m = Model()
u = Units()
u.setName(name)
self.assertIsNone(m.units(name))
m.addUnits(u)
self.assertIsNotNone(m.units(name))
self.assertEqual(m.units(name).name(), name)
del [m, u, name]
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_take_units(self):
from libcellml import Model, Units
# UnitsPtr takeUnits(size_t index)
name = 'piggy'
m = Model()
u = Units()
u.setName(name)
self.assertIsNone(m.takeUnits(0))
self.assertIsNone(m.takeUnits(-1))
self.assertIsNone(m.takeUnits(1))
m.addUnits(u)
self.assertIsNone(m.takeUnits(-1))
self.assertIsNone(m.takeUnits(1))
self.assertIsNotNone(m.takeUnits(0))
self.assertIsNone(m.takeUnits(0))
m.addUnits(Units())
m.addUnits(u)
self.assertEqual(m.takeUnits(1).name(), name)
del [m, u]
# UnitsPtr takeUnits(const std::string &name)
name = 'aloha'
m = Model()
u = Units()
u.setName(name)
self.assertIsNone(m.takeUnits(name))
m.addUnits(u)
self.assertEqual(m.takeUnits(name).name(), name)
self.assertIsNone(m.takeUnits(name))
del [m, u, name]
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_create_destroy(self):
from libcellml import Model
x = Model()
del(x)
y = Model()
z = Model(y)
del(y, z)
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_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_clean(self):
from libcellml import Component, Model, Units, Variable, Printer
model = Model()
c1 = Component('c1')
c2 = Component()
c2.setId('c2')
c3 = Component()
c4 = Component()
u1 = Units('used')
u2 = Units()
u2.setId('u2')
u3 = Units()
v = Variable('x')
model.addComponent(c1)
model.addComponent(c2)
model.addComponent(c3)
model.addComponent(c4)
model.addUnits(u1)
model.addUnits(u2)
model.addUnits(u3)
c3.addVariable(v)
self.assertEqual(4, model.componentCount())
self.assertEqual(3, model.unitsCount())
# Call the Model.clean() function to remove the empty items (c4 and u3).
model.clean()
self.assertEqual(3, model.componentCount())
self.assertEqual(2, model.unitsCount())
def test_add_units(self):
from libcellml import Model, Units
# void addUnits(const UnitsPtr &units)
m = Model()
u = Units()
m.addUnits(u)
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_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_imports(self):
from libcellml import Model, ImportSource, Units
m = Model()
u = Units()
u.setImportSource(ImportSource())
m.addUnits(u)
self.assertTrue(m.hasImports())
self.assertEqual(1, m.importSourceCount())
i = ImportSource()
i.setUrl('actual_url')
m.addImportSource(i)
self.assertEqual(2, m.importSourceCount())
i1 = m.importSource(0)
self.assertTrue(m.hasImportSource(i))
m.removeImportSource(0)
self.assertEqual(1, m.importSourceCount())
m.removeAllImportSources()
self.assertEqual(0, m.importSourceCount())
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_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_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_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_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_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_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_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_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)
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_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_replace_units(self):
from libcellml import Model, Units
# bool replaceUnits(size_t index, const UnitsPtr &units)
m = Model()
u1 = Units()
u1.setName('a')
m.addUnits(u1)
u2 = Units()
u2.setName('b')
self.assertTrue(m.replaceUnits(0, u2))
self.assertFalse(m.replaceUnits(1, u1))
self.assertFalse(m.replaceUnits(-1, u1))
self.assertEqual(m.getUnits(0).getName(), 'b')
del(m, u1, u2)
# bool replaceUnits(const std::string &name, const UnitsPtr &units)
m = Model()
a = Units()
a.setName('a')
m.addUnits(a)
b = Units()
b.setName('b')
self.assertFalse(m.replaceUnits('b', a))
self.assertTrue(m.replaceUnits('a', b))
self.assertTrue(m.replaceUnits('b', a))
self.assertFalse(m.replaceUnits('b', a))
del(m, a, b)
# bool replaceUnits(const UnitsPtr &oldUnits, const UnitsPtr &newUnits)
m = Model()
a = Units()
m.addUnits(a)
b = Units()
self.assertFalse(m.replaceUnits(b, a))
self.assertTrue(m.replaceUnits(a, b))
self.assertTrue(m.replaceUnits(b, a))
self.assertFalse(m.replaceUnits(b, a))
del(m, a, b)
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_units_count(self):
from libcellml import Model, Units
# size_t unitsCount()
m = Model()
self.assertEqual(m.unitsCount(), 0)
m.addUnits(Units())
self.assertEqual(m.unitsCount(), 1)
m.addUnits(Units())
self.assertEqual(m.unitsCount(), 2)
m.removeAllUnits()
self.assertEqual(m.unitsCount(), 0)
del m
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())
