def testrealnum(self):
"""test parsing of real numbers"""
res = self.parser.parse('a=5.45\n',debug=True,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self)==5.45)
res = self.parser.parse('a=.45e-24\n',debug=True,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) ==.45e-24)
def testrealnum(self):
"""test parsing of real numbers"""
res = self.parser.parse('a=5.45\n',debug=True,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self)==5.45)
res = self.parser.parse('a=.45e-24\n',debug=True,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) ==.45e-24)
def testshortstring(self):
"""test parsing a one-line string"""
jk = "a = \"my pink pony's mane\""
jl = "a = 'my pink pony\"s mane'"
ress = self.parser.parse(jk+"\n",lexer=self.lexer)
resr = self.parser.parse(jl+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(ress,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == jk[5:-1])
realfunc = drel_yacc.make_func(resr,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == jl[5:-1])
def testshortstring(self):
"""test parsing a one-line string"""
jk = "a = \"my pink pony's mane\""
jl = "a = 'my pink pony\"s mane'"
ress = self.parser.parse(jk+"\n",lexer=self.lexer)
resr = self.parser.parse(jl+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(ress,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == jk[5:-1])
realfunc = drel_yacc.make_func(resr,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == jl[5:-1])
def testassignment(self):
"""Test that an assignment works"""
teststrg = "n = 11"
res = self.parser.parse(teststrg,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","n",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self)==11)
def testparen(self):
"""test parentheses"""
test = "a = ('once', 'upon', 6,7j +.5e2)"
res = self.parser.parse(test+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) ==('once' , 'upon' , 6 , 7j + .5e2 ))
def testparen(self):
"""test parentheses"""
test = "a = ('once', 'upon', 6,7j +.5e2)"
res = self.parser.parse(test+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) ==('once' , 'upon' , 6 , 7j + .5e2 ))
def testlongstring(self):
"""test parsing multi-line strings"""
jk = '''a = """ a long string la la la '"'
some more
end"""'''
jl = """a = ''' a long string la la la '"'
some more
end'''"""
ress = self.parser.parse(jk+"\n",lexer=self.lexer)
resr = self.parser.parse(jl+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(ress,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == jk[7:-3])
realfunc = drel_yacc.make_func(resr,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == jl[7:-3])
def testlists(self):
"""test list parsing"""
test = "a = ['once', 'upon', 6,7j +.5e2]"
res = self.parser.parse(test+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) ==['once' , 'upon' , 6 , 7j + .5e2 ])
def testassignment(self):
"""Test that an assignment works"""
teststrg = "n = 11"
res = self.parser.parse(teststrg,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","n",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self)==11)
def testexprlist(self):
"""test comma-separated expressions"""
test = "a = 5,6,7+8.5e2"
res = self.parser.parse(test+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) ==(5,6,7+8.5e2))
def testlongstring(self):
"""test parsing multi-line strings"""
jk = '''a = """ a long string la la la '"'
some more
end"""'''
jl = """a = ''' a long string la la la '"'
some more
end'''"""
ress = self.parser.parse(jk+"\n",lexer=self.lexer)
resr = self.parser.parse(jl+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(ress,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == jk[7:-3])
realfunc = drel_yacc.make_func(resr,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == jl[7:-3])
def test_attributes(self):
"""Test that attributes of complex expressions come out OK"""
# We need to do a scary funky attribute of a key lookup
ourdic = CifFile.CifDic("testdic2")
testblock = CifFile.CifFile("test_data.cif")["testdata"]
self.parser.loopable_cats = ['geom','position'] #
teststrg = """
LineList = []
PointList = []
With p as position
Loop g as geom {
If (g.type == "point") {
PointList += Tuple(g.vertex1_id,p[g.vertex1_id].vector_xyz)
}
#Else if (g.type == "line") {
# LineList ++= Tuple(Tuple(g.vertex1_id, g.vertex2_id),
# Tuple(p[g.vertex1_id].vector_xyz,
# p[g.vertex2_id].vector_xyz))
#}
}
"""
self.parser.target_id = 'PointList'
res = self.parser.parse(teststrg+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","PointList")
print "Function -> \n" + realfunc
exec realfunc
retval = myfunc(ourdic,testblock,"LineList")
print "testdic2 return value" + `retval`
print "Value for comparison with docs: %s" % `retval[0]`
def test_attributes(self):
"""Test that attributes of complex expressions come out OK"""
# We need to do a scary funky attribute of a key lookup
ourdic = CifFile.CifDic("testdic2",grammar="DDLm")
testblock = CifFile.CifFile("test_data.cif",grammar="DDLm")["testdata"]
self.parser.loopable_cats = ['geom','position'] #
teststrg = """
LineList = []
PointList = []
With p as position
Loop g as geom {
If (g.type == "point") {
PointList += Tuple(g.vertex1_id,p[g.vertex1_id].vector_xyz)
}
#Else if (g.type == "line") {
# LineList ++= Tuple(Tuple(g.vertex1_id, g.vertex2_id),
# Tuple(p[g.vertex1_id].vector_xyz,
# p[g.vertex2_id].vector_xyz))
#}
}
"""
self.parser.target_id = 'PointList'
res = self.parser.parse(teststrg+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","PointList")
print "Function -> \n" + realfunc
exec realfunc
retval = myfunc(ourdic,testblock,"LineList")
print "testdic2 return value" + `retval`
print "Value for comparison with docs: %s" % `retval[0]`
def testexprlist(self):
"""test comma-separated expressions"""
test = "a = 5,6,7+8.5e2"
res = self.parser.parse(test+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) ==(5,6,7+8.5e2))
def testlists(self):
"""test list parsing"""
test = "a = ['once', 'upon', 6,7j +.5e2]"
res = self.parser.parse(test+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) ==['once' , 'upon' , 6 , 7j + .5e2 ])
def testmathexpr(self):
"""test simple maths expressions """
testexpr = (("a = 5.45 + 23.6e05",5.45+23.6e05),
("a = 11 - 45",11-45),
("a = 45.6 / 22.2",45.6/22.2))
for test,check in testexpr:
res = self.parser.parse(test+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == check)
def testmathexpr(self):
"""test simple maths expressions """
testexpr = (("a = 5.45 + 23.6e05",5.45+23.6e05),
("a = 11 - 45",11-45),
("a = 45.6 / 22.2",45.6/22.2))
for test,check in testexpr:
res = self.parser.parse(test+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == check)
def testinteger(self):
"""test parsing an integer"""
resm = [0,0,0,0]
checkm = [1230,77,5,473]
resm[0] = self.parser.parse('a = 1230\n',lexer=self.lexer)
resm[1] = self.parser.parse('a = 0x4D\n',lexer=self.lexer)
resm[2] = self.parser.parse('a = 0B0101\n',lexer=self.lexer)
resm[3] = self.parser.parse('a = 0o731\n',lexer=self.lexer)
for res,check in zip(resm,checkm):
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == check)
def testinteger(self):
"""test parsing an integer"""
resm = [0,0,0,0]
checkm = [1230,77,5,473]
resm[0] = self.parser.parse('a = 1230\n',lexer=self.lexer)
resm[1] = self.parser.parse('a = 0x4D\n',lexer=self.lexer)
resm[2] = self.parser.parse('a = 0B0101\n',lexer=self.lexer)
resm[3] = self.parser.parse('a = 0o731\n',lexer=self.lexer)
for res,check in zip(resm,checkm):
realfunc = drel_yacc.make_func(res,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == check)
def test_tables(self):
"""Test that tables are parsed correctly"""
teststrg = """
jk = Table()
jk['bx'] = 25
"""
print "Table test:"
res = self.parser.parse(teststrg+"\n",debug=True,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","jk",have_sn=False)
print "Table: %s" % `res[0]`
exec realfunc
b = myfunc(self,self)
self.failUnless(b['bx']==25)
def test_tables(self):
"""Test that tables are parsed correctly"""
teststrg = """
jk = Table()
jk['bx'] = 25
"""
print "Table test:"
res = self.parser.parse(teststrg+"\n",debug=True,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","jk",have_sn=False)
print "Table: %s" % `res[0]`
exec realfunc
b = myfunc(self,self)
self.failUnless(b['bx']==25)
def test_if_stmt(self):
"""test parsing of if statement"""
teststrg = """
dmin = 5.0
d1 = 4.0
rad1 = 2.2
radius_bond = 2.0
If (d1<dmin or d1>(rad1+radius_bond)) b = 5
"""
res = self.parser.parse(teststrg + "\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","b",have_sn=False)
exec realfunc
b = myfunc(self,self)
print "if returns %d" % b
self.failUnless(b==5)
def test_if_stmt(self):
"""test parsing of if statement"""
teststrg = """
dmin = 5.0
d1 = 4.0
rad1 = 2.2
radius_bond = 2.0
If (d1<dmin or d1>(rad1+radius_bond)) b = 5
"""
res = self.parser.parse(teststrg + "\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","b",have_sn=False)
exec realfunc
b = myfunc(self,self)
print "if returns %d" % b
self.failUnless(b==5)
def test_loop_statement(self):
"""Test proper processing of loop statements"""
teststrg = """
n = 0
loop p as dictionary_audit n += 1
_symmetry.ops = n
"""
self.parser.loopable_cats = ['dictionary_audit'] #category dictionary is not looped
self.parser.target_id = '_symmetry.ops'
res = self.parser.parse(teststrg+"\n",lexer=self.lexer,debug=1)
realfunc = drel_yacc.make_func(res,"myfunc",None)
print "Loop statement -> \n" + realfunc
exec realfunc
symops = myfunc(self.testdic,self.testblock)
print 'symops now %d' % symops
self.failUnless(symops == 81)
def test_loop_statement(self):
"""Test proper processing of loop statements"""
teststrg = """
n = 0
loop p as dictionary_audit n += 1
_symmetry.ops = n
"""
self.parser.loopable_cats = ['dictionary_audit'] #category dictionary is not looped
self.parser.target_id = '_symmetry.ops'
res = self.parser.parse(teststrg+"\n",lexer=self.lexer,debug=1)
realfunc = drel_yacc.make_func(res,"myfunc",None)
print "Loop statement -> \n" + realfunc
exec realfunc
symops = myfunc(self.testdic,self.testblock)
print 'symops now %d' % symops
self.failUnless(symops == 81)
def test_functions(self):
"""Test that functions are converted correctly"""
struct_testdic = CifFile.CifFile("/home/jrh/COMCIFS/DDLm_20071010/cif_core.dic")
struct_testblock = struct_testdic["CIF_CORE"]
self.parser.loopable_cats = ["import"] #category import is looped
self.parser.target_id = "_import_list.id"
self.parser.withtable = {}
teststrg = """
with i as import
_import_list.id = List([i.scope, i.block, i.file, i.if_dupl, i.if_miss])
"""
res = self.parser.parse(teststrg+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc",None)
print "With statement -> \n" + realfunc
exec realfunc
retval = myfunc(self.testdic,struct_testblock,3)
self.failUnless(retval == StarFile.StarList(["dic","CORE_MODEL","core_model.dic","exit","exit"]))
def test_functions(self):
"""Test that functions are converted correctly"""
struct_testdic = CifFile.CifFile("cif_core.dic", grammar="DDLm")
struct_testblock = struct_testdic["CIF_CORE"]
self.parser.loopable_cats = ["import"] #category import is looped
self.parser.target_id = "_import_list.id"
self.parser.withtable = {}
teststrg = """
with i as import
_import_list.id = List([i.scope, i.block, i.file, i.if_dupl, i.if_miss])
"""
res = self.parser.parse(teststrg+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc",None)
print "With statement -> \n" + realfunc
exec realfunc
retval = myfunc(self.testdic,struct_testblock,3)
self.failUnless(retval == StarFile.StarList(["dic","CORE_MODEL","core_model.dic","exit","exit"]))
def test_nested_stmt(self):
"""Test how a nested do statement prints"""
teststrg = """
total = 0
othertotal = 0
do jkl = 0,20,2 { total = total + jkl
do emm = 1,5 { othertotal = othertotal + 1 }
}
end_of_loop = -25.6
"""
res = self.parser.parse(teststrg + "\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","othertotal,total",have_sn=False)
print "Nested do:\n" + realfunc
exec realfunc
othertotal,total = myfunc(self,self)
print "nested do returns %d, %d" % (othertotal,total)
self.failUnless(othertotal==55)
self.failUnless(total==110)
def test_nested_stmt(self):
"""Test how a nested do statement prints"""
teststrg = """
total = 0
othertotal = 0
do jkl = 0,20,2 { total = total + jkl
do emm = 1,5 { othertotal = othertotal + 1 }
}
end_of_loop = -25.6
"""
res = self.parser.parse(teststrg + "\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","othertotal,total",have_sn=False)
print "Nested do:\n" + realfunc
exec realfunc
othertotal,total = myfunc(self,self)
print "nested do returns %d, %d" % (othertotal,total)
self.failUnless(othertotal==55)
self.failUnless(total==110)
def test_do_stmt(self):
"""Test how a do statement comes out"""
teststrg = """
total = 0
do jkl = 0,20,2 { total = total + jkl
}
do emm = 1,5 {
total = total + emm
}
"""
res = self.parser.parse(teststrg + "\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","total",have_sn=False)
exec realfunc
realres = myfunc(self,self)
# Do statements are inclusive
print "Do statement returns %d" % realres
self.failUnless(realres==125)
print res
def test_do_stmt(self):
"""Test how a do statement comes out"""
teststrg = """
total = 0
do jkl = 0,20,2 { total = total + jkl
}
do emm = 1,5 {
total = total + emm
}
"""
res = self.parser.parse(teststrg + "\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","total",have_sn=False)
exec realfunc
realres = myfunc(self,self)
# Do statements are inclusive
print "Do statement returns %d" % realres
self.failUnless(realres==125)
print res
def test_do_stmt_2(self):
"""Test how another do statement comes out"""
teststrg = """
pp = 0
geom_hbond = [(1,2),(2,3),(3,4)]
do i= 0,1 {
l,s = geom_hbond [i]
pp += s
}
"""
self.parser.special_id = [{'axy':1}]
res = self.parser.parse(teststrg + "\n",debug=True,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","pp",have_sn=False)
exec realfunc
realres = myfunc(self,self)
# Do statements are inclusive
print "Do statement returns %d" % realres
self.failUnless(realres==5)
print res
def test_do_stmt_2(self):
"""Test how another do statement comes out"""
teststrg = """
pp = 0
geom_hbond = [(1,2),(2,3),(3,4)]
do i= 0,1 {
l,s = geom_hbond [i]
pp += s
}
"""
self.parser.special_id = [{'axy':1}]
res = self.parser.parse(teststrg + "\n",debug=True,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc","pp",have_sn=False)
exec realfunc
realres = myfunc(self,self)
# Do statements are inclusive
print "Do statement returns %d" % realres
self.failUnless(realres==5)
print res
def test_fancy_assign(self):
"""Test fancy assignment"""
teststrg = """
a = [2,3,4]
b = 3
c= 4
do jkl = 1,5,1 {
geom_angle( .id = Tuple(a,b,c),
.distances = Tuple(b,c),
.value = jkl)
}
"""
self.parser.target_id = "geom_angle"
res = self.parser.parse(teststrg + "\n",debug=True,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc",None,cat_meth = True,have_sn=False)
print "Fancy assign: %s" % res[0]
exec realfunc
b = myfunc(self,self)
print "Geom_angle.angle = %s" % b['geom_angle.value']
self.failUnless(b['geom_angle.value']==[1,2,3,4])
def test_fancy_assign(self):
"""Test fancy assignment"""
teststrg = """
a = [2,3,4]
b = 3
c= 4
do jkl = 1,5,1 {
geom_angle( .id = Tuple(a,b,c),
.distances = Tuple(b,c),
.value = jkl)
}
"""
self.parser.target_id = "geom_angle"
res = self.parser.parse(teststrg + "\n",debug=True,lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc",None,cat_meth = True,have_sn=False)
print "Fancy assign: %s" % res[0]
exec realfunc
b = myfunc(self,self)
print "Geom_angle.angle = %s" % b['geom_angle.value']
self.failUnless(b['geom_angle.value']==[1,2,3,4])
def test_with_stmt(self):
"""Test what comes out of a simple flow statement, including
multiple with statements"""
teststrg = """
with p as description
with q as dictionary {
x = 22
j = 25
jj = q.date
px = p.text
_dictionary.date = "2007-04-01"
}"""
self.parser.loopable_cats = [] #category dictionary is not looped
self.parser.target_id = '_dictionary.date'
res = self.parser.parse(teststrg+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc",None)
print "With statement -> \n" + realfunc
exec realfunc
newdate = myfunc(self.testdic,self.testblock)
print 'date now %s' % newdate
self.failUnless(newdate == "2007-04-01")
def test_with_stmt(self):
"""Test what comes out of a simple flow statement, including
multiple with statements"""
teststrg = """
with p as description
with q as dictionary {
x = 22
j = 25
jj = q.date
px = p.text
_dictionary.date = "2007-04-01"
}"""
self.parser.loopable_cats = [] #category dictionary is not looped
self.parser.target_id = '_dictionary.date'
res = self.parser.parse(teststrg+"\n",lexer=self.lexer)
realfunc = drel_yacc.make_func(res,"myfunc",None)
print "With statement -> \n" + realfunc
exec realfunc
newdate = myfunc(self.testdic,self.testblock)
print 'date now %s' % newdate
self.failUnless(newdate == "2007-04-01")
def execute_method(self):
#create our lexer and parser
self.lexer = drel_lex.lexer
self.parser = drel_yacc.parser
#use a simple dictionary
self.testdic = CifFile.CifDic("dict/cif_short.dic")
self.testdic.diclang = "DDLm"
self.testblock = CifFile.CifFile("tests/c2ctest5.cif") ["c2ctest5"]
#create the global namespace
self.namespace = self.testblock.keys()
self.namespace = dict(map(None,self.namespace,self.namespace))
self.parser.loopable_cats = ["import"]
self.parser.special_id = [self.namespace]
self.parser.withtable = {}
self.parser.target_id = None
self.parser.indent = ""
#get valuename from cmdline
valuename = sys.argv[1]
f = open("method_expression")
expression = f.readline()
str_list = []
str_list.append(expression)
while expression:
expression = f.readline()
str_list.append(expression)
expression = "".join(str_list)
self.parser.target_id = valuename
res = self.parser.parse(expression + "\n", lexer=self.lexer)
realfunc = drel_yacc.make_func(res, "myfunc", valuename)
print "Compiling dREL....."
exec realfunc
realres = myfunc(self.testdic,self.testblock)
print "Generated value: %s" % realres
fout = open("method_output", 'w')
print>>fout, realres
def execute_method(self):
#create our lexer and parser
self.lexer = drel_lex.lexer
self.parser = drel_yacc.parser
#use a simple dictionary
self.testdic = CifFile.CifDic("dict/cif_short.dic")
self.testdic.diclang = "DDLm"
self.testblock = CifFile.CifFile("tests/c2ctest5.cif")["c2ctest5"]
#create the global namespace
self.namespace = self.testblock.keys()
self.namespace = dict(map(None, self.namespace, self.namespace))
self.parser.loopable_cats = ["import"]
self.parser.special_id = [self.namespace]
self.parser.withtable = {}
self.parser.target_id = None
self.parser.indent = ""
#get valuename from cmdline
valuename = sys.argv[1]
f = open("method_expression")
expression = f.readline()
str_list = []
str_list.append(expression)
while expression:
expression = f.readline()
str_list.append(expression)
expression = "".join(str_list)
self.parser.target_id = valuename
res = self.parser.parse(expression + "\n", lexer=self.lexer)
realfunc = drel_yacc.make_func(res, "myfunc", valuename)
print "Compiling dREL....."
exec realfunc
realres = myfunc(self.testdic, self.testblock)
print "Generated value: %s" % realres
fout = open("method_output", 'w')
print >> fout, realres
def testcomplex(self):
"""test parsing a complex number"""
resc = self.parser.parse('a = 13.45j\n',lexer=self.lexer)
realfunc = drel_yacc.make_func(resc,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == 13.45j)
def testcomplex(self):
"""test parsing a complex number"""
resc = self.parser.parse('a = 13.45j\n',lexer=self.lexer)
realfunc = drel_yacc.make_func(resc,"myfunc","a",have_sn=False)
exec realfunc
self.failUnless(myfunc(self,self) == 13.45j)