import sys, itertools, unittest

from test import support

from io import StringIO

import ast

import types

def to_tuple(t):

if t is None or isinstance(t, (str, int, complex)):

return t

elif isinstance(t, list):

return [to_tuple(e) for e in t]

result = [t.__class__.__name__]

if hasattr(t, 'lineno') and hasattr(t, 'col_offset'):

result.append((t.lineno, t.col_offset))

if t._fields is None:

return tuple(result)

for f in t._fields:

result.append(to_tuple(getattr(t, f)))

return tuple(result)

# These tests are compiled through "exec"

# There should be at least one test per statement

exec_tests = [

# FunctionDef

"def f(): pass",

"def f(a): pass",

"def f(a=1): pass",

"def f(*args, **kwargs): pass",

# ClassDef

"class C:pass",

# Return

"def f():return 1",

# Delete

"del v",

# Assign

"v = 1",

# AugAssign

"v += 1",

# Print

"print >>f, 1, ",

# For

"for v in v:pass",

# While

"while v:pass",

# If

"if v:pass",

# If elif else

"if v:pass\nelif u:pass\nelse: pass",

# Raise

"raise Exception, 'string'",

# TryExcept

"try:\n pass\nexcept Exception:\n pass",

# TryFinally

"try:\n pass\nfinally:\n pass",

# Assert

"assert v",

# Import

"import sys",

# ImportFrom

"from sys import v",

# Exec

"exec 'v'",

# Global

"global v",

# Expr

"1",

# Pass,

"pass",

# Break

# "break", doesn't work outside a loop

"while x: break",

# Continue

# "continue", doesn't work outside a loop

"while x: continue",

# for statements with naked tuples (see http://bugs.python.org/issue6704)

"for a,b in c: pass",

"[(a,b) for a,b in c]",

"((a,b) for a,b in c)",

# yield makes no sense outside function

"def f(): yield 1",

# CP35001

"def f(): yield",

# comment

"#"

]

# These are compiled through "single"

# because of overlap with "eval", it just tests what

# can't be tested with "eval"

single_tests = [

"1+2"

]

# These are compiled through "eval"

# It should test all expressions

eval_tests = [

# BoolOp

"a and b",

# BinOp

"a + b",

# UnaryOp

"not v",

# Lambda

"lambda:None",

"lambda x: x",

"lambda x: (yield x)",

# Dict

"{ 1:2 }",

# ListComp

"[a for b in c if d]",

# GeneratorExp

"(a for b in c for d in e for f in g)",

"(a for b in c if d)",

"(a for b in c for c in d)",

# Yield

"((yield i) for i in range(5))",

# Compare

"1 < 2 < 3",

# Call

"f(1,2,c=3,*d,**e)",

# Repr

"`v`",

# Num

"10L",

# Str

"'string'",

# Attribute

"a.b",

# Subscript

"a[b:c]",

# Name

"v",

# List

"[1,2,3]",

# Tuple

"1,2,3",

# Combination

"a.b.c.d(a.b[1:2])",

# ellipsis

"a[...]",

# index

"a[1]",

# set

"{a,b,c}",

# DictComp

"{k:v for k,v in li}",

# SetComp

"{e for e in li}",

]

# TODO: expr_context, slice, boolop, operator, unaryop, cmpop, comprehension

# excepthandler, arguments, keywords, alias

class AST_Tests(unittest.TestCase):

def _assertTrueorder(self, ast_node, parent_pos):

if not isinstance(ast_node, ast.AST) or ast_node._fields is None:

return

if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)):

node_pos = (ast_node.lineno, ast_node.col_offset)

self.assertTrue(node_pos >= parent_pos)

parent_pos = (ast_node.lineno, ast_node.col_offset)

for name in ast_node._fields:

value = getattr(ast_node, name)

if isinstance(value, list):

for child in value:

self._assertTrueorder(child, parent_pos)

elif value is not None:

self._assertTrueorder(value, parent_pos)

def test_compile_from_ast_001(self):

