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())
