def test_ASTNode_prependChild1(self):
node = libsbml.ASTNode()
c1 = libsbml.ASTNode()
c2 = libsbml.ASTNode()
c1_1 = libsbml.ASTNode()
i = 0
node.setType(libsbml.AST_LOGICAL_AND)
c1.setName("a")
c2.setName("b")
node.addChild(c1)
node.addChild(c2)
self.assert_(node.getNumChildren() == 2)
self.assert_(("and(a, b)" == libsbml.formulaToString(node)))
c1_1.setName("d")
i = node.prependChild(c1_1)
self.assert_(i == libsbml.LIBSBML_OPERATION_SUCCESS)
self.assert_(node.getNumChildren() == 3)
self.assert_(("and(d, a, b)" == libsbml.formulaToString(node)))
self.assert_(("d" == node.getChild(0).getName()))
self.assert_(("a" == node.getChild(1).getName()))
self.assert_(("b" == node.getChild(2).getName()))
_dummyList = [node]
_dummyList[:] = []
del _dummyList
pass
def __convertFormulaToExpression( self, anASTNode ):
numChildren = anASTNode.getNumChildren()
if numChildren == 2:
self.__convertFormulaToExpression( anASTNode.getLeftChild() )
self.__convertFormulaToExpression( anASTNode.getRightChild() )
return anASTNode
elif numChildren == 1:
self.__convertFormulaToExpression( anASTNode.getLeftChild() )
return anASTNode
elif numChildren == 0:
if anASTNode.isNumber():
return anASTNode
else:
name = anASTNode.getName()
( fullIDString, sbaseType ) \
= self.rootobj.theSBMLIdManager.searchFullIDFromId( name )
if sbaseType == libsbml.SBML_SPECIES:
variableName = self.__addVariableReference( fullIDString )
fullID = ecell.ecssupport.createFullID( fullIDString )
sizeName = self.__addVariableReference( 'Variable:%s:SIZE' % ( fullID[ 1 ] ) )
anASTNode.setType( libsbml.AST_DIVIDE )
anASTNode.addChild( libsbml.ASTNode( libsbml.AST_NAME ) )
anASTNode.addChild( libsbml.ASTNode( libsbml.AST_NAME ) )
anASTNode.getLeftChild().setName( '%s.Value' % ( variableName ) )
anASTNode.getRightChild().setName( '%s.Value' % ( sizeName ) )
return anASTNode
elif sbaseType == libsbml.SBML_PARAMETER:
variableName = self.__addVariableReference( fullIDString )
anASTNode.setName( '%s.Value' % ( variableName ) )
return anASTNode
elif sbaseType == libsbml.SBML_COMPARTMENT:
fullID = ecell.ecssupport.createFullID( fullIDString )
systemPath = ecell.ecssupport.createSystemPathFromFullID( fullID )
fullIDString = 'Variable:%s:SIZE' % ( systemPath )
variableName = self.__addVariableReference( fullIDString )
anASTNode.setName( '%s.Value' % ( variableName ) )
return anASTNode
elif self.theParameterDict.has_key( name ):
return anASTNode
else:
raise SBMLConvertError, 'Reaction [%s] has no parameter [%s]' % ( self.theSBase.getId(), name )
def test_ASTNode_replaceChild(self):
node = libsbml.ASTNode()
c1 = libsbml.ASTNode()
c2 = libsbml.ASTNode()
c3 = libsbml.ASTNode()
newc = libsbml.ASTNode()
i = 0
node.setType(libsbml.AST_LOGICAL_AND)
c1.setName("a")
c2.setName("b")
c3.setName("c")
node.addChild(c1)
node.addChild(c2)
node.addChild(c3)
self.assert_(node.getNumChildren() == 3)
self.assert_(("and(a, b, c)" == libsbml.formulaToString(node)))
newc.setName("d")
i = node.replaceChild(0, newc)
self.assert_(i == libsbml.LIBSBML_OPERATION_SUCCESS)
self.assert_(node.getNumChildren() == 3)
self.assert_(("and(d, b, c)" == libsbml.formulaToString(node)))
i = node.replaceChild(3, newc)
self.assert_(i == libsbml.LIBSBML_INDEX_EXCEEDS_SIZE)
self.assert_(node.getNumChildren() == 3)
self.assert_(("and(d, b, c)" == libsbml.formulaToString(node)))
i = node.replaceChild(1, c1)
self.assert_(i == libsbml.LIBSBML_OPERATION_SUCCESS)
self.assert_(node.getNumChildren() == 3)
self.assert_(("and(d, a, c)" == libsbml.formulaToString(node)))
_dummyList = [node]
_dummyList[:] = []
del _dummyList
pass
def test_ASTNode_children(self):
parent = libsbml.ASTNode()
left = libsbml.ASTNode()
right = libsbml.ASTNode()
right2 = libsbml.ASTNode()
parent.setType(libsbml.AST_PLUS)
left.setValue(1)
right.setValue(2)
right2.setValue(3)
parent.addChild(left)
parent.addChild(right)
self.assert_(parent.getNumChildren() == 2)
self.assert_(left.getNumChildren() == 0)
self.assert_(right.getNumChildren() == 0)
self.assert_(parent.getLeftChild() == left)
self.assert_(parent.getRightChild() == right)
self.assert_(parent.getChild(0) == left)
self.assert_(parent.getChild(1) == right)
self.assert_(parent.getChild(2) == None)
parent.addChild(right2)
self.assert_(parent.getNumChildren() == 3)
self.assert_(left.getNumChildren() == 0)
self.assert_(right.getNumChildren() == 0)
self.assert_(right2.getNumChildren() == 0)
self.assert_(parent.getLeftChild() == left)
self.assert_(parent.getRightChild() == right2)
self.assert_(parent.getChild(0) == left)
self.assert_(parent.getChild(1) == right)
self.assert_(parent.getChild(2) == right2)
self.assert_(parent.getChild(3) == None)
_dummyList = [parent]
_dummyList[:] = []
del _dummyList
pass
def test_ASTNode_isUMinus(self):
n = libsbml.ASTNode()
n.setType(libsbml.AST_MINUS)
self.assert_(n.isUMinus() == False)
n.addChild(libsbml.ASTNode(libsbml.AST_NAME))
self.assert_(n.isUMinus() == True)
_dummyList = [n]
_dummyList[:] = []
del _dummyList
pass
def test_KineticLaw_setMath2(self): math = libsbml.ASTNode(libsbml.AST_DIVIDE) a = libsbml.ASTNode() a.setName( "a") math.addChild(a) i = self.kl.setMath(math) self.assert_( i == libsbml.LIBSBML_INVALID_OBJECT ) self.assertEqual( False, self.kl.isSetMath() ) _dummyList = [ math ]; _dummyList[:] = []; del _dummyList pass
def test_SpeciesReference_setStoichiometryMath2(self): sm = libsbml.StoichiometryMath(2,4) math = libsbml.ASTNode(libsbml.AST_TIMES) a = libsbml.ASTNode() a.setName( "a") math.addChild(a) sm.setMath(math) i = self.sr.setStoichiometryMath(sm) self.assert_( i == libsbml.LIBSBML_OPERATION_SUCCESS ) self.assertEqual( True, self.sr.isSetStoichiometryMath() ) _dummyList = [ sm ]; _dummyList[:] = []; del _dummyList pass
def __convertVariableName(self, anASTNode):
aNumChildren = anASTNode.getNumChildren()
if (aNumChildren == 2):
self.__convertVariableName(anASTNode.getLeftChild())
self.__convertVariableName(anASTNode.getRightChild())
elif (aNumChildren == 1):
self.__convertVariableName(anASTNode.getLeftChild())
elif (aNumChildren == 0):
if (anASTNode.isNumber() == 1):
pass
else:
aName = anASTNode.getName()
aType = self.getVariableType(aName)
# Species
if (aType == libsbml.SBML_SPECIES):
(variableName, compartmentName
) = self.setSpeciesToVariableReference(aName)
if (variableName != ''):
anASTNode.setType(libsbml.AST_DIVIDE)
anASTNode.addChild(libsbml.ASTNode(libsbml.AST_NAME))
anASTNode.addChild(libsbml.ASTNode(libsbml.AST_NAME))
anASTNode.getLeftChild().setName('%s.Value' %
(variableName))
anASTNode.getRightChild().setName('%s.Value' %
(compartmentName))
return anASTNode
# Parameter
elif (aType == libsbml.SBML_PARAMETER):
variableName = self.setParameterToVariableReference(aName)
if (variableName != ''):
anASTNode.setName('%s.Value' % (variableName))
return anASTNode
# Compartment
elif (aType == libsbml.SBML_COMPARTMENT):
variableName = self.setCompartmentToVariableReference(
aName)
if (variableName != ''):
anASTNode.setName('%s.Value' % (variableName))
return anASTNode
return anASTNode
def test_ASTNode_one_child(self):
node = libsbml.ASTNode()
child = libsbml.ASTNode()
node.addChild(child)
self.assert_(node.getNumChildren() == 1)
self.assert_(node.getLeftChild() == child)
self.assert_(node.getRightChild() == None)
self.assert_(node.getChild(0) == child)
self.assert_(node.getChild(1) == None)
_dummyList = [node]
_dummyList[:] = []
del _dummyList
pass
def test_ASTNode_canonicalizeConstants(self):
n = libsbml.ASTNode()
n.setName("ExponentialE")
self.assertEqual(True, n.isName())
n.canonicalize()
self.assert_(n.getType() == libsbml.AST_CONSTANT_E)
n.setType(libsbml.AST_NAME)
n.setName("False")
self.assertEqual(True, n.isName())
n.canonicalize()
self.assert_(n.getType() == libsbml.AST_CONSTANT_FALSE)
n.setType(libsbml.AST_NAME)
n.setName("Pi")
self.assertEqual(True, n.isName())
n.canonicalize()
self.assert_(n.getType() == libsbml.AST_CONSTANT_PI)
n.setType(libsbml.AST_NAME)
n.setName("True")
self.assertEqual(True, n.isName())
n.canonicalize()
self.assert_(n.getType() == libsbml.AST_CONSTANT_TRUE)
n.setType(libsbml.AST_NAME)
n.setName("Foo")
self.assertEqual(True, n.isName())
n.canonicalize()
self.assertEqual(True, n.isName())
_dummyList = [n]
_dummyList[:] = []
del _dummyList
pass
def test_MathMLFormatter_cn_rational(self):
expected = wrapMathML(" <cn type=\"rational\"> 1 <sep/> 3 </cn>\n")
self.N = libsbml.ASTNode()
self.N.setValue(1, 3)
self.S = libsbml.writeMathMLToString(self.N)
self.assertEqual(True, self.equals(expected, self.S))
pass
def test_ASTNode_setType(self):
node = libsbml.ASTNode()
node.setName("foo")
self.assert_(node.getType() == libsbml.AST_NAME)
node.setType(libsbml.AST_FUNCTION)
self.assert_(node.getType() == libsbml.AST_FUNCTION)
self.assert_(("foo" == node.getName()))
node.setType(libsbml.AST_NAME)
self.assert_(node.getType() == libsbml.AST_NAME)
self.assert_(("foo" == node.getName()))
node.setType(libsbml.AST_INTEGER)
self.assert_(node.getType() == libsbml.AST_INTEGER)
node.setType(libsbml.AST_REAL)
self.assert_(node.getType() == libsbml.AST_REAL)
node.setType(libsbml.AST_UNKNOWN)
self.assert_(node.getType() == libsbml.AST_UNKNOWN)
node.setType(libsbml.AST_PLUS)
self.assert_(node.getType() == libsbml.AST_PLUS)
self.assert_(node.getCharacter() == '+')
node.setType(libsbml.AST_MINUS)
self.assert_(node.getType() == libsbml.AST_MINUS)
self.assert_(node.getCharacter() == '-')
node.setType(libsbml.AST_TIMES)
self.assert_(node.getType() == libsbml.AST_TIMES)
self.assert_(node.getCharacter() == '*')
node.setType(libsbml.AST_DIVIDE)
self.assert_(node.getType() == libsbml.AST_DIVIDE)
self.assert_(node.getCharacter() == '/')
node.setType(libsbml.AST_POWER)
self.assert_(node.getType() == libsbml.AST_POWER)
self.assert_(node.getCharacter() == '^')
_dummyList = [node]
_dummyList[:] = []
del _dummyList
pass
def test_ASTNode_setReal(self):
node = libsbml.ASTNode()
node.setName("foo")
self.assert_(node.getType() == libsbml.AST_NAME)
node.setValue(32.1)
self.assert_(node.getType() == libsbml.AST_REAL)
self.assert_(node.getInteger() == 0)
self.assert_(node.getName() == None)
self.assert_(node.getCharacter() == "\0")
self.assert_(node.getReal() == 32.1)
self.assert_(node.getExponent() == 0)
self.assert_(node.getDenominator() == 1)
self.assert_(node.getMantissa() == 32.1)
node.setValue(45, 90)
self.assert_(node.getType() == libsbml.AST_RATIONAL)
self.assert_(node.getInteger() == 45)
self.assert_(node.getName() == None)
self.assert_(node.getCharacter() == "\0")
self.assert_(node.getReal() == 0.5)
self.assert_(node.getExponent() == 0)
self.assert_(node.getDenominator() == 90)
self.assert_(node.getMantissa() == 0)
node.setValue(32.0, 4)
self.assert_(node.getType() == libsbml.AST_REAL_E)
self.assert_(node.getInteger() == 0)
self.assert_(node.getName() == None)
self.assert_(node.getCharacter() == "\0")
self.assert_(node.getReal() == 320000)
self.assert_(node.getExponent() == 4)
self.assert_(node.getDenominator() == 1)
self.assert_(node.getMantissa() == 32)
_dummyList = [node]
_dummyList[:] = []
del _dummyList
pass
def test_ASTNode_setInteger(self):
node = libsbml.ASTNode()
node.setName("foo")
self.assert_(node.getType() == libsbml.AST_NAME)
self.assert_(("foo" == node.getName()))
self.assert_(node.getCharacter() == "\0")
self.assert_(node.getInteger() == 0)
self.assert_(node.getReal() == 0)
self.assert_(node.getExponent() == 0)
self.assert_(node.getDenominator() == 1)
node.setValue(3.2)
self.assert_(node.getType() == libsbml.AST_REAL)
self.assert_(node.getInteger() == 0)
self.assert_(node.getName() == None)
self.assert_(node.getCharacter() == "\0")
self.assert_(node.getReal() == 3.2)
self.assert_(node.getExponent() == 0)
self.assert_(node.getDenominator() == 1)
node.setValue(321)
self.assert_(node.getType() == libsbml.AST_INTEGER)
self.assert_(node.getInteger() == 321)
self.assert_(node.getName() == None)
self.assert_(node.getCharacter() == "\0")
self.assert_(node.getReal() == 0)
self.assert_(node.getExponent() == 0)
self.assert_(node.getDenominator() == 1)
_dummyList = [node]
_dummyList[:] = []
del _dummyList
pass
def test_Constraint_copyConstructor(self):
o1 = libsbml.Constraint(2,4)
o1.setMetaId("c")
self.assert_( o1.getMetaId() == "c" )
text = libsbml.XMLNode.convertStringToXMLNode(" Some text ")
triple = libsbml.XMLTriple("p", "http://www.w3.org/1999/xhtml", "")
att = libsbml.XMLAttributes()
xmlns = libsbml.XMLNamespaces()
xmlns.add("http://www.w3.org/1999/xhtml")
p = libsbml.XMLNode(triple,att,xmlns)
p.addChild(text)
triple1 = libsbml.XMLTriple("message", "", "")
att1 = libsbml.XMLAttributes()
message = libsbml.XMLNode(triple1,att1)
message.addChild(p)
math = libsbml.ASTNode(libsbml.AST_CONSTANT_PI)
o1.setMath(math)
o1.setMessage(message)
math = None
message = None
self.assert_( o1.getMath() != None )
msg = o1.getMessage()
self.assert_( msg != None )
o2 = libsbml.Constraint(o1)
self.assert_( o2.getMetaId() == "c" )
self.assert_( o2.getMath() != None )
msg = o2.getMessage()
self.assert_( msg != None )
self.assert_( o2.getParentSBMLObject() == o1.getParentSBMLObject() )
o2 = None
o1 = None
pass
def test_MathMLFormatter_constant_infinity(self):
expected = wrapMathML(" <infinity/>\n")
self.N = libsbml.ASTNode()
self.N.setValue(util_PosInf())
self.S = libsbml.writeMathMLToString(self.N)
self.assertEqual(True, self.equals(expected, self.S))
pass
def test_MathMLFormatter_constant_notanumber(self):
expected = wrapMathML(" <notanumber/>\n")
self.N = libsbml.ASTNode(libsbml.AST_REAL)
self.N.setValue(util_NaN())
self.S = libsbml.writeMathMLToString(self.N)
self.assertEqual(True, self.equals(expected, self.S))
pass
def test_ValidASTNode_returnsBoolean(self):
node = libsbml.ASTNode(libsbml.AST_LOGICAL_AND)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_LOGICAL_NOT)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_LOGICAL_OR)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_LOGICAL_XOR)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_FUNCTION_PIECEWISE)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_RELATIONAL_EQ)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_RELATIONAL_GEQ)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_RELATIONAL_GT)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_RELATIONAL_LEQ)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_RELATIONAL_LT)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_RELATIONAL_NEQ)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_CONSTANT_TRUE)
self.assertEqual(True, node.returnsBoolean())
node.setType(libsbml.AST_CONSTANT_FALSE)
self.assertEqual(True, node.returnsBoolean())
pass
def test_ASTNode_canonicalizeLogical(self):
n = libsbml.ASTNode(libsbml.AST_FUNCTION)
n.setName("and")
self.assert_(n.getType() == libsbml.AST_FUNCTION)
n.canonicalize()
self.assert_(n.getType() == libsbml.AST_LOGICAL_AND)
n.setType(libsbml.AST_FUNCTION)
n.setName("not")
self.assert_(n.getType() == libsbml.AST_FUNCTION)
n.canonicalize()
self.assert_(n.getType() == libsbml.AST_LOGICAL_NOT)
n.setType(libsbml.AST_FUNCTION)
n.setName("or")
self.assert_(n.getType() == libsbml.AST_FUNCTION)
n.canonicalize()
self.assert_(n.getType() == libsbml.AST_LOGICAL_OR)
n.setType(libsbml.AST_FUNCTION)
n.setName("xor")
self.assert_(n.getType() == libsbml.AST_FUNCTION)
n.canonicalize()
self.assert_(n.getType() == libsbml.AST_LOGICAL_XOR)
n.setType(libsbml.AST_FUNCTION)
_dummyList = [n]
_dummyList[:] = []
del _dummyList
pass
def test_StoichiometryMath_setMath2(self): math = libsbml.ASTNode(libsbml.AST_DIVIDE) i = self.D.setMath(math) self.assert_( i == libsbml.LIBSBML_INVALID_OBJECT ) self.assertEqual( False, self.D.isSetMath() ) _dummyList = [ math ]; _dummyList[:] = []; del _dummyList pass
def traverse_math(node, old_id, new_id):
if node is None: return
for i in range(node.getNumChildren()):
if node.getChild(i).getName() == old_id:
new_node = libsbml.ASTNode()
new_node.setName(new_id)
node.replaceChild(i, new_node)
traverse_math(node.getChild(i), old_id, new_id)
def test_SpeciesReference_setStoichiometryMath5(self): sr1 = libsbml.SpeciesReference(1,2) sm = libsbml.StoichiometryMath(2,4) math = libsbml.ASTNode(libsbml.AST_TIMES) a = libsbml.ASTNode() b = libsbml.ASTNode() a.setName( "a") b.setName( "b") math.addChild(a) math.addChild(b) sm.setMath(math) i = sr1.setStoichiometryMath(sm) self.assert_( i == libsbml.LIBSBML_UNEXPECTED_ATTRIBUTE ) self.assertEqual( False, sr1.isSetStoichiometryMath() ) _dummyList = [ sm ]; _dummyList[:] = []; del _dummyList _dummyList = [ sr1 ]; _dummyList[:] = []; del _dummyList pass
def test_Priority_setMath2(self):
math = libsbml.ASTNode(libsbml.AST_DIVIDE)
i = self.P.setMath(math)
self.assert_(i == libsbml.LIBSBML_INVALID_OBJECT)
self.assertEqual(False, self.P.isSetMath())
_dummyList = [math]
_dummyList[:] = []
del _dummyList
pass
def test_KineticLaw_setMath1(self): math = libsbml.ASTNode(libsbml.AST_TIMES) a = libsbml.ASTNode() b = libsbml.ASTNode() a.setName( "a") b.setName( "b") math.addChild(a) math.addChild(b) i = self.kl.setMath(math) self.assert_( i == libsbml.LIBSBML_OPERATION_SUCCESS ) self.assertEqual( True, self.kl.isSetMath() ) math1 = self.kl.getMath() self.assert_( math1 != None ) formula = libsbml.formulaToString(math1) self.assert_( formula != None ) self.assert_(( "a * b" == formula )) _dummyList = [ math ]; _dummyList[:] = []; del _dummyList pass
def test_ASTNode_isSqrt(self):
n = libsbml.ASTNode()
n.setType(libsbml.AST_FUNCTION)
self.assert_(n.isSqrt() == False)
n.setType(libsbml.AST_FUNCTION_ROOT)
self.assert_(n.isSqrt() == False)
c = libsbml.ASTNode()
n.addChild(c)
c.setValue(2)
self.assert_(n.isSqrt() == False)
n.addChild(libsbml.ASTNode())
self.assert_(n.isSqrt() == True)
c.setValue(3)
self.assert_(n.isSqrt() == False)
_dummyList = [n]
_dummyList[:] = []
del _dummyList
pass
def test_MathMLFormatter_csymbol_time(self):
expected = wrapMathML(
" <csymbol encoding=\"text\" " +
"definitionURL=\"http://www.sbml.org/sbml/symbols/time\"> t </csymbol>\n"
)
self.N = libsbml.ASTNode(libsbml.AST_NAME_TIME)
self.N.setName("t")
self.S = libsbml.writeMathMLToString(self.N)
self.assertEqual(True, self.equals(expected, self.S))
pass
def buildASTInequality(source, relation, threshold):
# create a ASTNode for the source/regulator
source_ASTNode = libsbml.ASTNode(libsbml.AST_NAME)
source_ASTNode.setName(source)
# create relation ASTNode. This exporter only uses '<' (lt) and '>=' (geq) relations
if(relation == 'lt'):
relation_ASTNode = libsbml.ASTNode(libsbml.AST_RELATIONAL_LT)
elif(relation == 'geq'):
relation_ASTNode = libsbml.ASTNode(libsbml.AST_RELATIONAL_GEQ)
# create threshold ASTNode
threshold_ASTNode = libsbml.ASTNode(libsbml.AST_INTEGER) # Integer ASTNode for threshold
threshold_ASTNode.setValue(threshold)
relation_ASTNode.addChild(libsbml.ASTNode(source_ASTNode)) # add source and upper bound nodes as children of the inequality node
relation_ASTNode.addChild(threshold_ASTNode)
return relation_ASTNode
def test_ASTNode_no_children(self):
node = libsbml.ASTNode()
self.assert_(node.getNumChildren() == 0)
self.assert_(node.getLeftChild() == None)
self.assert_(node.getRightChild() == None)
self.assert_(node.getChild(0) == None)
_dummyList = [node]
_dummyList[:] = []
del _dummyList
pass
def test_ASTNode_getName(self):
n = libsbml.ASTNode()
n.setName("foo")
self.assert_(("foo" == n.getName()))
n.setType(libsbml.AST_NAME_TIME)
self.assert_(("foo" == n.getName()))
n.setName(None)
self.assert_(n.getName() == None)
n.setType(libsbml.AST_CONSTANT_E)
self.assert_(("exponentiale" == n.getName()))
n.setType(libsbml.AST_CONSTANT_FALSE)
self.assert_(("false" == n.getName()))
n.setType(libsbml.AST_CONSTANT_PI)
self.assert_(("pi" == n.getName()))
n.setType(libsbml.AST_CONSTANT_TRUE)
self.assert_(("true" == n.getName()))
n.setType(libsbml.AST_LAMBDA)
self.assert_(("lambda" == n.getName()))
n.setType(libsbml.AST_FUNCTION)
n.setName("f")
self.assert_(("f" == n.getName()))
n.setType(libsbml.AST_FUNCTION_DELAY)
self.assert_(("f" == n.getName()))
n.setName(None)
self.assert_(("delay" == n.getName()))
n.setType(libsbml.AST_FUNCTION)
self.assert_(n.getName() == None)
n.setType(libsbml.AST_FUNCTION_ABS)
self.assert_(("abs" == n.getName()))
n.setType(libsbml.AST_FUNCTION_ARCCOS)
self.assert_(("arccos" == n.getName()))
n.setType(libsbml.AST_FUNCTION_TAN)
self.assert_(("tan" == n.getName()))
n.setType(libsbml.AST_FUNCTION_TANH)
self.assert_(("tanh" == n.getName()))
n.setType(libsbml.AST_LOGICAL_AND)
self.assert_(("and" == n.getName()))
n.setType(libsbml.AST_LOGICAL_NOT)
self.assert_(("not" == n.getName()))
n.setType(libsbml.AST_LOGICAL_OR)
self.assert_(("or" == n.getName()))
n.setType(libsbml.AST_LOGICAL_XOR)
self.assert_(("xor" == n.getName()))
n.setType(libsbml.AST_RELATIONAL_EQ)
self.assert_(("eq" == n.getName()))
n.setType(libsbml.AST_RELATIONAL_GEQ)
self.assert_(("geq" == n.getName()))
n.setType(libsbml.AST_RELATIONAL_LT)
self.assert_(("lt" == n.getName()))
n.setType(libsbml.AST_RELATIONAL_NEQ)
self.assert_(("neq" == n.getName()))
_dummyList = [n]
_dummyList[:] = []
del _dummyList
pass
def test_ValidASTNode_binary(self):
n = libsbml.ASTNode(libsbml.AST_DIVIDE)
self.assertEqual(False, (n.isWellFormedASTNode()))
c = libsbml.parseFormula("c")
n.addChild(c)
self.assertEqual(False, (n.isWellFormedASTNode()))
d = libsbml.parseFormula("d")
n.addChild(d)
self.assertEqual(True, n.isWellFormedASTNode())
n = None
pass