p = ast.parse("-1", mode="eval")

c = compile(p,"<unknown>", mode="eval" )

self.assertEqual( eval(c), -1)

def test_compile_from_ast_002(self):

p = ast.parse("+1", mode="eval")

c = compile(p,"<unknown>", mode="eval" )

self.assertEqual( eval(c), 1)

def test_compile_from_ast_003(self):

p = ast.parse("not True", mode="eval")

c = compile(p,"<unknown>", mode="eval" )

self.assertEqual( eval(c), False)

def test_compile_from_ast_004(self):

p = ast.parse("2+2", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), 4 )

def test_compile_from_ast_005(self):

p = ast.parse("5-1", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), 4 )

def test_compile_from_ast_006(self):

p = ast.parse("42%13", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), 3 )

def test_compile_from_ast_007(self):

p = ast.parse("2**8", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), 256 )

def test_compile_from_ast_008(self):

p = ast.parse("True or False", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), True )

def test_compile_from_ast_009(self):

p = ast.parse("True and False", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), False )

def test_compile_from_ast_010(self):

p = ast.parse("'a'", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), "a" )

def test_compile_from_ast_011(self):

p = ast.parse("42", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), 42 )

def test_compile_from_ast_012(self):

p = ast.parse("None", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), None )

def test_compile_from_ast_013(self):

p = ast.parse("[1,2,3]", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), [1,2,3] )

def test_compile_from_ast_014(self):

p = ast.parse("{1,2,3}", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), {1,2,3} )

def test_compile_from_ast_015(self):

p = ast.parse("{1:'a', 2:'b'}", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), {1:'a',2:'b'} )

def test_compile_from_ast_016(self):

p = ast.parse("1,2", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), (1,2) )

def test_compile_from_ast_017(self):

p = ast.parse("dict()", mode="eval") # trivial call expression

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), {} )

# parenthesis ?

def test_compile_from_ast_018(self):

p = ast.parse("(1)", mode="eval") # failed attempt to generate parenthesis expression

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), 1 )

def test_compile_from_ast_019(self):

p = ast.parse("[x for x in range(2)]", mode="eval") # list comprehension

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), [0,1] )

def test_compile_from_ast_020(self):

# list comprehension

p = ast.parse("[(x, y, z) for x in [1,2,3] if x!=2 for y in [3,1,4] for z in [7,8,9] if x != y]", mode="eval")

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), [(1, 3, 7), (1, 3, 8), (1, 3, 9), (1, 4, 7),

(1, 4, 8), (1, 4, 9), (3, 1, 7), (3, 1, 8),

(3, 1, 9), (3, 4, 7), (3, 4, 8), (3, 4, 9)] )

def test_compile_from_ast_021(self):

p = ast.parse("2>1", mode="eval") # Compare

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), True )

def test_compile_from_ast_022(self):

p = ast.parse("2>1<3==3", mode="eval") # All comparisons evaluate to True

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), True )

p = ast.parse("1>1<3==3", mode="eval") # False at first position

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), False )

p = ast.parse("2>1<0==0", mode="eval") # False at second position

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), False )

p = ast.parse("2>1<3==1", mode="eval") # False at third position

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), False )

def test_compile_from_ast_023(self):

p = ast.parse("{x for x in range(3) if x!=2 }", mode="eval") # set comprehension

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), {0,1} )

def test_compile_from_ast_024(self):

p = ast.parse("{ x : ord(x) for x in ['a','b'] }", mode="eval") # dict comprehension

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), {'a':97, 'b':98 } )

def test_compile_from_ast_025(self):

p = ast.parse("'a'.upper()", mode="eval") # attribute

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), 'A' )

def test_compile_from_ast_026(self):

p = ast.parse("lambda x: x", mode="eval") # lambda

c = compile(p,"<unknown>", mode="eval")

f = eval(c)

self.assertEqual( f(42),42)

def test_compile_from_ast_027(self):

