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_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_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_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_attr(self):
     src = """
     x = a.y
     """
     expected = """
     x = a.y
     """
     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_binop_single(self):
     src = """
     x = 1 + 2
     """
     expected = """
     x = 1 + 2
     """
     utils.compare(src, expected, decomplexexpr.DeComplexExpr)

 def test_call_no_args(self):
     src = """
     f()
     """
     expected = """
     f()
     """
     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_multi_assignment_num(self):
     src = """
     x = y = 1
     """
     expected = """
     x = 1
     y = 1
     """
     utils.compare(src, expected, demultitarget.DeMultiTarget)

 def test_augassign(self):
     src = """
     x += "s" + "t"
     """
     expected = """
     binop__U0 = "s" + "t"
     x += binop__U0
     """
     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_binop(self):
     src = """
     x = 1 + 2 * 3
     """
     expected = """
     binop__U0 = 2 * 3
     x = 1 + binop__U0
     """
     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)