def test_as(self):
src = """
def test():
with foo as bar:
x + y
"""
expected = """
def test():
mgr__U0 = foo
exit__U0 = type(mgr__U0).__exit__
value__U0 = type(mgr__U0).__enter__(mgr__U0)
exc__U0 = True
try:
try:
bar = value__U0
x + y
except:
exc__U0 = False
if not exit__U0(mgr__U0, *sys.exc_info()):
raise
finally:
if exc__U0:
exit__U0(mgr__U0, None, None, None)
"""
utils.compare(src, expected, dewith.DeWith)
def test_tryfinally(self):
src = """
def test():
try:
return "hi"
finally:
return "hello"
print "world"
"""
expected = """
def test():
returnvalue__U0 = None
interrupted__U0 = "0_none"
try:
returnvalue__U0 = "hi"
interrupted__U0 = "3_return"
finally:
interrupted__U1 = interrupted__U0
returnvalue__U0 = "hello"
interrupted__U0 = "3_return"
interrupted__U0 = __pydron_max__(interrupted__U0, interrupted__U1)
if interrupted__U0 == "0_none":
print "world"
return returnvalue__U0
"""
utils.compare(src, expected, DeInterrupt)
def test_for_break_continue(self):
src = """
def test():
for a in b:
if a:
break
if b:
continue
print "hi"
"""
expected = """
def test():
interrupted__U0 = "0_none"
for a in b:
interrupted__U0 = "0_none"
if a:
interrupted__U0 = "2_break"
if interrupted__U0 == "0_none":
interrupted__U0 = "0_none"
if b:
interrupted__U0 = "1_continue"
if interrupted__U0 == "0_none":
print "hi"
if interrupted__U0 == "1_continue":
interrupted__U0 = "0_none"
if ((interrupted__U0 == '2_break') or (interrupted__U0 == '3_return')):
break
if interrupted__U0 == "2_break":
interrupted__U0 = "0_none"
return None
"""
utils.compare(src, expected, DeInterrupt)
def test_return_skip_nested(self):
src = """
def test():
if a:
if b:
return "Hello"
print "a"
print "b"
"""
expected = """
def test():
returnvalue__U0 = None
interrupted__U0 = "0_none"
if a:
interrupted__U0 = "0_none"
if b:
returnvalue__U0 = 'Hello'
interrupted__U0 = '3_return'
if interrupted__U0 == "0_none":
print "a"
if interrupted__U0 == "0_none":
print "b"
return returnvalue__U0
"""
utils.compare(src, expected, DeInterrupt)
def test_compare_oneop(self):
src = """
test = a == b
"""
expected = """
test = a == b
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_augassign_simple(self):
src = """
x += "s"
"""
expected = """
x += "s"
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_delete_single(self):
src = """
del x[0]
"""
expected = """
del x[0]
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_single_assignment(self):
src = """
x = 1
"""
expected = """
x = 1
"""
utils.compare(src, expected, demultitarget.DeMultiTarget)
def test_locals_globals(self):
src = """
exec "code" in context, context2
"""
expected = """
__pydron_exec__("code", context2, context)
"""
utils.compare(src, expected, deexec.DeExec)
def test_call_no_args(self):
src = """
f()
"""
expected = """
f()
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_attr(self):
src = """
x = a.y
"""
expected = """
x = a.y
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_exec(self):
src = """
exec "code"
"""
expected = """
__pydron_exec__("code", locals(), globals())
"""
utils.compare(src, expected, deexec.DeExec)
def test_binop_single(self):
src = """
x = 1 + 2
"""
expected = """
x = 1 + 2
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_unaryop(self):
src = """
x = -(1+2)
"""
expected = """
binop__U0 = 1 + 2
x = - (binop__U0)
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_dict(self):
src = """
x = {a+b: c}
"""
expected = """
binop__U0 = a+b
x = {binop__U0: c}
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_tuple_nested(self):
src = """
(a,(b,c),d) = x
"""
expected = """
a,tuple__U0,d = x
b,c = tuple__U0
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_attr_lhr(self):
src = """
(a+b).y = x
"""
expected = """
binop__U0 = a + b
binop__U0.y = x
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_subscript(self):
src = """
x = a[a+b]
"""
expected = """
binop__U0 = a + b
x = a[binop__U0]
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_repr(self):
src = """
`a+b`
"""
expected = """
binop__U0 = a + b
`binop__U0`
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_call_func(self):
src = """
(a+b)()
"""
expected = """
binop__U0 = a + b
binop__U0()
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_augassign(self):
src = """
x += "s" + "t"
"""
expected = """
binop__U0 = "s" + "t"
x += binop__U0
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_raise_onearg(self):
src = """
raise a+b
"""
expected = """
binop__U0 = a + b
raise binop__U0
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_delete(self):
src = """
del x[1 + 2]
"""
expected = """
binop__U0 = 1 + 2
del x[binop__U0]
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_tuple(self):
src = """
x = (1,2+3,4)
"""
expected = """
binop__U0 = 2 + 3
x = (1, binop__U0, 4)
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_multi_assignment_str(self):
src = """
x = y = "a"
"""
expected = """
x = "a"
y = "a"
"""
utils.compare(src, expected, demultitarget.DeMultiTarget)
def test_binop(self):
src = """
x = 1 + 2 * 3
"""
expected = """
binop__U0 = 2 * 3
x = 1 + binop__U0
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_multi_assignment_num(self):
src = """
x = y = 1
"""
expected = """
x = 1
y = 1
"""
utils.compare(src, expected, demultitarget.DeMultiTarget)
def test_list(self):
src = """
def test():
return [x for x in lst]
"""
expected = """
def test():
return [x for x in lst]
"""
utils.compare(src, expected, decomp.DeComp)
def test_subscript_lhs(self):
src = """
(a+b)[c+d] = x
"""
expected = """
binop__U0 = a + b
binop__U1 = c + d
binop__U0[binop__U1] = x
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_functiondef_primitive_default(self):
src = """
def f(x=1):
pass
"""
expected = """
def f(x=1):
pass
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_stream_multiple(self):
src = """
def test():
print >> stream, "Hello", "World"
"""
expected = """
def test():
__pydron_print__(stream, ("Hello", "World"), True)
"""
utils.compare(src, expected, deprint.DePrint)
def test_noargs(self):
src = """
def test():
pass
"""
expected = """
def test():
pass
"""
utils.compare(src, expected, dedefault.DeDefault)
def test_single_obj(self):
src = """
def test():
print "Hello"
"""
expected = """
def test():
__pydron_print__(None, ("Hello",), True)
"""
utils.compare(src, expected, deprint.DePrint)
def test_dict(self):
src = """
def test():
return {k:v for k,v in lst}
"""
expected = """
def test():
return dict([(k,v) for k,v in lst])
"""
utils.compare(src, expected, decomp.DeComp)
def test_nonewline(self):
src = """
def test():
print "Hello",
"""
expected = """
def test():
__pydron_print__(None, ("Hello",), False)
"""
utils.compare(src, expected, deprint.DePrint)
def test_slice_left(self):
src = """
def test():
obj[:1]
"""
expected = """
def test():
obj[slice(None,1,None)]
"""
utils.compare(src, expected, deslice.DeSlice)
def test_multi_assignment_complex(self):
src = """
x = y = 1 + 2
"""
expected = """
value__U0 = 1 + 2
x = value__U0
y = value__U0
"""
utils.compare(src, expected, demultitarget.DeMultiTarget)
def test_slice(self):
src = """
def test():
obj[1:2]
"""
expected = """
def test():
obj[slice(1,2,None)]
"""
utils.compare(src, expected, deslice.DeSlice)
def test_slice_step(self):
src = """
def test():
obj[1:2:3]
"""
expected = """
def test():
obj[slice(1,2,3)]
"""
utils.compare(src, expected, deslice.DeSlice)
def test_set_nested_list(self):
src = """
def test():
return {x for x in {y for y in lst}}
"""
expected = """
def test():
return set([x for x in set([y for y in lst])])
"""
utils.compare(src, expected, decomp.DeComp)
def test_set(self):
src = """
def test():
return {x for x in lst}
"""
expected = """
def test():
return set([x for x in lst])
"""
utils.compare(src, expected, decomp.DeComp)
def test_set_nested_elt(self):
src = """
def test():
return {{y for y in x} for x in lst}
"""
expected = """
def test():
return set([set([y for y in x]) for x in lst])
"""
utils.compare(src, expected, decomp.DeComp)
def test_call_kwargs(self):
src = """
f(*(a+b),**(c+d))
"""
expected = """
binop__U0 = a + b
binop__U1 = c + d
f(*binop__U0, **binop__U1)
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_call_star(self):
src = """
f(a+b,*(c+d))
"""
expected = """
binop__U0 = a + b
binop__U1 = c + d
f(binop__U0, *binop__U1)
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_call_keywords(self):
src = """
f(x=a+b,y=c+d)
"""
expected = """
binop__U0 = a + b
binop__U1 = c + d
f(x=binop__U0, y=binop__U1)
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_raise_twoargs(self):
src = """
raise a+b, c+d
"""
expected = """
binop__U0 = a + b
binop__U1 = c + d
raise binop__U0, binop__U1
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_simple(self):
src = """
class Test():
x = 1
"""
expected = """
class Test():
x = 1
__pydron_members__ = locals()
"""
utils.compare(src, expected, demembers.DeMembers)
def test_classdef(self):
src = """
class f(a + b):
pass
"""
expected = """
binop__U0 = a + b
class f(binop__U0):
pass
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_if(self):
src = """
if a + b:
pass
"""
expected = """
binop__U0 = a + b
if binop__U0:
pass
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_return(self):
src = """
def f():
return "s" + "t"
"""
expected = """
def f():
binop__U0 = "s" + "t"
return binop__U0
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_yield(self):
src = """
def f():
yield a+b
"""
expected = """
def f():
binop__U0 = a + b
yield binop__U0
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_raise_threeargs(self):
src = """
raise a+b, c+d, e+f
"""
expected = """
binop__U0 = a + b
binop__U1 = c + d
binop__U2 = e + f
raise binop__U0, binop__U1, binop__U2
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_for_target(self):
src = """
for x.abc in l:
a + b
"""
expected = """
for target__U0 in l:
x.abc = target__U0
a + b
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_inside_if(self):
src = """
if test:
x = a * b + c
"""
expected = """
if test:
binop__U0 = a * b
x = binop__U0 + c
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_tuple_nested2(self):
src = """
(a,(b,c[1+2]),d) = x
"""
expected = """
a,tuple__U0,d = x
b,tuple__U1 = tuple__U0
binop__U0 = 1 + 2
c[binop__U0] = tuple__U1
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_for_iterator(self):
src = """
for x in a + b:
pass
"""
expected = """
binop__U0 = a + b
for x in binop__U0:
pass
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_add_return(self):
src = """
def test():
pass
"""
expected = """
def test():
pass
return None
"""
utils.compare(src, expected, DeInterrupt)
def test_functiondef_default(self):
src = """
def f(x=1+2):
pass
"""
expected = """
binop__U0 = 1 + 2
def f(x=binop__U0):
pass
"""
utils.compare(src, expected, decomplexexpr.DeComplexExpr)
def test_func_one(self):
src = """
@mydecorator
def test():
pass
"""
expected = """
def test__U0():
pass
test = mydecorator(test__U0)
"""
utils.compare(src, expected, dedecorator.DeDecorator)
def test_func_arguments(self):
src = """
@mydecorator(1,2,3)
def test():
pass
"""
expected = """
def test__U0():
pass
test = mydecorator(1,2,3)(test__U0)
"""
utils.compare(src, expected, dedecorator.DeDecorator)