p = ast.parse("lambda x=42: x", mode="eval") # default argument

c = compile(p,"<unknown>", mode="eval")

f = eval(c)

self.assertEqual( f(),42)

def test_compile_from_ast_028(self):

p = ast.parse("1 if True else 2", mode="eval") # conditional expression

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), 1 )

p = ast.parse("1 if False else 2", mode="eval") # conditional expression

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), 2 )

def test_compile_from_ast_029(self):

p = ast.parse("(x for x in [1,2,3] if x!=1)", mode="eval") # generator

c = compile(p,"<unknown>", mode="eval")

g = eval(c)

self.assertEqual( next(g), 2 )

self.assertEqual( next(g), 3 )

self.assertRaises( StopIteration, g.__next__ )

def test_compile_from_ast_030(self):

p = ast.parse("`101`", mode="eval") # repr

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), '101' )

def test_compile_from_ast_031(self):

p = ast.parse("range(13)[10]", mode="eval") # index

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), 10 )

def test_compile_from_ast_032(self):

p = ast.parse("range(42)[1:5]", mode="eval") # slice

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), list(range(1,5)))

def test_compile_from_ast_033(self):

p = ast.parse("range(42)[1:5:2]", mode="eval") # extended? slice

c = compile(p,"<unknown>", mode="eval")

self.assertEqual( eval(c), [1,3])

def test_compile_from_ast_034(self):

# plain generator

page = [ "line1 aaaaa bbb cccccc ddddddddd", "line2 xxxxxxxx yyyyyyy zzzzzz", "line3 ssssss ttttttttttt uuuu" ]

p = ast.parse("(word for line in page for word in line.split())", mode="eval")

c = compile(p,"<unknown>", mode="eval")

g = eval(c)

self.assertEqual( next(g), 'line1' )

self.assertEqual( next(g), 'aaaaa' )

self.assertEqual( next(g), 'bbb')

self.assertEqual( next(g), 'cccccc' )

self.assertEqual( next(g), 'ddddddddd' )

self.assertEqual( next(g), 'line2' )

self.assertEqual( next(g), 'xxxxxxxx' )

self.assertEqual( next(g), 'yyyyyyy' )

self.assertEqual( next(g), 'zzzzzz' )

self.assertEqual( next(g), 'line3' )

self.assertEqual( next(g), 'ssssss' )

self.assertEqual( next(g), 'ttttttttttt' )

self.assertEqual( next(g), 'uuuu' )

self.assertRaises( StopIteration, g.__next__ )

def test_compile_from_ast_035(self):

# generator with multiple ifs

page = [ "line1 aaaaa bbb cccccc ddddddddd", "short line", "line2 xxxxxxxx yyyyyyy zzzzzz", "line3 ssssss ttttttttttt uuuu" ]

p = ast.parse("(word for line in page if len(line)>10 for word in line.split() if word!='ssssss' if word!='zzzzzz')",

mode="eval")

c = compile(p,"<unknown>", mode="eval")

g = eval(c)

self.assertEqual( next(g), 'line1' )

self.assertEqual( next(g), 'aaaaa' )

self.assertEqual( next(g), 'bbb')

self.assertEqual( next(g), 'cccccc' )

self.assertEqual( next(g), 'ddddddddd' )

self.assertEqual( next(g), 'line2' )

self.assertEqual( next(g), 'xxxxxxxx' )

self.assertEqual( next(g), 'yyyyyyy' )

self.assertEqual( next(g), 'line3' )

self.assertEqual( next(g), 'ttttttttttt' )

self.assertEqual( next(g), 'uuuu' )

self.assertRaises( StopIteration, g.__next__ )

def test_compile_from_ast_036(self):

# the results comply 1:1 with cpython 2.7.3 on Linux

p = ast.parse("((yield i) for i in range(3))", mode="eval") # yield inside generator

c = compile(p,"<unknown>", mode="eval")

g = eval(c)

self.assertEqual(next(g),0)

self.assertIsNone(next(g))

