def test_create_destroy(self):
from libcellml import Reset
x = Reset()
y = Reset()
z = Reset(y)
del (x, y, z)
def test_add_when(self):
from libcellml import Reset
from libcellml import When
# addWhen()
w = When()
x = Reset()
x.addWhen(w)
self.assertEqual(1, x.whenCount())
def test_get_reset(self):
from libcellml import Error, Reset
# ResetPtr getReset() const;
e = Error()
self.assertIsNone(e.getReset())
name = 'res'
r = Reset()
r.setId(name)
e.setReset(r)
self.assertIsInstance(e.getReset(), Reset)
self.assertEqual(e.getReset().getId(), name)
def test_reset(self):
from libcellml import Component, Reset
c = Component()
r = Reset()
r.setTestValue('<math></math>')
c.addReset(r)
self.assertEqual(1, c.resetCount())
self.assertTrue(c.hasReset(r))
rReturned = c.reset(0)
self.assertEqual(r.testValue(), rReturned.testValue())
def test_test_value(self):
from libcellml import Issue, Reset
# ResetPtr reset() const;
e = Issue()
self.assertIsNone(e.reset())
name = 'res'
r = Reset()
r.setId(name)
e.setTestValue(r)
self.assertIsInstance(e.testValue(), Reset)
self.assertEqual(e.testValue().id(), name)
def test_unset_order(self):
from libcellml import Reset
# removeOrder()
x = Reset()
x.setOrder(-4)
self.assertTrue(x.isOrderSet())
x.removeOrder()
self.assertFalse(x.isOrderSet())
self.assertEqual(0, x.order())
def test_remove_all_whens(self):
from libcellml import Reset
from libcellml import When
w1 = When()
w2 = When()
w3 = When()
r = Reset()
r.addWhen(w1)
r.addWhen(w2)
r.addWhen(w3)
self.assertEqual(3, r.whenCount())
r.removeAllWhens()
self.assertEqual(0, r.whenCount())
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_unset_order(self):
from libcellml import Reset
# unsetOrder()
x = Reset()
x.setOrder(-4)
self.assertTrue(x.isOrderSet())
x.unsetOrder()
self.assertFalse(x.isOrderSet())
def test_clone(self):
from libcellml import Reset
x = Reset()
self.assertEqual("", x.resetValue())
x.setResetValue("A reset MathML string.")
x.setTestValue("A test MathML string.")
rCloned = x.clone()
self.assertEqual("A reset MathML string.", rCloned.resetValue())
self.assertEqual("A test MathML string.", rCloned.testValue())
def test_replace_when(self):
from libcellml import Reset
from libcellml import When
w1 = When()
w1.setCondition("x=exp(y)")
w2 = When()
w2.setValue("a=2")
r = Reset()
r.addWhen(w1)
self.assertFalse(r.replaceWhen(3, w2))
self.assertEqual("x=exp(y)", r.getWhen(0).getCondition())
self.assertEqual("", r.getWhen(0).getValue())
self.assertTrue(r.replaceWhen(0, w2))
self.assertEqual("", r.getWhen(0).getCondition())
self.assertEqual("a=2", r.getWhen(0).getValue())
def test_reset_manipulations(self):
from libcellml import Component, Reset
c = Component()
r1 = Reset()
r1.setResetValue('<math></math>')
r2 = Reset()
c.addReset(r1)
c.addReset(r2)
self.assertEqual(2, c.resetCount())
c.removeAllResets()
self.assertEqual(0, c.resetCount())
c.addReset(r1)
c.addReset(r2)
self.assertTrue(c.removeReset(r2))
self.assertEqual(1, c.resetCount())
rTaken = c.takeReset(0)
self.assertEqual(0, c.resetCount())
self.assertEqual(r1.resetValue(), rTaken.resetValue())
def test_is_order_set(self):
from libcellml import Reset
# bool isOrderSet()
x = Reset()
self.assertFalse(x.isOrderSet())
x.setOrder(2)
self.assertTrue(x.isOrderSet())
def test_get_when(self):
from libcellml import Reset
from libcellml import When
w = When()
r = Reset()
r.addWhen(w)
self.assertEqual(None, r.getWhen(2))
self.assertEqual(None, r.getWhen(-4))
self.assertNotEqual(None, r.getWhen(0))
def test_take_when(self):
from libcellml import Reset
from libcellml import When
w = When()
r = Reset()
r.addWhen(w)
self.assertEqual(1, r.whenCount())
self.assertEqual(None, r.takeWhen(2))
w_returned = r.takeWhen(0)
self.assertNotEqual(None, w_returned)
self.assertEqual(0, r.whenCount())
def test_set_get_reset_value(self):
from libcellml import Reset
x = Reset()
self.assertEqual("", x.resetValue())
x.setResetValue("A value MathML string.")
self.assertEqual("A value MathML string.", x.resetValue())
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 Unit
from libcellml import Units
from libcellml import Variable
from libcellml import VariablePair
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
v1 = Variable("v1")
v2 = Variable("v2")
vp = VariablePair(v1, v2)
e8 = Issue(vp)
del e8
ui = Unit(u, 0)
e9 = Issue(ui)
del e9
def test_contains_when(self):
from libcellml import Reset
from libcellml import When
w1 = When()
w2 = When()
r = Reset()
r.addWhen(w1)
self.assertTrue(r.containsWhen(w1))
self.assertFalse(r.containsWhen(w2))
def test_set_get_test_variable(self):
from libcellml import Reset
from libcellml import Variable
r = Reset()
v = Variable()
v.setName("glucose")
self.assertEqual(None, r.testVariable())
r.setTestVariable(v)
self.assertEqual("glucose", r.testVariable().name())
def test_create_destroy(self):
from libcellml import Reset
x = Reset()
del (x)
def test_set_reset(self):
from libcellml import Error, Reset
# void setReset(const ResetPtr &reset);
e = Error()
e.setReset(Reset())
def test_reset_value(self):
from libcellml import Reset
x = Reset()
self.assertEqual("", x.resetValue())
x.setResetValue("A reset MathML string.")
self.assertEqual("A reset MathML string.", x.resetValue())
x.appendResetValue(" More MathML.")
self.assertEqual("A reset MathML string. More MathML.", x.resetValue())
self.assertEqual("", x.resetValueId())
x.setResetValueId("my_reset_value")
self.assertEqual("my_reset_value", x.resetValueId())
x.removeResetValue()
self.assertEqual("", x.resetValue())
x.removeResetValueId()
self.assertEqual("", x.resetValueId())
def test_set_order(self):
from libcellml import Reset
x = Reset()
x.setOrder(3)
self.assertEqual(3, x.order())
def test_print_reset(self):
from libcellml import Printer, Reset
# std::string printReset(ResetPtr reset) const;
p = Printer()
self.assertIsInstance(p.printReset(Reset()), str)
def test_item(self):
from libcellml import Component, Issue, ImportSource, Model, Unit
from libcellml import Reset, Units, Variable, CellmlElementType, VariablePair
i = Issue()
item = i.item()
self.assertEqual(CellmlElementType.UNDEFINED, item[0])
self.assertIsNone(item[1])
i.setItem(CellmlElementType.VARIABLE, Variable("v"))
vItem = i.item()
self.assertEqual(CellmlElementType.VARIABLE, vItem[0])
self.assertEqual("v", vItem[1].name())
i.setItem(CellmlElementType.UNITS, Units("u"))
uItem = i.item()
self.assertEqual(CellmlElementType.UNITS, uItem[0])
self.assertEqual("u", uItem[1].name())
u = Units("ui")
u.addUnit("volt")
u.addUnit("second")
u.addUnit("metre")
i.setItem(CellmlElementType.UNIT, Unit(u, 2))
uiItem = i.item()
self.assertEqual(CellmlElementType.UNIT, uiItem[0])
self.assertEqual("ui", uiItem[1].units().name())
self.assertEqual(2, uiItem[1].index())
v1 = Variable("v1")
v2 = Variable("v2")
i.setItem(CellmlElementType.CONNECTION, VariablePair(v1, v2))
vpItem = i.item()
self.assertEqual(CellmlElementType.CONNECTION, vpItem[0])
self.assertEqual("v1", vpItem[1].variable1().name())
self.assertEqual("v2", vpItem[1].variable2().name())
v3 = Variable("v3")
v4 = Variable("v4")
i.setItem(CellmlElementType.MAP_VARIABLES, VariablePair(v3, v4))
vpItem = i.item()
self.assertEqual(CellmlElementType.MAP_VARIABLES, vpItem[0])
self.assertEqual("v3", vpItem[1].variable1().name())
self.assertEqual("v4", vpItem[1].variable2().name())
r = Reset()
r.setId("r")
i.setItem(CellmlElementType.RESET, r)
rItem = i.item()
self.assertEqual(CellmlElementType.RESET, rItem[0])
self.assertEqual("r", rItem[1].id())
r.setId("r1")
i.setItem(CellmlElementType.RESET_VALUE, r)
rItem = i.item()
self.assertEqual(CellmlElementType.RESET_VALUE, rItem[0])
self.assertEqual("r1", rItem[1].id())
r.setId("r2")
i.setItem(CellmlElementType.TEST_VALUE, r)
rItem = i.item()
self.assertEqual(CellmlElementType.TEST_VALUE, rItem[0])
self.assertEqual("r2", rItem[1].id())
i.setItem(CellmlElementType.MODEL, Model("m"))
mItem = i.item()
self.assertEqual(CellmlElementType.MODEL, mItem[0])
self.assertEqual("m", mItem[1].name())
i.setItem(CellmlElementType.ENCAPSULATION, Model("e"))
mItem = i.item()
self.assertEqual(CellmlElementType.ENCAPSULATION, mItem[0])
self.assertEqual("e", mItem[1].name())
iS = ImportSource()
iS.setId("is")
i.setItem(CellmlElementType.IMPORT, iS)
isItem = i.item()
self.assertEqual(CellmlElementType.IMPORT, isItem[0])
self.assertEqual("is", isItem[1].id())
i.setItem(CellmlElementType.COMPONENT, Component("c"))
cItem = i.item()
self.assertEqual(CellmlElementType.COMPONENT, cItem[0])
self.assertEqual("c", cItem[1].name())
i.setItem(CellmlElementType.COMPONENT_REF, Component("c1"))
cItem = i.item()
self.assertEqual(CellmlElementType.COMPONENT_REF, cItem[0])
self.assertEqual("c1", cItem[1].name())
def test_remove_when(self):
from libcellml import Reset
from libcellml import When
w = When()
r = Reset()
r.addWhen(w)
self.assertEqual(1, r.whenCount())
self.assertTrue(r.removeWhen(0))
self.assertEqual(0, r.whenCount())
r.addWhen(w)
self.assertTrue(r.removeWhen(w))
self.assertEqual(0, r.whenCount())
def test_set_reset(self):
from libcellml import Issue, Reset
# void setReset(const ResetPtr &reset);
e = Issue()
e.setReset(Reset())
