1import ast 2import dis 3import os 4import sys 5import unittest 6import weakref 7 8from test import support 9 10def to_tuple(t): 11 if t is None or isinstance(t, (str, int, complex)): 12 return t 13 elif isinstance(t, list): 14 return [to_tuple(e) for e in t] 15 result = [t.__class__.__name__] 16 if hasattr(t, 'lineno') and hasattr(t, 'col_offset'): 17 result.append((t.lineno, t.col_offset)) 18 if t._fields is None: 19 return tuple(result) 20 for f in t._fields: 21 result.append(to_tuple(getattr(t, f))) 22 return tuple(result) 23 24 25# These tests are compiled through "exec" 26# There should be at least one test per statement 27exec_tests = [ 28 # None 29 "None", 30 # Module docstring 31 "'module docstring'", 32 # FunctionDef 33 "def f(): pass", 34 # FunctionDef with docstring 35 "def f(): 'function docstring'", 36 # FunctionDef with arg 37 "def f(a): pass", 38 # FunctionDef with arg and default value 39 "def f(a=0): pass", 40 # FunctionDef with varargs 41 "def f(*args): pass", 42 # FunctionDef with kwargs 43 "def f(**kwargs): pass", 44 # FunctionDef with all kind of args and docstring 45 "def f(a, b=1, c=None, d=[], e={}, *args, f=42, **kwargs): 'doc for f()'", 46 # ClassDef 47 "class C:pass", 48 # ClassDef with docstring 49 "class C: 'docstring for class C'", 50 # ClassDef, new style class 51 "class C(object): pass", 52 # Return 53 "def f():return 1", 54 # Delete 55 "del v", 56 # Assign 57 "v = 1", 58 # AugAssign 59 "v += 1", 60 # For 61 "for v in v:pass", 62 # While 63 "while v:pass", 64 # If 65 "if v:pass", 66 # With 67 "with x as y: pass", 68 "with x as y, z as q: pass", 69 # Raise 70 "raise Exception('string')", 71 # TryExcept 72 "try:\n pass\nexcept Exception:\n pass", 73 # TryFinally 74 "try:\n pass\nfinally:\n pass", 75 # Assert 76 "assert v", 77 # Import 78 "import sys", 79 # ImportFrom 80 "from sys import v", 81 # Global 82 "global v", 83 # Expr 84 "1", 85 # Pass, 86 "pass", 87 # Break 88 "for v in v:break", 89 # Continue 90 "for v in v:continue", 91 # for statements with naked tuples (see http://bugs.python.org/issue6704) 92 "for a,b in c: pass", 93 "[(a,b) for a,b in c]", 94 "((a,b) for a,b in c)", 95 "((a,b) for (a,b) in c)", 96 # Multiline generator expression (test for .lineno & .col_offset) 97 """( 98 ( 99 Aa 100 , 101 Bb 102 ) 103 for 104 Aa 105 , 106 Bb in Cc 107 )""", 108 # dictcomp 109 "{a : b for w in x for m in p if g}", 110 # dictcomp with naked tuple 111 "{a : b for v,w in x}", 112 # setcomp 113 "{r for l in x if g}", 114 # setcomp with naked tuple 115 "{r for l,m in x}", 116 # AsyncFunctionDef 117 "async def f():\n 'async function'\n await something()", 118 # AsyncFor 119 "async def f():\n async for e in i: 1\n else: 2", 120 # AsyncWith 121 "async def f():\n async with a as b: 1", 122 # PEP 448: Additional Unpacking Generalizations 123 "{**{1:2}, 2:3}", 124 "{*{1, 2}, 3}", 125 # Asynchronous comprehensions 126 "async def f():\n [i async for b in c]", 127] 128 129# These are compiled through "single" 130# because of overlap with "eval", it just tests what 131# can't be tested with "eval" 132single_tests = [ 133 "1+2" 134] 135 136# These are compiled through "eval" 137# It should test all expressions 138eval_tests = [ 139 # None 140 "None", 141 # BoolOp 142 "a and b", 143 # BinOp 144 "a + b", 145 # UnaryOp 146 "not v", 147 # Lambda 148 "lambda:None", 149 # Dict 150 "{ 1:2 }", 151 # Empty dict 152 "{}", 153 # Set 154 "{None,}", 155 # Multiline dict (test for .lineno & .col_offset) 156 """{ 157 1 158 : 159 2 160 }""", 161 # ListComp 162 "[a for b in c if d]", 163 # GeneratorExp 164 "(a for b in c if d)", 165 # Yield - yield expressions can't work outside a function 166 # 167 # Compare 168 "1 < 2 < 3", 169 # Call 170 "f(1,2,c=3,*d,**e)", 171 # Num 172 "10", 173 # Str 174 "'string'", 175 # Attribute 176 "a.b", 177 # Subscript 178 "a[b:c]", 179 # Name 180 "v", 181 # List 182 "[1,2,3]", 183 # Empty list 184 "[]", 185 # Tuple 186 "1,2,3", 187 # Tuple 188 "(1,2,3)", 189 # Empty tuple 190 "()", 191 # Combination 192 "a.b.c.d(a.b[1:2])", 193 194] 195 196# TODO: expr_context, slice, boolop, operator, unaryop, cmpop, comprehension 197# excepthandler, arguments, keywords, alias 198 199class AST_Tests(unittest.TestCase): 200 201 def _assertTrueorder(self, ast_node, parent_pos): 202 if not isinstance(ast_node, ast.AST) or ast_node._fields is None: 203 return 204 if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)): 205 node_pos = (ast_node.lineno, ast_node.col_offset) 206 self.assertTrue(node_pos >= parent_pos) 207 parent_pos = (ast_node.lineno, ast_node.col_offset) 208 for name in ast_node._fields: 209 value = getattr(ast_node, name) 210 if isinstance(value, list): 211 for child in value: 212 self._assertTrueorder(child, parent_pos) 213 elif value is not None: 214 self._assertTrueorder(value, parent_pos) 215 216 def test_AST_objects(self): 217 x = ast.AST() 218 self.assertEqual(x._fields, ()) 219 x.foobar = 42 220 self.assertEqual(x.foobar, 42) 221 self.assertEqual(x.__dict__["foobar"], 42) 222 223 with self.assertRaises(AttributeError): 224 x.vararg 225 226 with self.assertRaises(TypeError): 227 # "_ast.AST constructor takes 0 positional arguments" 228 ast.AST(2) 229 230 def test_AST_garbage_collection(self): 231 class X: 232 pass 233 a = ast.AST() 234 a.x = X() 235 a.x.a = a 236 ref = weakref.ref(a.x) 237 del a 238 support.gc_collect() 239 self.assertIsNone(ref()) 240 241 def test_snippets(self): 242 for input, output, kind in ((exec_tests, exec_results, "exec"), 243 (single_tests, single_results, "single"), 244 (eval_tests, eval_results, "eval")): 245 for i, o in zip(input, output): 246 with self.subTest(action="parsing", input=i): 247 ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST) 248 self.assertEqual(to_tuple(ast_tree), o) 249 self._assertTrueorder(ast_tree, (0, 0)) 250 with self.subTest(action="compiling", input=i, kind=kind): 251 compile(ast_tree, "?", kind) 252 253 def test_slice(self): 254 slc = ast.parse("x[::]").body[0].value.slice 255 self.assertIsNone(slc.upper) 256 self.assertIsNone(slc.lower) 257 self.assertIsNone(slc.step) 258 259 def test_from_import(self): 260 im = ast.parse("from . import y").body[0] 261 self.assertIsNone(im.module) 262 263 def test_non_interned_future_from_ast(self): 264 mod = ast.parse("from __future__ import division") 265 self.assertIsInstance(mod.body[0], ast.ImportFrom) 266 mod.body[0].module = " __future__ ".strip() 267 compile(mod, "<test>", "exec") 268 269 def test_base_classes(self): 270 self.assertTrue(issubclass(ast.For, ast.stmt)) 271 self.assertTrue(issubclass(ast.Name, ast.expr)) 272 self.assertTrue(issubclass(ast.stmt, ast.AST)) 273 self.assertTrue(issubclass(ast.expr, ast.AST)) 274 self.assertTrue(issubclass(ast.comprehension, ast.AST)) 275 self.assertTrue(issubclass(ast.Gt, ast.AST)) 276 277 def test_field_attr_existence(self): 278 for name, item in ast.__dict__.items(): 279 if isinstance(item, type) and name != 'AST' and name[0].isupper(): 280 x = item() 281 if isinstance(x, ast.AST): 282 self.assertEqual(type(x._fields), tuple) 283 284 def test_arguments(self): 285 x = ast.arguments() 286 self.assertEqual(x._fields, ('args', 'vararg', 'kwonlyargs', 287 'kw_defaults', 'kwarg', 'defaults')) 288 289 with self.assertRaises(AttributeError): 290 x.vararg 291 292 x = ast.arguments(*range(1, 7)) 293 self.assertEqual(x.vararg, 2) 294 295 def test_field_attr_writable(self): 296 x = ast.Num() 297 # We can assign to _fields 298 x._fields = 666 299 self.assertEqual(x._fields, 666) 300 301 def test_classattrs(self): 302 x = ast.Num() 303 self.assertEqual(x._fields, ('n',)) 304 305 with self.assertRaises(AttributeError): 306 x.n 307 308 x = ast.Num(42) 309 self.assertEqual(x.n, 42) 310 311 with self.assertRaises(AttributeError): 312 x.lineno 313 314 with self.assertRaises(AttributeError): 315 x.foobar 316 317 x = ast.Num(lineno=2) 318 self.assertEqual(x.lineno, 2) 319 320 x = ast.Num(42, lineno=0) 321 self.assertEqual(x.lineno, 0) 322 self.assertEqual(x._fields, ('n',)) 323 self.assertEqual(x.n, 42) 324 325 self.assertRaises(TypeError, ast.Num, 1, 2) 326 self.assertRaises(TypeError, ast.Num, 1, 2, lineno=0) 327 328 def test_module(self): 329 body = [ast.Num(42)] 330 x = ast.Module(body) 331 self.assertEqual(x.body, body) 332 333 def test_nodeclasses(self): 334 # Zero arguments constructor explicitly allowed 335 x = ast.BinOp() 336 self.assertEqual(x._fields, ('left', 'op', 'right')) 337 338 # Random attribute allowed too 339 x.foobarbaz = 5 340 self.assertEqual(x.foobarbaz, 5) 341 342 n1 = ast.Num(1) 343 n3 = ast.Num(3) 344 addop = ast.Add() 345 x = ast.BinOp(n1, addop, n3) 346 self.assertEqual(x.left, n1) 347 self.assertEqual(x.op, addop) 348 self.assertEqual(x.right, n3) 349 350 x = ast.BinOp(1, 2, 3) 351 self.assertEqual(x.left, 1) 352 self.assertEqual(x.op, 2) 353 self.assertEqual(x.right, 3) 354 355 x = ast.BinOp(1, 2, 3, lineno=0) 356 self.assertEqual(x.left, 1) 357 self.assertEqual(x.op, 2) 358 self.assertEqual(x.right, 3) 359 self.assertEqual(x.lineno, 0) 360 361 # node raises exception when given too many arguments 362 self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4) 363 # node raises exception when given too many arguments 364 self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4, lineno=0) 365 366 # can set attributes through kwargs too 367 x = ast.BinOp(left=1, op=2, right=3, lineno=0) 368 self.assertEqual(x.left, 1) 369 self.assertEqual(x.op, 2) 370 self.assertEqual(x.right, 3) 371 self.assertEqual(x.lineno, 0) 372 373 # Random kwargs also allowed 374 x = ast.BinOp(1, 2, 3, foobarbaz=42) 375 self.assertEqual(x.foobarbaz, 42) 376 377 def test_no_fields(self): 378 # this used to fail because Sub._fields was None 379 x = ast.Sub() 380 self.assertEqual(x._fields, ()) 381 382 def test_pickling(self): 383 import pickle 384 mods = [pickle] 385 try: 386 import cPickle 387 mods.append(cPickle) 388 except ImportError: 389 pass 390 protocols = [0, 1, 2] 391 for mod in mods: 392 for protocol in protocols: 393 for ast in (compile(i, "?", "exec", 0x400) for i in exec_tests): 394 ast2 = mod.loads(mod.dumps(ast, protocol)) 395 self.assertEqual(to_tuple(ast2), to_tuple(ast)) 396 397 def test_invalid_sum(self): 398 pos = dict(lineno=2, col_offset=3) 399 m = ast.Module([ast.Expr(ast.expr(**pos), **pos)]) 400 with self.assertRaises(TypeError) as cm: 401 compile(m, "<test>", "exec") 402 self.assertIn("but got <_ast.expr", str(cm.exception)) 403 404 def test_invalid_identitifer(self): 405 m = ast.Module([ast.Expr(ast.Name(42, ast.Load()))]) 406 ast.fix_missing_locations(m) 407 with self.assertRaises(TypeError) as cm: 408 compile(m, "<test>", "exec") 409 self.assertIn("identifier must be of type str", str(cm.exception)) 410 411 def test_empty_yield_from(self): 412 # Issue 16546: yield from value is not optional. 413 empty_yield_from = ast.parse("def f():\n yield from g()") 414 empty_yield_from.body[0].body[0].value.value = None 415 with self.assertRaises(ValueError) as cm: 416 compile(empty_yield_from, "<test>", "exec") 417 self.assertIn("field value is required", str(cm.exception)) 418 419 @support.cpython_only 420 def test_issue31592(self): 421 # There shouldn't be an assertion failure in case of a bad 422 # unicodedata.normalize(). 423 import unicodedata 424 def bad_normalize(*args): 425 return None 426 with support.swap_attr(unicodedata, 'normalize', bad_normalize): 427 self.assertRaises(TypeError, ast.parse, '\u03D5') 428 429 430class ASTHelpers_Test(unittest.TestCase): 431 432 def test_parse(self): 433 a = ast.parse('foo(1 + 1)') 434 b = compile('foo(1 + 1)', '<unknown>', 'exec', ast.PyCF_ONLY_AST) 435 self.assertEqual(ast.dump(a), ast.dump(b)) 436 437 def test_parse_in_error(self): 438 try: 439 1/0 440 except Exception: 441 with self.assertRaises(SyntaxError) as e: 442 ast.literal_eval(r"'\U'") 443 self.assertIsNotNone(e.exception.__context__) 444 445 def test_dump(self): 446 node = ast.parse('spam(eggs, "and cheese")') 447 self.assertEqual(ast.dump(node), 448 "Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load()), " 449 "args=[Name(id='eggs', ctx=Load()), Str(s='and cheese')], " 450 "keywords=[]))])" 451 ) 452 self.assertEqual(ast.dump(node, annotate_fields=False), 453 "Module([Expr(Call(Name('spam', Load()), [Name('eggs', Load()), " 454 "Str('and cheese')], []))])" 455 ) 456 self.assertEqual(ast.dump(node, include_attributes=True), 457 "Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load(), " 458 "lineno=1, col_offset=0), args=[Name(id='eggs', ctx=Load(), " 459 "lineno=1, col_offset=5), Str(s='and cheese', lineno=1, " 460 "col_offset=11)], keywords=[], " 461 "lineno=1, col_offset=0), lineno=1, col_offset=0)])" 462 ) 463 464 def test_copy_location(self): 465 src = ast.parse('1 + 1', mode='eval') 466 src.body.right = ast.copy_location(ast.Num(2), src.body.right) 467 self.assertEqual(ast.dump(src, include_attributes=True), 468 'Expression(body=BinOp(left=Num(n=1, lineno=1, col_offset=0), ' 469 'op=Add(), right=Num(n=2, lineno=1, col_offset=4), lineno=1, ' 470 'col_offset=0))' 471 ) 472 473 def test_fix_missing_locations(self): 474 src = ast.parse('write("spam")') 475 src.body.append(ast.Expr(ast.Call(ast.Name('spam', ast.Load()), 476 [ast.Str('eggs')], []))) 477 self.assertEqual(src, ast.fix_missing_locations(src)) 478 self.assertEqual(ast.dump(src, include_attributes=True), 479 "Module(body=[Expr(value=Call(func=Name(id='write', ctx=Load(), " 480 "lineno=1, col_offset=0), args=[Str(s='spam', lineno=1, " 481 "col_offset=6)], keywords=[], " 482 "lineno=1, col_offset=0), lineno=1, col_offset=0), " 483 "Expr(value=Call(func=Name(id='spam', ctx=Load(), lineno=1, " 484 "col_offset=0), args=[Str(s='eggs', lineno=1, col_offset=0)], " 485 "keywords=[], lineno=1, " 486 "col_offset=0), lineno=1, col_offset=0)])" 487 ) 488 489 def test_increment_lineno(self): 490 src = ast.parse('1 + 1', mode='eval') 491 self.assertEqual(ast.increment_lineno(src, n=3), src) 492 self.assertEqual(ast.dump(src, include_attributes=True), 493 'Expression(body=BinOp(left=Num(n=1, lineno=4, col_offset=0), ' 494 'op=Add(), right=Num(n=1, lineno=4, col_offset=4), lineno=4, ' 495 'col_offset=0))' 496 ) 497 # issue10869: do not increment lineno of root twice 498 src = ast.parse('1 + 1', mode='eval') 499 self.assertEqual(ast.increment_lineno(src.body, n=3), src.body) 500 self.assertEqual(ast.dump(src, include_attributes=True), 501 'Expression(body=BinOp(left=Num(n=1, lineno=4, col_offset=0), ' 502 'op=Add(), right=Num(n=1, lineno=4, col_offset=4), lineno=4, ' 503 'col_offset=0))' 504 ) 505 506 def test_iter_fields(self): 507 node = ast.parse('foo()', mode='eval') 508 d = dict(ast.iter_fields(node.body)) 509 self.assertEqual(d.pop('func').id, 'foo') 510 self.assertEqual(d, {'keywords': [], 'args': []}) 511 512 def test_iter_child_nodes(self): 513 node = ast.parse("spam(23, 42, eggs='leek')", mode='eval') 514 self.assertEqual(len(list(ast.iter_child_nodes(node.body))), 4) 515 iterator = ast.iter_child_nodes(node.body) 516 self.assertEqual(next(iterator).id, 'spam') 517 self.assertEqual(next(iterator).n, 23) 518 self.assertEqual(next(iterator).n, 42) 519 self.assertEqual(ast.dump(next(iterator)), 520 "keyword(arg='eggs', value=Str(s='leek'))" 521 ) 522 523 def test_get_docstring(self): 524 node = ast.parse('"""line one\n line two"""') 525 self.assertEqual(ast.get_docstring(node), 526 'line one\nline two') 527 528 node = ast.parse('class foo:\n """line one\n line two"""') 529 self.assertEqual(ast.get_docstring(node.body[0]), 530 'line one\nline two') 531 532 node = ast.parse('def foo():\n """line one\n line two"""') 533 self.assertEqual(ast.get_docstring(node.body[0]), 534 'line one\nline two') 535 536 node = ast.parse('async def foo():\n """spam\n ham"""') 537 self.assertEqual(ast.get_docstring(node.body[0]), 'spam\nham') 538 539 def test_get_docstring_none(self): 540 self.assertIsNone(ast.get_docstring(ast.parse(''))) 541 node = ast.parse('x = "not docstring"') 542 self.assertIsNone(ast.get_docstring(node)) 543 node = ast.parse('def foo():\n pass') 544 self.assertIsNone(ast.get_docstring(node)) 545 546 node = ast.parse('class foo:\n pass') 547 self.assertIsNone(ast.get_docstring(node.body[0])) 548 node = ast.parse('class foo:\n x = "not docstring"') 549 self.assertIsNone(ast.get_docstring(node.body[0])) 550 node = ast.parse('class foo:\n def bar(self): pass') 551 self.assertIsNone(ast.get_docstring(node.body[0])) 552 553 node = ast.parse('def foo():\n pass') 554 self.assertIsNone(ast.get_docstring(node.body[0])) 555 node = ast.parse('def foo():\n x = "not docstring"') 556 self.assertIsNone(ast.get_docstring(node.body[0])) 557 558 node = ast.parse('async def foo():\n pass') 559 self.assertIsNone(ast.get_docstring(node.body[0])) 560 node = ast.parse('async def foo():\n x = "not docstring"') 561 self.assertIsNone(ast.get_docstring(node.body[0])) 562 563 def test_literal_eval(self): 564 self.assertEqual(ast.literal_eval('[1, 2, 3]'), [1, 2, 3]) 565 self.assertEqual(ast.literal_eval('{"foo": 42}'), {"foo": 42}) 566 self.assertEqual(ast.literal_eval('(True, False, None)'), (True, False, None)) 567 self.assertEqual(ast.literal_eval('{1, 2, 3}'), {1, 2, 3}) 568 self.assertEqual(ast.literal_eval('b"hi"'), b"hi") 569 self.assertRaises(ValueError, ast.literal_eval, 'foo()') 570 self.assertEqual(ast.literal_eval('6'), 6) 571 self.assertEqual(ast.literal_eval('+6'), 6) 572 self.assertEqual(ast.literal_eval('-6'), -6) 573 self.assertEqual(ast.literal_eval('3.25'), 3.25) 574 self.assertEqual(ast.literal_eval('+3.25'), 3.25) 575 self.assertEqual(ast.literal_eval('-3.25'), -3.25) 576 self.assertEqual(repr(ast.literal_eval('-0.0')), '-0.0') 577 self.assertRaises(ValueError, ast.literal_eval, '++6') 578 self.assertRaises(ValueError, ast.literal_eval, '+True') 579 self.assertRaises(ValueError, ast.literal_eval, '2+3') 580 581 def test_literal_eval_complex(self): 582 # Issue #4907 583 self.assertEqual(ast.literal_eval('6j'), 6j) 584 self.assertEqual(ast.literal_eval('-6j'), -6j) 585 self.assertEqual(ast.literal_eval('6.75j'), 6.75j) 586 self.assertEqual(ast.literal_eval('-6.75j'), -6.75j) 587 self.assertEqual(ast.literal_eval('3+6j'), 3+6j) 588 self.assertEqual(ast.literal_eval('-3+6j'), -3+6j) 589 self.assertEqual(ast.literal_eval('3-6j'), 3-6j) 590 self.assertEqual(ast.literal_eval('-3-6j'), -3-6j) 591 self.assertEqual(ast.literal_eval('3.25+6.75j'), 3.25+6.75j) 592 self.assertEqual(ast.literal_eval('-3.25+6.75j'), -3.25+6.75j) 593 self.assertEqual(ast.literal_eval('3.25-6.75j'), 3.25-6.75j) 594 self.assertEqual(ast.literal_eval('-3.25-6.75j'), -3.25-6.75j) 595 self.assertEqual(ast.literal_eval('(3+6j)'), 3+6j) 596 self.assertRaises(ValueError, ast.literal_eval, '-6j+3') 597 self.assertRaises(ValueError, ast.literal_eval, '-6j+3j') 598 self.assertRaises(ValueError, ast.literal_eval, '3+-6j') 599 self.assertRaises(ValueError, ast.literal_eval, '3+(0+6j)') 600 self.assertRaises(ValueError, ast.literal_eval, '-(3+6j)') 601 602 def test_bad_integer(self): 603 # issue13436: Bad error message with invalid numeric values 604 body = [ast.ImportFrom(module='time', 605 names=[ast.alias(name='sleep')], 606 level=None, 607 lineno=None, col_offset=None)] 608 mod = ast.Module(body) 609 with self.assertRaises(ValueError) as cm: 610 compile(mod, 'test', 'exec') 611 self.assertIn("invalid integer value: None", str(cm.exception)) 612 613 def test_level_as_none(self): 614 body = [ast.ImportFrom(module='time', 615 names=[ast.alias(name='sleep')], 616 level=None, 617 lineno=0, col_offset=0)] 618 mod = ast.Module(body) 619 code = compile(mod, 'test', 'exec') 620 ns = {} 621 exec(code, ns) 622 self.assertIn('sleep', ns) 623 624 625class ASTValidatorTests(unittest.TestCase): 626 627 def mod(self, mod, msg=None, mode="exec", *, exc=ValueError): 628 mod.lineno = mod.col_offset = 0 629 ast.fix_missing_locations(mod) 630 with self.assertRaises(exc) as cm: 631 compile(mod, "<test>", mode) 632 if msg is not None: 633 self.assertIn(msg, str(cm.exception)) 634 635 def expr(self, node, msg=None, *, exc=ValueError): 636 mod = ast.Module([ast.Expr(node)]) 637 self.mod(mod, msg, exc=exc) 638 639 def stmt(self, stmt, msg=None): 640 mod = ast.Module([stmt]) 641 self.mod(mod, msg) 642 643 def test_module(self): 644 m = ast.Interactive([ast.Expr(ast.Name("x", ast.Store()))]) 645 self.mod(m, "must have Load context", "single") 646 m = ast.Expression(ast.Name("x", ast.Store())) 647 self.mod(m, "must have Load context", "eval") 648 649 def _check_arguments(self, fac, check): 650 def arguments(args=None, vararg=None, 651 kwonlyargs=None, kwarg=None, 652 defaults=None, kw_defaults=None): 653 if args is None: 654 args = [] 655 if kwonlyargs is None: 656 kwonlyargs = [] 657 if defaults is None: 658 defaults = [] 659 if kw_defaults is None: 660 kw_defaults = [] 661 args = ast.arguments(args, vararg, kwonlyargs, kw_defaults, 662 kwarg, defaults) 663 return fac(args) 664 args = [ast.arg("x", ast.Name("x", ast.Store()))] 665 check(arguments(args=args), "must have Load context") 666 check(arguments(kwonlyargs=args), "must have Load context") 667 check(arguments(defaults=[ast.Num(3)]), 668 "more positional defaults than args") 669 check(arguments(kw_defaults=[ast.Num(4)]), 670 "length of kwonlyargs is not the same as kw_defaults") 671 args = [ast.arg("x", ast.Name("x", ast.Load()))] 672 check(arguments(args=args, defaults=[ast.Name("x", ast.Store())]), 673 "must have Load context") 674 args = [ast.arg("a", ast.Name("x", ast.Load())), 675 ast.arg("b", ast.Name("y", ast.Load()))] 676 check(arguments(kwonlyargs=args, 677 kw_defaults=[None, ast.Name("x", ast.Store())]), 678 "must have Load context") 679 680 def test_funcdef(self): 681 a = ast.arguments([], None, [], [], None, []) 682 f = ast.FunctionDef("x", a, [], [], None) 683 self.stmt(f, "empty body on FunctionDef") 684 f = ast.FunctionDef("x", a, [ast.Pass()], [ast.Name("x", ast.Store())], 685 None) 686 self.stmt(f, "must have Load context") 687 f = ast.FunctionDef("x", a, [ast.Pass()], [], 688 ast.Name("x", ast.Store())) 689 self.stmt(f, "must have Load context") 690 def fac(args): 691 return ast.FunctionDef("x", args, [ast.Pass()], [], None) 692 self._check_arguments(fac, self.stmt) 693 694 def test_classdef(self): 695 def cls(bases=None, keywords=None, body=None, decorator_list=None): 696 if bases is None: 697 bases = [] 698 if keywords is None: 699 keywords = [] 700 if body is None: 701 body = [ast.Pass()] 702 if decorator_list is None: 703 decorator_list = [] 704 return ast.ClassDef("myclass", bases, keywords, 705 body, decorator_list) 706 self.stmt(cls(bases=[ast.Name("x", ast.Store())]), 707 "must have Load context") 708 self.stmt(cls(keywords=[ast.keyword("x", ast.Name("x", ast.Store()))]), 709 "must have Load context") 710 self.stmt(cls(body=[]), "empty body on ClassDef") 711 self.stmt(cls(body=[None]), "None disallowed") 712 self.stmt(cls(decorator_list=[ast.Name("x", ast.Store())]), 713 "must have Load context") 714 715 def test_delete(self): 716 self.stmt(ast.Delete([]), "empty targets on Delete") 717 self.stmt(ast.Delete([None]), "None disallowed") 718 self.stmt(ast.Delete([ast.Name("x", ast.Load())]), 719 "must have Del context") 720 721 def test_assign(self): 722 self.stmt(ast.Assign([], ast.Num(3)), "empty targets on Assign") 723 self.stmt(ast.Assign([None], ast.Num(3)), "None disallowed") 724 self.stmt(ast.Assign([ast.Name("x", ast.Load())], ast.Num(3)), 725 "must have Store context") 726 self.stmt(ast.Assign([ast.Name("x", ast.Store())], 727 ast.Name("y", ast.Store())), 728 "must have Load context") 729 730 def test_augassign(self): 731 aug = ast.AugAssign(ast.Name("x", ast.Load()), ast.Add(), 732 ast.Name("y", ast.Load())) 733 self.stmt(aug, "must have Store context") 734 aug = ast.AugAssign(ast.Name("x", ast.Store()), ast.Add(), 735 ast.Name("y", ast.Store())) 736 self.stmt(aug, "must have Load context") 737 738 def test_for(self): 739 x = ast.Name("x", ast.Store()) 740 y = ast.Name("y", ast.Load()) 741 p = ast.Pass() 742 self.stmt(ast.For(x, y, [], []), "empty body on For") 743 self.stmt(ast.For(ast.Name("x", ast.Load()), y, [p], []), 744 "must have Store context") 745 self.stmt(ast.For(x, ast.Name("y", ast.Store()), [p], []), 746 "must have Load context") 747 e = ast.Expr(ast.Name("x", ast.Store())) 748 self.stmt(ast.For(x, y, [e], []), "must have Load context") 749 self.stmt(ast.For(x, y, [p], [e]), "must have Load context") 750 751 def test_while(self): 752 self.stmt(ast.While(ast.Num(3), [], []), "empty body on While") 753 self.stmt(ast.While(ast.Name("x", ast.Store()), [ast.Pass()], []), 754 "must have Load context") 755 self.stmt(ast.While(ast.Num(3), [ast.Pass()], 756 [ast.Expr(ast.Name("x", ast.Store()))]), 757 "must have Load context") 758 759 def test_if(self): 760 self.stmt(ast.If(ast.Num(3), [], []), "empty body on If") 761 i = ast.If(ast.Name("x", ast.Store()), [ast.Pass()], []) 762 self.stmt(i, "must have Load context") 763 i = ast.If(ast.Num(3), [ast.Expr(ast.Name("x", ast.Store()))], []) 764 self.stmt(i, "must have Load context") 765 i = ast.If(ast.Num(3), [ast.Pass()], 766 [ast.Expr(ast.Name("x", ast.Store()))]) 767 self.stmt(i, "must have Load context") 768 769 def test_with(self): 770 p = ast.Pass() 771 self.stmt(ast.With([], [p]), "empty items on With") 772 i = ast.withitem(ast.Num(3), None) 773 self.stmt(ast.With([i], []), "empty body on With") 774 i = ast.withitem(ast.Name("x", ast.Store()), None) 775 self.stmt(ast.With([i], [p]), "must have Load context") 776 i = ast.withitem(ast.Num(3), ast.Name("x", ast.Load())) 777 self.stmt(ast.With([i], [p]), "must have Store context") 778 779 def test_raise(self): 780 r = ast.Raise(None, ast.Num(3)) 781 self.stmt(r, "Raise with cause but no exception") 782 r = ast.Raise(ast.Name("x", ast.Store()), None) 783 self.stmt(r, "must have Load context") 784 r = ast.Raise(ast.Num(4), ast.Name("x", ast.Store())) 785 self.stmt(r, "must have Load context") 786 787 def test_try(self): 788 p = ast.Pass() 789 t = ast.Try([], [], [], [p]) 790 self.stmt(t, "empty body on Try") 791 t = ast.Try([ast.Expr(ast.Name("x", ast.Store()))], [], [], [p]) 792 self.stmt(t, "must have Load context") 793 t = ast.Try([p], [], [], []) 794 self.stmt(t, "Try has neither except handlers nor finalbody") 795 t = ast.Try([p], [], [p], [p]) 796 self.stmt(t, "Try has orelse but no except handlers") 797 t = ast.Try([p], [ast.ExceptHandler(None, "x", [])], [], []) 798 self.stmt(t, "empty body on ExceptHandler") 799 e = [ast.ExceptHandler(ast.Name("x", ast.Store()), "y", [p])] 800 self.stmt(ast.Try([p], e, [], []), "must have Load context") 801 e = [ast.ExceptHandler(None, "x", [p])] 802 t = ast.Try([p], e, [ast.Expr(ast.Name("x", ast.Store()))], [p]) 803 self.stmt(t, "must have Load context") 804 t = ast.Try([p], e, [p], [ast.Expr(ast.Name("x", ast.Store()))]) 805 self.stmt(t, "must have Load context") 806 807 def test_assert(self): 808 self.stmt(ast.Assert(ast.Name("x", ast.Store()), None), 809 "must have Load context") 810 assrt = ast.Assert(ast.Name("x", ast.Load()), 811 ast.Name("y", ast.Store())) 812 self.stmt(assrt, "must have Load context") 813 814 def test_import(self): 815 self.stmt(ast.Import([]), "empty names on Import") 816 817 def test_importfrom(self): 818 imp = ast.ImportFrom(None, [ast.alias("x", None)], -42) 819 self.stmt(imp, "Negative ImportFrom level") 820 self.stmt(ast.ImportFrom(None, [], 0), "empty names on ImportFrom") 821 822 def test_global(self): 823 self.stmt(ast.Global([]), "empty names on Global") 824 825 def test_nonlocal(self): 826 self.stmt(ast.Nonlocal([]), "empty names on Nonlocal") 827 828 def test_expr(self): 829 e = ast.Expr(ast.Name("x", ast.Store())) 830 self.stmt(e, "must have Load context") 831 832 def test_boolop(self): 833 b = ast.BoolOp(ast.And(), []) 834 self.expr(b, "less than 2 values") 835 b = ast.BoolOp(ast.And(), [ast.Num(3)]) 836 self.expr(b, "less than 2 values") 837 b = ast.BoolOp(ast.And(), [ast.Num(4), None]) 838 self.expr(b, "None disallowed") 839 b = ast.BoolOp(ast.And(), [ast.Num(4), ast.Name("x", ast.Store())]) 840 self.expr(b, "must have Load context") 841 842 def test_unaryop(self): 843 u = ast.UnaryOp(ast.Not(), ast.Name("x", ast.Store())) 844 self.expr(u, "must have Load context") 845 846 def test_lambda(self): 847 a = ast.arguments([], None, [], [], None, []) 848 self.expr(ast.Lambda(a, ast.Name("x", ast.Store())), 849 "must have Load context") 850 def fac(args): 851 return ast.Lambda(args, ast.Name("x", ast.Load())) 852 self._check_arguments(fac, self.expr) 853 854 def test_ifexp(self): 855 l = ast.Name("x", ast.Load()) 856 s = ast.Name("y", ast.Store()) 857 for args in (s, l, l), (l, s, l), (l, l, s): 858 self.expr(ast.IfExp(*args), "must have Load context") 859 860 def test_dict(self): 861 d = ast.Dict([], [ast.Name("x", ast.Load())]) 862 self.expr(d, "same number of keys as values") 863 d = ast.Dict([ast.Name("x", ast.Load())], [None]) 864 self.expr(d, "None disallowed") 865 866 def test_set(self): 867 self.expr(ast.Set([None]), "None disallowed") 868 s = ast.Set([ast.Name("x", ast.Store())]) 869 self.expr(s, "must have Load context") 870 871 def _check_comprehension(self, fac): 872 self.expr(fac([]), "comprehension with no generators") 873 g = ast.comprehension(ast.Name("x", ast.Load()), 874 ast.Name("x", ast.Load()), [], 0) 875 self.expr(fac([g]), "must have Store context") 876 g = ast.comprehension(ast.Name("x", ast.Store()), 877 ast.Name("x", ast.Store()), [], 0) 878 self.expr(fac([g]), "must have Load context") 879 x = ast.Name("x", ast.Store()) 880 y = ast.Name("y", ast.Load()) 881 g = ast.comprehension(x, y, [None], 0) 882 self.expr(fac([g]), "None disallowed") 883 g = ast.comprehension(x, y, [ast.Name("x", ast.Store())], 0) 884 self.expr(fac([g]), "must have Load context") 885 886 def _simple_comp(self, fac): 887 g = ast.comprehension(ast.Name("x", ast.Store()), 888 ast.Name("x", ast.Load()), [], 0) 889 self.expr(fac(ast.Name("x", ast.Store()), [g]), 890 "must have Load context") 891 def wrap(gens): 892 return fac(ast.Name("x", ast.Store()), gens) 893 self._check_comprehension(wrap) 894 895 def test_listcomp(self): 896 self._simple_comp(ast.ListComp) 897 898 def test_setcomp(self): 899 self._simple_comp(ast.SetComp) 900 901 def test_generatorexp(self): 902 self._simple_comp(ast.GeneratorExp) 903 904 def test_dictcomp(self): 905 g = ast.comprehension(ast.Name("y", ast.Store()), 906 ast.Name("p", ast.Load()), [], 0) 907 c = ast.DictComp(ast.Name("x", ast.Store()), 908 ast.Name("y", ast.Load()), [g]) 909 self.expr(c, "must have Load context") 910 c = ast.DictComp(ast.Name("x", ast.Load()), 911 ast.Name("y", ast.Store()), [g]) 912 self.expr(c, "must have Load context") 913 def factory(comps): 914 k = ast.Name("x", ast.Load()) 915 v = ast.Name("y", ast.Load()) 916 return ast.DictComp(k, v, comps) 917 self._check_comprehension(factory) 918 919 def test_yield(self): 920 self.expr(ast.Yield(ast.Name("x", ast.Store())), "must have Load") 921 self.expr(ast.YieldFrom(ast.Name("x", ast.Store())), "must have Load") 922 923 def test_compare(self): 924 left = ast.Name("x", ast.Load()) 925 comp = ast.Compare(left, [ast.In()], []) 926 self.expr(comp, "no comparators") 927 comp = ast.Compare(left, [ast.In()], [ast.Num(4), ast.Num(5)]) 928 self.expr(comp, "different number of comparators and operands") 929 comp = ast.Compare(ast.Num("blah"), [ast.In()], [left]) 930 self.expr(comp, "non-numeric", exc=TypeError) 931 comp = ast.Compare(left, [ast.In()], [ast.Num("blah")]) 932 self.expr(comp, "non-numeric", exc=TypeError) 933 934 def test_call(self): 935 func = ast.Name("x", ast.Load()) 936 args = [ast.Name("y", ast.Load())] 937 keywords = [ast.keyword("w", ast.Name("z", ast.Load()))] 938 call = ast.Call(ast.Name("x", ast.Store()), args, keywords) 939 self.expr(call, "must have Load context") 940 call = ast.Call(func, [None], keywords) 941 self.expr(call, "None disallowed") 942 bad_keywords = [ast.keyword("w", ast.Name("z", ast.Store()))] 943 call = ast.Call(func, args, bad_keywords) 944 self.expr(call, "must have Load context") 945 946 def test_num(self): 947 class subint(int): 948 pass 949 class subfloat(float): 950 pass 951 class subcomplex(complex): 952 pass 953 for obj in "0", "hello", subint(), subfloat(), subcomplex(): 954 self.expr(ast.Num(obj), "non-numeric", exc=TypeError) 955 956 def test_attribute(self): 957 attr = ast.Attribute(ast.Name("x", ast.Store()), "y", ast.Load()) 958 self.expr(attr, "must have Load context") 959 960 def test_subscript(self): 961 sub = ast.Subscript(ast.Name("x", ast.Store()), ast.Index(ast.Num(3)), 962 ast.Load()) 963 self.expr(sub, "must have Load context") 964 x = ast.Name("x", ast.Load()) 965 sub = ast.Subscript(x, ast.Index(ast.Name("y", ast.Store())), 966 ast.Load()) 967 self.expr(sub, "must have Load context") 968 s = ast.Name("x", ast.Store()) 969 for args in (s, None, None), (None, s, None), (None, None, s): 970 sl = ast.Slice(*args) 971 self.expr(ast.Subscript(x, sl, ast.Load()), 972 "must have Load context") 973 sl = ast.ExtSlice([]) 974 self.expr(ast.Subscript(x, sl, ast.Load()), "empty dims on ExtSlice") 975 sl = ast.ExtSlice([ast.Index(s)]) 976 self.expr(ast.Subscript(x, sl, ast.Load()), "must have Load context") 977 978 def test_starred(self): 979 left = ast.List([ast.Starred(ast.Name("x", ast.Load()), ast.Store())], 980 ast.Store()) 981 assign = ast.Assign([left], ast.Num(4)) 982 self.stmt(assign, "must have Store context") 983 984 def _sequence(self, fac): 985 self.expr(fac([None], ast.Load()), "None disallowed") 986 self.expr(fac([ast.Name("x", ast.Store())], ast.Load()), 987 "must have Load context") 988 989 def test_list(self): 990 self._sequence(ast.List) 991 992 def test_tuple(self): 993 self._sequence(ast.Tuple) 994 995 def test_nameconstant(self): 996 self.expr(ast.NameConstant(4), "singleton must be True, False, or None") 997 998 def test_stdlib_validates(self): 999 stdlib = os.path.dirname(ast.__file__) 1000 tests = [fn for fn in os.listdir(stdlib) if fn.endswith(".py")] 1001 tests.extend(["test/test_grammar.py", "test/test_unpack_ex.py"]) 1002 for module in tests: 1003 fn = os.path.join(stdlib, module) 1004 with open(fn, "r", encoding="utf-8") as fp: 1005 source = fp.read() 1006 mod = ast.parse(source, fn) 1007 compile(mod, fn, "exec") 1008 1009 1010class ConstantTests(unittest.TestCase): 1011 """Tests on the ast.Constant node type.""" 1012 1013 def compile_constant(self, value): 1014 tree = ast.parse("x = 123") 1015 1016 node = tree.body[0].value 1017 new_node = ast.Constant(value=value) 1018 ast.copy_location(new_node, node) 1019 tree.body[0].value = new_node 1020 1021 code = compile(tree, "<string>", "exec") 1022 1023 ns = {} 1024 exec(code, ns) 1025 return ns['x'] 1026 1027 def test_validation(self): 1028 with self.assertRaises(TypeError) as cm: 1029 self.compile_constant([1, 2, 3]) 1030 self.assertEqual(str(cm.exception), 1031 "got an invalid type in Constant: list") 1032 1033 def test_singletons(self): 1034 for const in (None, False, True, Ellipsis, b'', frozenset()): 1035 with self.subTest(const=const): 1036 value = self.compile_constant(const) 1037 self.assertIs(value, const) 1038 1039 def test_values(self): 1040 nested_tuple = (1,) 1041 nested_frozenset = frozenset({1}) 1042 for level in range(3): 1043 nested_tuple = (nested_tuple, 2) 1044 nested_frozenset = frozenset({nested_frozenset, 2}) 1045 values = (123, 123.0, 123j, 1046 "unicode", b'bytes', 1047 tuple("tuple"), frozenset("frozenset"), 1048 nested_tuple, nested_frozenset) 1049 for value in values: 1050 with self.subTest(value=value): 1051 result = self.compile_constant(value) 1052 self.assertEqual(result, value) 1053 1054 def test_assign_to_constant(self): 1055 tree = ast.parse("x = 1") 1056 1057 target = tree.body[0].targets[0] 1058 new_target = ast.Constant(value=1) 1059 ast.copy_location(new_target, target) 1060 tree.body[0].targets[0] = new_target 1061 1062 with self.assertRaises(ValueError) as cm: 1063 compile(tree, "string", "exec") 1064 self.assertEqual(str(cm.exception), 1065 "expression which can't be assigned " 1066 "to in Store context") 1067 1068 def test_get_docstring(self): 1069 tree = ast.parse("'docstring'\nx = 1") 1070 self.assertEqual(ast.get_docstring(tree), 'docstring') 1071 1072 def get_load_const(self, tree): 1073 # Compile to bytecode, disassemble and get parameter of LOAD_CONST 1074 # instructions 1075 co = compile(tree, '<string>', 'exec') 1076 consts = [] 1077 for instr in dis.get_instructions(co): 1078 if instr.opname == 'LOAD_CONST': 1079 consts.append(instr.argval) 1080 return consts 1081 1082 @support.cpython_only 1083 def test_load_const(self): 1084 consts = [None, 1085 True, False, 1086 124, 1087 2.0, 1088 3j, 1089 "unicode", 1090 b'bytes', 1091 (1, 2, 3)] 1092 1093 code = '\n'.join(['x={!r}'.format(const) for const in consts]) 1094 code += '\nx = ...' 1095 consts.extend((Ellipsis, None)) 1096 1097 tree = ast.parse(code) 1098 self.assertEqual(self.get_load_const(tree), 1099 consts) 1100 1101 # Replace expression nodes with constants 1102 for assign, const in zip(tree.body, consts): 1103 assert isinstance(assign, ast.Assign), ast.dump(assign) 1104 new_node = ast.Constant(value=const) 1105 ast.copy_location(new_node, assign.value) 1106 assign.value = new_node 1107 1108 self.assertEqual(self.get_load_const(tree), 1109 consts) 1110 1111 def test_literal_eval(self): 1112 tree = ast.parse("1 + 2") 1113 binop = tree.body[0].value 1114 1115 new_left = ast.Constant(value=10) 1116 ast.copy_location(new_left, binop.left) 1117 binop.left = new_left 1118 1119 new_right = ast.Constant(value=20j) 1120 ast.copy_location(new_right, binop.right) 1121 binop.right = new_right 1122 1123 self.assertEqual(ast.literal_eval(binop), 10+20j) 1124 1125 1126def main(): 1127 if __name__ != '__main__': 1128 return 1129 if sys.argv[1:] == ['-g']: 1130 for statements, kind in ((exec_tests, "exec"), (single_tests, "single"), 1131 (eval_tests, "eval")): 1132 print(kind+"_results = [") 1133 for statement in statements: 1134 tree = ast.parse(statement, "?", kind) 1135 print("%r," % (to_tuple(tree),)) 1136 print("]") 1137 print("main()") 1138 raise SystemExit 1139 unittest.main() 1140 1141#### EVERYTHING BELOW IS GENERATED ##### 1142exec_results = [ 1143('Module', [('Expr', (1, 0), ('NameConstant', (1, 0), None))]), 1144('Module', [('Expr', (1, 0), ('Str', (1, 0), 'module docstring'))]), 1145('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('Pass', (1, 9))], [], None)]), 1146('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('Expr', (1, 9), ('Str', (1, 9), 'function docstring'))], [], None)]), 1147('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [('arg', (1, 6), 'a', None)], None, [], [], None, []), [('Pass', (1, 10))], [], None)]), 1148('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [('arg', (1, 6), 'a', None)], None, [], [], None, [('Num', (1, 8), 0)]), [('Pass', (1, 12))], [], None)]), 1149('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], ('arg', (1, 7), 'args', None), [], [], None, []), [('Pass', (1, 14))], [], None)]), 1150('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], ('arg', (1, 8), 'kwargs', None), []), [('Pass', (1, 17))], [], None)]), 1151('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [('arg', (1, 6), 'a', None), ('arg', (1, 9), 'b', None), ('arg', (1, 14), 'c', None), ('arg', (1, 22), 'd', None), ('arg', (1, 28), 'e', None)], ('arg', (1, 35), 'args', None), [('arg', (1, 41), 'f', None)], [('Num', (1, 43), 42)], ('arg', (1, 49), 'kwargs', None), [('Num', (1, 11), 1), ('NameConstant', (1, 16), None), ('List', (1, 24), [], ('Load',)), ('Dict', (1, 30), [], [])]), [('Expr', (1, 58), ('Str', (1, 58), 'doc for f()'))], [], None)]), 1152('Module', [('ClassDef', (1, 0), 'C', [], [], [('Pass', (1, 8))], [])]), 1153('Module', [('ClassDef', (1, 0), 'C', [], [], [('Expr', (1, 9), ('Str', (1, 9), 'docstring for class C'))], [])]), 1154('Module', [('ClassDef', (1, 0), 'C', [('Name', (1, 8), 'object', ('Load',))], [], [('Pass', (1, 17))], [])]), 1155('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('Return', (1, 8), ('Num', (1, 15), 1))], [], None)]), 1156('Module', [('Delete', (1, 0), [('Name', (1, 4), 'v', ('Del',))])]), 1157('Module', [('Assign', (1, 0), [('Name', (1, 0), 'v', ('Store',))], ('Num', (1, 4), 1))]), 1158('Module', [('AugAssign', (1, 0), ('Name', (1, 0), 'v', ('Store',)), ('Add',), ('Num', (1, 5), 1))]), 1159('Module', [('For', (1, 0), ('Name', (1, 4), 'v', ('Store',)), ('Name', (1, 9), 'v', ('Load',)), [('Pass', (1, 11))], [])]), 1160('Module', [('While', (1, 0), ('Name', (1, 6), 'v', ('Load',)), [('Pass', (1, 8))], [])]), 1161('Module', [('If', (1, 0), ('Name', (1, 3), 'v', ('Load',)), [('Pass', (1, 5))], [])]), 1162('Module', [('With', (1, 0), [('withitem', ('Name', (1, 5), 'x', ('Load',)), ('Name', (1, 10), 'y', ('Store',)))], [('Pass', (1, 13))])]), 1163('Module', [('With', (1, 0), [('withitem', ('Name', (1, 5), 'x', ('Load',)), ('Name', (1, 10), 'y', ('Store',))), ('withitem', ('Name', (1, 13), 'z', ('Load',)), ('Name', (1, 18), 'q', ('Store',)))], [('Pass', (1, 21))])]), 1164('Module', [('Raise', (1, 0), ('Call', (1, 6), ('Name', (1, 6), 'Exception', ('Load',)), [('Str', (1, 16), 'string')], []), None)]), 1165('Module', [('Try', (1, 0), [('Pass', (2, 2))], [('ExceptHandler', (3, 0), ('Name', (3, 7), 'Exception', ('Load',)), None, [('Pass', (4, 2))])], [], [])]), 1166('Module', [('Try', (1, 0), [('Pass', (2, 2))], [], [], [('Pass', (4, 2))])]), 1167('Module', [('Assert', (1, 0), ('Name', (1, 7), 'v', ('Load',)), None)]), 1168('Module', [('Import', (1, 0), [('alias', 'sys', None)])]), 1169('Module', [('ImportFrom', (1, 0), 'sys', [('alias', 'v', None)], 0)]), 1170('Module', [('Global', (1, 0), ['v'])]), 1171('Module', [('Expr', (1, 0), ('Num', (1, 0), 1))]), 1172('Module', [('Pass', (1, 0))]), 1173('Module', [('For', (1, 0), ('Name', (1, 4), 'v', ('Store',)), ('Name', (1, 9), 'v', ('Load',)), [('Break', (1, 11))], [])]), 1174('Module', [('For', (1, 0), ('Name', (1, 4), 'v', ('Store',)), ('Name', (1, 9), 'v', ('Load',)), [('Continue', (1, 11))], [])]), 1175('Module', [('For', (1, 0), ('Tuple', (1, 4), [('Name', (1, 4), 'a', ('Store',)), ('Name', (1, 6), 'b', ('Store',))], ('Store',)), ('Name', (1, 11), 'c', ('Load',)), [('Pass', (1, 14))], [])]), 1176('Module', [('Expr', (1, 0), ('ListComp', (1, 1), ('Tuple', (1, 2), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'a', ('Store',)), ('Name', (1, 13), 'b', ('Store',))], ('Store',)), ('Name', (1, 18), 'c', ('Load',)), [], 0)]))]), 1177('Module', [('Expr', (1, 0), ('GeneratorExp', (1, 1), ('Tuple', (1, 2), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'a', ('Store',)), ('Name', (1, 13), 'b', ('Store',))], ('Store',)), ('Name', (1, 18), 'c', ('Load',)), [], 0)]))]), 1178('Module', [('Expr', (1, 0), ('GeneratorExp', (1, 1), ('Tuple', (1, 2), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 12), [('Name', (1, 12), 'a', ('Store',)), ('Name', (1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 20), 'c', ('Load',)), [], 0)]))]), 1179('Module', [('Expr', (1, 0), ('GeneratorExp', (2, 4), ('Tuple', (3, 4), [('Name', (3, 4), 'Aa', ('Load',)), ('Name', (5, 7), 'Bb', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (8, 4), [('Name', (8, 4), 'Aa', ('Store',)), ('Name', (10, 4), 'Bb', ('Store',))], ('Store',)), ('Name', (10, 10), 'Cc', ('Load',)), [], 0)]))]), 1180('Module', [('Expr', (1, 0), ('DictComp', (1, 0), ('Name', (1, 1), 'a', ('Load',)), ('Name', (1, 5), 'b', ('Load',)), [('comprehension', ('Name', (1, 11), 'w', ('Store',)), ('Name', (1, 16), 'x', ('Load',)), [], 0), ('comprehension', ('Name', (1, 22), 'm', ('Store',)), ('Name', (1, 27), 'p', ('Load',)), [('Name', (1, 32), 'g', ('Load',))], 0)]))]), 1181('Module', [('Expr', (1, 0), ('DictComp', (1, 0), ('Name', (1, 1), 'a', ('Load',)), ('Name', (1, 5), 'b', ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'v', ('Store',)), ('Name', (1, 13), 'w', ('Store',))], ('Store',)), ('Name', (1, 18), 'x', ('Load',)), [], 0)]))]), 1182('Module', [('Expr', (1, 0), ('SetComp', (1, 0), ('Name', (1, 1), 'r', ('Load',)), [('comprehension', ('Name', (1, 7), 'l', ('Store',)), ('Name', (1, 12), 'x', ('Load',)), [('Name', (1, 17), 'g', ('Load',))], 0)]))]), 1183('Module', [('Expr', (1, 0), ('SetComp', (1, 0), ('Name', (1, 1), 'r', ('Load',)), [('comprehension', ('Tuple', (1, 7), [('Name', (1, 7), 'l', ('Store',)), ('Name', (1, 9), 'm', ('Store',))], ('Store',)), ('Name', (1, 14), 'x', ('Load',)), [], 0)]))]), 1184('Module', [('AsyncFunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('Expr', (2, 1), ('Str', (2, 1), 'async function')), ('Expr', (3, 1), ('Await', (3, 1), ('Call', (3, 7), ('Name', (3, 7), 'something', ('Load',)), [], [])))], [], None)]), 1185('Module', [('AsyncFunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('AsyncFor', (2, 1), ('Name', (2, 11), 'e', ('Store',)), ('Name', (2, 16), 'i', ('Load',)), [('Expr', (2, 19), ('Num', (2, 19), 1))], [('Expr', (3, 7), ('Num', (3, 7), 2))])], [], None)]), 1186('Module', [('AsyncFunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('AsyncWith', (2, 1), [('withitem', ('Name', (2, 12), 'a', ('Load',)), ('Name', (2, 17), 'b', ('Store',)))], [('Expr', (2, 20), ('Num', (2, 20), 1))])], [], None)]), 1187('Module', [('Expr', (1, 0), ('Dict', (1, 0), [None, ('Num', (1, 10), 2)], [('Dict', (1, 3), [('Num', (1, 4), 1)], [('Num', (1, 6), 2)]), ('Num', (1, 12), 3)]))]), 1188('Module', [('Expr', (1, 0), ('Set', (1, 0), [('Starred', (1, 1), ('Set', (1, 2), [('Num', (1, 3), 1), ('Num', (1, 6), 2)]), ('Load',)), ('Num', (1, 10), 3)]))]), 1189('Module', [('AsyncFunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('Expr', (2, 1), ('ListComp', (2, 2), ('Name', (2, 2), 'i', ('Load',)), [('comprehension', ('Name', (2, 14), 'b', ('Store',)), ('Name', (2, 19), 'c', ('Load',)), [], 1)]))], [], None)]), 1190] 1191single_results = [ 1192('Interactive', [('Expr', (1, 0), ('BinOp', (1, 0), ('Num', (1, 0), 1), ('Add',), ('Num', (1, 2), 2)))]), 1193] 1194eval_results = [ 1195('Expression', ('NameConstant', (1, 0), None)), 1196('Expression', ('BoolOp', (1, 0), ('And',), [('Name', (1, 0), 'a', ('Load',)), ('Name', (1, 6), 'b', ('Load',))])), 1197('Expression', ('BinOp', (1, 0), ('Name', (1, 0), 'a', ('Load',)), ('Add',), ('Name', (1, 4), 'b', ('Load',)))), 1198('Expression', ('UnaryOp', (1, 0), ('Not',), ('Name', (1, 4), 'v', ('Load',)))), 1199('Expression', ('Lambda', (1, 0), ('arguments', [], None, [], [], None, []), ('NameConstant', (1, 7), None))), 1200('Expression', ('Dict', (1, 0), [('Num', (1, 2), 1)], [('Num', (1, 4), 2)])), 1201('Expression', ('Dict', (1, 0), [], [])), 1202('Expression', ('Set', (1, 0), [('NameConstant', (1, 1), None)])), 1203('Expression', ('Dict', (1, 0), [('Num', (2, 6), 1)], [('Num', (4, 10), 2)])), 1204('Expression', ('ListComp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))], 0)])), 1205('Expression', ('GeneratorExp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))], 0)])), 1206('Expression', ('Compare', (1, 0), ('Num', (1, 0), 1), [('Lt',), ('Lt',)], [('Num', (1, 4), 2), ('Num', (1, 8), 3)])), 1207('Expression', ('Call', (1, 0), ('Name', (1, 0), 'f', ('Load',)), [('Num', (1, 2), 1), ('Num', (1, 4), 2), ('Starred', (1, 10), ('Name', (1, 11), 'd', ('Load',)), ('Load',))], [('keyword', 'c', ('Num', (1, 8), 3)), ('keyword', None, ('Name', (1, 15), 'e', ('Load',)))])), 1208('Expression', ('Num', (1, 0), 10)), 1209('Expression', ('Str', (1, 0), 'string')), 1210('Expression', ('Attribute', (1, 0), ('Name', (1, 0), 'a', ('Load',)), 'b', ('Load',))), 1211('Expression', ('Subscript', (1, 0), ('Name', (1, 0), 'a', ('Load',)), ('Slice', ('Name', (1, 2), 'b', ('Load',)), ('Name', (1, 4), 'c', ('Load',)), None), ('Load',))), 1212('Expression', ('Name', (1, 0), 'v', ('Load',))), 1213('Expression', ('List', (1, 0), [('Num', (1, 1), 1), ('Num', (1, 3), 2), ('Num', (1, 5), 3)], ('Load',))), 1214('Expression', ('List', (1, 0), [], ('Load',))), 1215('Expression', ('Tuple', (1, 0), [('Num', (1, 0), 1), ('Num', (1, 2), 2), ('Num', (1, 4), 3)], ('Load',))), 1216('Expression', ('Tuple', (1, 1), [('Num', (1, 1), 1), ('Num', (1, 3), 2), ('Num', (1, 5), 3)], ('Load',))), 1217('Expression', ('Tuple', (1, 0), [], ('Load',))), 1218('Expression', ('Call', (1, 0), ('Attribute', (1, 0), ('Attribute', (1, 0), ('Attribute', (1, 0), ('Name', (1, 0), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',)), 'd', ('Load',)), [('Subscript', (1, 8), ('Attribute', (1, 8), ('Name', (1, 8), 'a', ('Load',)), 'b', ('Load',)), ('Slice', ('Num', (1, 12), 1), ('Num', (1, 14), 2), None), ('Load',))], [])), 1219] 1220main() 1221