self.assertEqual(next(g),1)

self.assertIsNone(next(g))

self.assertEqual(next(g),2)

self.assertIsNone(next(g))

self.assertRaises(StopIteration, g.__next__ )

# TODO: more testing for extended slices [1:2, 5:10], [1:2, ...] etc

# inspiration at: http://ilan.schnell-web.net/prog/slicing/

def test_compile_from_ast_038(self):

p = ast.parse("lambda x: (yield x)", mode="eval") # yield inside lambda

c = compile(p,"<unknown>", mode="eval")

eval(c)

f = eval(c)

g = f(1)

self.assertEqual(next(g),1)

self.assertRaises(StopIteration, g.__next__ )

def test_compile_from_ast_100(self):

p = ast.parse("pass", mode="exec")

c = compile(p,"<unknown>", mode="exec")

self.assertEqual( eval(c), None)

def test_compile_from_ast_101(self):

cap = StringIO()

p = ast.parse("print >> cap, 1, 2,", mode="exec") # print

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual( cap.getvalue(), "1 2")

def test_compile_from_ast_102(self):

p = ast.parse("a=b=42", mode="exec") # assignment

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(a, 42)

self.assertEqual(b, 42)

def test_compile_from_ast_103(self):

p = ast.parse("a,b=13,42", mode="exec") # assignment

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(a, 13)

self.assertEqual(b, 42)

def test_compile_from_ast_104(self):

p = ast.parse("a=42\na+=1", mode="exec") # assignment

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(a, 43)

def test_compile_from_ast_105(self):

p = ast.parse("assert True", mode="exec") # assert no exception

c = compile(p,"<unknown>", mode="exec")

exec(c)

p = ast.parse("assert False", mode="exec") # assert with exception

c = compile(p,"<unknown>", mode="exec")

raised=False

try:

exec(c)

except AssertionError:

raised=True

self.assertTrue(raised)

def test_compile_from_ast_106(self):

p = ast.parse("a=1\ndel a\nprint a", mode="exec") # delete statement

c = compile(p,"<unknown>", mode="exec")

raised=False

try:

exec(c)

except NameError:

raised=True

self.assertTrue(raised)

def test_compile_from_ast_107(self):

p = ast.parse("def f(): return\nf()", mode="exec") # return statement

c = compile(p,"<unknown>", mode="exec")

exec(c)

def test_compile_from_ast_108(self):

cap = StringIO()

p = ast.parse("def f(): return 42\nprint >> cap, f(),", mode="exec") # return statement

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(cap.getvalue(),'42')

def test_compile_from_ast_109(self):

p = ast.parse("def f(): yield 42", mode="exec") # yield statement

c = compile(p,"<unknown>", mode="exec")

exec(c)

g = f()

self.assertEqual(next(g),42)

self.assertRaises(StopIteration, g.__next__ )

def test_compile_from_ast_110(self):

p = ast.parse("raise Exception('expected')", mode="exec") # raise

c = compile(p,"<unknown>", mode="exec")

raised=False

try:

exec(c)

except Exception as e:

raised=True

self.assertEqual(e.message,'expected')

self.assertTrue(raised)

def test_compile_from_ast_111(self):

p = ast.parse("n=0\nwhile n==0:\n n=1\n break\n n=2", mode="exec") # break

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(n,1)

def test_compile_from_ast_112(self):

p = ast.parse("n=0\nwhile n==0:\n n=1\n continue\n raise Exception()", mode="exec") # continue

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(n,1)

# TODO: test relative imports

# TODO: test imports with subpackages structure

def test_compile_from_ast_113(self):

p = ast.parse("import dummy_module", mode="exec") # import

c = compile(p,"<unknown>", mode="exec")

exec(c)

from sys import modules

self.assertNotEqual(modules.get('dummy_module'),None)

self.assertEqual(modules.get('dummy_module'),dummy_module)

def test_compile_from_ast_114(self):

p = ast.parse("import dummy_module as baz", mode="exec") # import as

c = compile(p,"<unknown>", mode="exec")

exec(c)

from sys import modules

self.assertNotEqual(modules.get('dummy_module'),None)

self.assertEqual(modules.get('dummy_module'),baz)

def test_compile_from_ast_115(self):

p = ast.parse("from dummy_module import *", mode="exec") # from import *

c = compile(p,"<unknown>", mode="exec")

exec(c)

from sys import modules

self.assertNotEqual(modules.get('dummy_module'),None)

self.assertEqual(foo,1)

self.assertEqual(bar,2)

self.assertEqual(foobar,3)

def test_compile_from_ast_116(self):

p = ast.parse("def f():\n global i\n i+=41\nf()", mode="exec") # global

c = compile(p,"<unknown>", mode="exec")

v = {'i':1}

exec(c, v)

self.assertEqual(v['i'],42)

def test_compile_from_ast_117(self):

cap = StringIO()

p = ast.parse("exec 'print >> cap, 42,'", mode="exec") # exec

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(cap.getvalue(), '42')

def test_compile_from_ast_118(self):

p = ast.parse("if a:\n x=1\nelif b:\n x=2\nelse:\n x=3", mode="exec") # if elif else

c = compile(p,"<unknown>", mode="exec")

a = True

exec(c)

self.assertEqual(x,1)

a = False

b = True

exec(c)

self.assertEqual(x,2)

a = False

b = False

exec(c)

self.assertEqual(x,3)

def test_compile_from_ast_119(self):

p = ast.parse("a=1; b=2", mode="exec") # statement list?

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(a,1)

self.assertEqual(b,2)

def test_compile_from_ast_120(self):

p = ast.parse("n=1\nwhile n==0:\n n=13\nelse: n=42", mode="exec") # while with else

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(n,42)

def test_compile_from_ast_121(self):

cap = StringIO()

p = ast.parse("for i in [0,1,2]:\n print>> cap, i,\nelse:\n print>>cap, 'else',", mode="exec") # for with else

exec(compile(p,"<unknown>", mode="exec"))

self.assertEqual(cap.getvalue(),"0 1 2 else")

def test_compile_from_ast_122(self):

cap = StringIO()

tc = """

try:

print >> cap, 1,

raise Exception("test")

print >> cap, 2,

except Exception as e:

print >> cap, 3,

else:

print >> cap, 4,

finally:

print >> cap, 5,

"""

p = ast.parse( tc, mode="exec") # try except

exec(compile(p,"<unknown>", mode="exec"))

self.assertEqual(cap.getvalue(), "1 3 5")

def test_compile_from_ast_123(self):

cap = StringIO()

tc = """

try:

print >> cap, 1,

# raise Exception("test")

print >> cap, 2,

except Exception as e:

print >> cap, 3

else:

print >> cap, 4,

finally:

print >> cap, 5,

"""

p = ast.parse( tc, mode="exec") # try except

exec(compile(p,"<unknown>", mode="exec"))

self.assertEqual(cap.getvalue(),"1 2 4 5")

def test_compile_from_ast_124(self):

tc = """

with open("dummy_module.py") as dm:

l = len(dm.read())

"""

p = ast.parse( tc, mode="exec") # try except

exec(compile(p,"<unknown>", mode="exec"))

self.assertEqual(l,20)

def test_compile_from_ast_125(self):

tc = """

class Foo(object):

pass

foo=Foo()

"""

p = ast.parse( tc, mode="exec") # try except

exec(compile(p,"<unknown>", mode="exec"))

self.assertIsInstance(foo,Foo)

def test_compile_from_ast_126(self):

cap = StringIO()

tc = """

def f(a):

return a

print >> cap, f(22),

"""

p = ast.parse( tc, mode="exec") # call function with an argument

exec(compile(p,"<unknown>", mode="exec"))

self.assertEqual(cap.getvalue(), "22")

def test_compile_from_ast_127(self):

cap = StringIO()

tc = """

def f(a):

return a

print >> cap, f(a=222),

"""

p = ast.parse( tc, mode="exec") # call function with an argument, pass as keyword

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(cap.getvalue(), "222")

def test_compile_from_ast_128(self):

cap = StringIO()

tc = """

def f(a,*args):

return args[1]

print >> cap, f(1,2,42),

"""

p = ast.parse( tc, mode="exec") # call function with a variable number of arguments

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(cap.getvalue(), "42")

def test_compile_from_ast_129(self):

cap = StringIO()

tc = """

def f(a,**kwargs):

return kwargs["two"]

d={ "one":13, "two":42 }

print >> cap, f(1, **d),

"""

p = ast.parse( tc, mode="exec") # call function with a keyword argument

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(cap.getvalue(), "42")

def test_compile_from_ast_130(self):

cap = StringIO()

tc = """

def f(a,**kwargs):

return kwargs["two"]

print >> cap, f(1, two=42, one=13),

"""

p = ast.parse( tc, mode="exec") # call function with a keyword argument

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(cap.getvalue(), "42")

def test_compile_from_ast_131(self):

cap = StringIO()

tc = """

def deco(fx):

def wrap():

print >> cap, "wrapped"

fx()

return wrap

@deco

def f():

print >> cap, "f"

f()

"""

p = ast.parse( tc, mode="exec") # function decorator

c = compile(p,"<unknown>", mode="exec")

exec(c, {"cap": cap})

self.assertEqual(cap.getvalue(), "wrapped\nf\n")

def test_compile_from_ast_132(self):

cap = StringIO()

tc = """

def deco(k):

k.foo = 42

return k

@deco

class C:

pass

c=C()

print >> cap, c.foo,

"""

p = ast.parse( tc, mode="exec") # function decorator

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(cap.getvalue(), "42")

def test_compile_from_ast_133(self):

cap = StringIO()

tc = """

def f1():

yield 1

def fNone():

yield

for v in f1():

print >> cap, v

for v in fNone():

print >> cap, v

"""

p = ast.parse( tc, mode="exec") # yield

c = compile(p,"<unknown>", mode="exec")

exec(c)

self.assertEqual(cap.getvalue(), "1\nNone\n")

def test_compile_from_ast_200(self):

p = ast.parse("a=1; b=2", mode="single") # something with single

c = compile(p,"<unknown>", mode="single")

exec(c)

self.assertEqual(a,1)

self.assertEqual(b,2)

def test_compile_from_ast_201(self):

p = ast.parse("1+1", mode="single") # expression in single should find its way into stdout

c = compile(p,"<unknown>", mode="single")

saveStdout = sys.stdout

sys.stdout = cap = StringIO()

exec(c)

sys.stdout = saveStdout

self.assertEqual(cap.getvalue(), "2\n")

def test_compile_argument_bytes(self):

p = ast.parse(b'1+1', "<unknown>", mode="eval")

c = compile(p, "<unknown>", mode="eval")

self.assertEqual(eval(c),2)

def test_compile_argument_buffer(self):

p = ast.parse(buffer('1+1'), "<unknown>", mode="eval")

c = compile(p, "<unknown>", mode="eval")

self.assertEqual(eval(c),2)

def test_compile_argument_bytearray(self):

p = ast.parse(bytearray('1+1','ascii'), "<unknown>", mode="eval")

c = compile(p, "<unknown>", mode="eval")

self.assertEqual(eval(c),2)

def test_compile_argument_error(self):

self.assertRaises( TypeError, ast.parse, ['1+1'], "<unknown>", mode="eval")

def test_compile_manual(self):

# check that expressions which are built manually compile

for test in eval_tests:

a = ast.parse(test, "<unknown>", mode="eval")

b = ast.fix_missing_locations(eval(ast.dump(a, annotate_fields=False), vars(ast)))

compile(b, "<unknown>", mode="eval")

for test in exec_tests:

a = ast.parse(test, "<unknown>", mode="exec")

b = ast.fix_missing_locations(eval(ast.dump(a, annotate_fields=False), vars(ast)))

compile(b, "<unknown>", mode="exec")

def test_snippets(self):

# Things which diverted from cpython:

# - col_offset of list comprehension in ironpython uses opening bracket, cpython points to first expr

# - same for generator

# - Slice in iron has col_offset and lineno set, in cpython both are not set

for input, output, kind in ((exec_tests, exec_results, "exec"),

(single_tests, single_results, "single"),

(eval_tests, eval_results, "eval")):

for i, o in zip(input, output):

ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)

self.assertEqual(to_tuple(ast_tree), o)

self._assertTrueorder(ast_tree, (0, 0))

def test_slicex(self):

slc = ast.parse("x[1:2:3]").body[0].value.slice

self.assertEqual(slc.lower.n, 1)

self.assertEqual(slc.upper.n, 2)

self.assertEqual(slc.step.n, 3)

def test_slice(self):

slc = ast.parse("x[::]").body[0].value.slice

self.assertIsNone(slc.upper)

self.assertIsNone(slc.lower)

self.assertIsInstance(slc.step, ast.Name)

self.assertEqual(slc.step.id, "None")

def test_from_import(self):

im = ast.parse("from . import y").body[0]

self.assertIsNone(im.module)

def test_base_classes(self):

self.assertTrue(issubclass(ast.For, ast.stmt))

self.assertTrue(issubclass(ast.Name, ast.expr))

self.assertTrue(issubclass(ast.stmt, ast.AST))

self.assertTrue(issubclass(ast.expr, ast.AST))

self.assertTrue(issubclass(ast.comprehension, ast.AST))

self.assertTrue(issubclass(ast.Gt, ast.AST))

def test_nodeclasses(self):

# IronPyhon performs argument typechecking

l=ast.Str('A')

o=ast.Mult()

r=ast.Num('13')

x=ast.BinOp(l,o,r,lineno=42)

self.assertEqual(x.left, l)

self.assertEqual(x.op, o)

self.assertEqual(x.right, r)

self.assertEqual(x.lineno, 42)

# node raises exception when not given enough arguments

self.assertRaises(TypeError, ast.BinOp, l, o)

# can set attributes through kwargs too

x = ast.BinOp(left=l, op=o, right=r, lineno=42)

self.assertEqual(x.left, l)

self.assertEqual(x.op, o)

self.assertEqual(x.right, r)

self.assertEqual(x.lineno, 42)

# this used to fail because Sub._fields was None

x = ast.Sub()

def test_docexample(self):

# used to fail on ironpython for various reason

node = ast.UnaryOp(ast.USub(), ast.Num(5, lineno=0, col_offset=0),

lineno=0, col_offset=0)

# the same with zero argument constructors

node = ast.UnaryOp()

node.op = ast.USub()

node.operand = ast.Num()

node.operand.n = 5

node.operand.lineno = 0

node.operand.col_offset = 0

node.lineno = 0

node.col_offset = 0

def test_example_from_net(self):

node = ast.Expression(ast.BinOp(ast.Str('xy'), ast.Mult(), ast.Num(3)))

def _test_extra_attribute(self):

n=ast.Num()

n.extra_attribute=2

self.assertTrue(hasattr(n,'extra_attribute'))

def test_operators(self):

boolop0 = ast.BoolOp()

boolop1 = ast.BoolOp(ast.And(),

[ ast.Name('True', ast.Load()), ast.Name('False', ast.Load()), ast.Name('a',ast.Load())])

boolop2 = ast.BoolOp(ast.And(),

[ ast.Name('True', ast.Load()), ast.Name('False', ast.Load()), ast.Name('a',ast.Load())],

0, 0)

binop0 = ast.BinOp()

binop1 = ast.BinOp(ast.Str('xy'), ast.Mult(), ast.Num(3))

binop2 = ast.BinOp(ast.Str('xy'), ast.Mult(), ast.Num(3), 0, 0)

unaryop0 = ast.UnaryOp()

unaryop1 = ast.UnaryOp(ast.Not(), ast.Name('True',ast.Load()))

unaryop2 = ast.UnaryOp(ast.Not(), ast.Name('True',ast.Load()), 0, 0)

lambda0 = ast.Lambda()

lambda1 = ast.Lambda(ast.arguments([ast.Name('x', ast.Param())], None, None, []), ast.Name('x', ast.Load()))

ifexp0 = ast.IfExp()

ifexp1 = ast.IfExp(ast.Name('True',ast.Load()), ast.Num(1), ast.Num(0))

ifexp2 = ast.IfExp(ast.Name('True',ast.Load()), ast.Num(1), ast.Num(0), 0, 0)

dict0 = ast.Dict()

dict1 = ast.Dict([ast.Num(1), ast.Num(2)], [ast.Str('a'), ast.Str('b')])

dict2 = ast.Dict([ast.Num(1), ast.Num(2)], [ast.Str('a'), ast.Str('b')], 0, 0)

set0 = ast.Set()

set1 = ast.Set([ast.Num(1), ast.Num(2)])

set2 = ast.Set([ast.Num(1), ast.Num(2)], 0, 0)

lc0 = ast.ListComp()

lc1 = ast.ListComp( ast.Name('x',ast.Load()),

[ast.comprehension(ast.Name('x', ast.Store()),

ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load()), [])])

lc2 = ast.ListComp( ast.Name('x',ast.Load()),

[ast.comprehension(ast.Name('x', ast.Store()),

ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load()), [])], 0, 0)

setcomp0 = ast.SetComp()

setcomp1 = ast.SetComp(ast.Name('x', ast.Load()),

[ast.comprehension(ast.Name('x', ast.Store()), ast.Str('abracadabra'),

[ast.Compare(ast.Name('x', ast.Load()), [ast.NotIn()],

[ast.Str('abc')])])])

comprehension0 = ast.comprehension()

comprehension1 = ast.comprehension(ast.Name('x', ast.Store()),

ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load()), [])

# "{i : chr(65+i) for i in (1,2)}")

dictcomp0 = ast.DictComp()

dictcomp1 = ast.DictComp(ast.Name('i', ast.Load()),

ast.Call(ast.Name('chr', ast.Load()),

[ast.BinOp(ast.Num(65), ast.Add(), ast.Name('i', ast.Load()))],

[], None, None),

[ast.comprehension(ast.Name('i', ast.Store()),

ast.Tuple([ast.Num(1), ast.Num(n=2)], ast.Load()), [])])

dictcomp2 = ast.DictComp(ast.Name('i', ast.Load()),

ast.Call(ast.Name('chr', ast.Load()),

[ast.BinOp(ast.Num(65), ast.Add(), ast.Name('i', ast.Load()))],

[], None, None),

[ast.comprehension(ast.Name('i', ast.Store()),

ast.Tuple([ast.Num(1), ast.Num(n=2)], ast.Load()), [])],0,0)

# (x for x in (1,2))

genexp0 = ast.GeneratorExp()

genexp1 = ast.GeneratorExp(ast.Name('x', ast.Load()),

[ast.comprehension(ast.Name('x', ast.Store()),

ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load()), [])])

genexp2 = ast.GeneratorExp(ast.Name('x', ast.Load()),

[ast.comprehension(ast.Name('x', ast.Store()),

ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load()), [])],0,0)

# yield 2

yield0 = ast.Yield()

yield1 = ast.Yield(ast.Num(2))

yield2 = ast.Yield(ast.Num(2),0,0)

yield20 = ast.Yield(lineno=0, col_offset=0)

# a>0

compare0 = ast.Compare()

compare1 = ast.Compare(ast.Name('a', ast.Load()), [ast.Gt()], [ast.Num(0)])

compare2 = ast.Compare(ast.Name('a', ast.Load()), [ast.Gt()], [ast.Num(0)],0,0)

# chr(65)

call0 = ast.Call()