| import parser |
| import unittest |
| from test import test_support |
| |
| # |
| # First, we test that we can generate trees from valid source fragments, |
| # and that these valid trees are indeed allowed by the tree-loading side |
| # of the parser module. |
| # |
| |
| class RoundtripLegalSyntaxTestCase(unittest.TestCase): |
| |
| def roundtrip(self, f, s): |
| st1 = f(s) |
| t = st1.totuple() |
| try: |
| st2 = parser.sequence2st(t) |
| except parser.ParserError, why: |
| self.fail("could not roundtrip %r: %s" % (s, why)) |
| |
| self.assertEquals(t, st2.totuple(), |
| "could not re-generate syntax tree") |
| |
| def check_expr(self, s): |
| self.roundtrip(parser.expr, s) |
| |
| def check_suite(self, s): |
| self.roundtrip(parser.suite, s) |
| |
| def test_yield_statement(self): |
| self.check_suite("def f(): yield 1") |
| self.check_suite("def f(): yield") |
| self.check_suite("def f(): x += yield") |
| self.check_suite("def f(): x = yield 1") |
| self.check_suite("def f(): x = y = yield 1") |
| self.check_suite("def f(): x = yield") |
| self.check_suite("def f(): x = y = yield") |
| self.check_suite("def f(): 1 + (yield)*2") |
| self.check_suite("def f(): (yield 1)*2") |
| self.check_suite("def f(): return; yield 1") |
| self.check_suite("def f(): yield 1; return") |
| self.check_suite("def f():\n" |
| " for x in range(30):\n" |
| " yield x\n") |
| self.check_suite("def f():\n" |
| " if (yield):\n" |
| " yield x\n") |
| |
| def test_expressions(self): |
| self.check_expr("foo(1)") |
| self.check_expr("[1, 2, 3]") |
| self.check_expr("[x**3 for x in range(20)]") |
| self.check_expr("[x**3 for x in range(20) if x % 3]") |
| self.check_expr("[x**3 for x in range(20) if x % 2 if x % 3]") |
| self.check_expr("list(x**3 for x in range(20))") |
| self.check_expr("list(x**3 for x in range(20) if x % 3)") |
| self.check_expr("list(x**3 for x in range(20) if x % 2 if x % 3)") |
| self.check_expr("foo(*args)") |
| self.check_expr("foo(*args, **kw)") |
| self.check_expr("foo(**kw)") |
| self.check_expr("foo(key=value)") |
| self.check_expr("foo(key=value, *args)") |
| self.check_expr("foo(key=value, *args, **kw)") |
| self.check_expr("foo(key=value, **kw)") |
| self.check_expr("foo(a, b, c, *args)") |
| self.check_expr("foo(a, b, c, *args, **kw)") |
| self.check_expr("foo(a, b, c, **kw)") |
| self.check_expr("foo + bar") |
| self.check_expr("foo - bar") |
| self.check_expr("foo * bar") |
| self.check_expr("foo / bar") |
| self.check_expr("foo // bar") |
| self.check_expr("lambda: 0") |
| self.check_expr("lambda x: 0") |
| self.check_expr("lambda *y: 0") |
| self.check_expr("lambda *y, **z: 0") |
| self.check_expr("lambda **z: 0") |
| self.check_expr("lambda x, y: 0") |
| self.check_expr("lambda foo=bar: 0") |
| self.check_expr("lambda foo=bar, spaz=nifty+spit: 0") |
| self.check_expr("lambda foo=bar, **z: 0") |
| self.check_expr("lambda foo=bar, blaz=blat+2, **z: 0") |
| self.check_expr("lambda foo=bar, blaz=blat+2, *y, **z: 0") |
| self.check_expr("lambda x, *y, **z: 0") |
| self.check_expr("(x for x in range(10))") |
| self.check_expr("foo(x for x in range(10))") |
| |
| def test_print(self): |
| self.check_suite("print") |
| self.check_suite("print 1") |
| self.check_suite("print 1,") |
| self.check_suite("print >>fp") |
| self.check_suite("print >>fp, 1") |
| self.check_suite("print >>fp, 1,") |
| |
| def test_simple_expression(self): |
| # expr_stmt |
| self.check_suite("a") |
| |
| def test_simple_assignments(self): |
| self.check_suite("a = b") |
| self.check_suite("a = b = c = d = e") |
| |
| def test_simple_augmented_assignments(self): |
| self.check_suite("a += b") |
| self.check_suite("a -= b") |
| self.check_suite("a *= b") |
| self.check_suite("a /= b") |
| self.check_suite("a //= b") |
| self.check_suite("a %= b") |
| self.check_suite("a &= b") |
| self.check_suite("a |= b") |
| self.check_suite("a ^= b") |
| self.check_suite("a <<= b") |
| self.check_suite("a >>= b") |
| self.check_suite("a **= b") |
| |
| def test_function_defs(self): |
| self.check_suite("def f(): pass") |
| self.check_suite("def f(*args): pass") |
| self.check_suite("def f(*args, **kw): pass") |
| self.check_suite("def f(**kw): pass") |
| self.check_suite("def f(foo=bar): pass") |
| self.check_suite("def f(foo=bar, *args): pass") |
| self.check_suite("def f(foo=bar, *args, **kw): pass") |
| self.check_suite("def f(foo=bar, **kw): pass") |
| |
| self.check_suite("def f(a, b): pass") |
| self.check_suite("def f(a, b, *args): pass") |
| self.check_suite("def f(a, b, *args, **kw): pass") |
| self.check_suite("def f(a, b, **kw): pass") |
| self.check_suite("def f(a, b, foo=bar): pass") |
| self.check_suite("def f(a, b, foo=bar, *args): pass") |
| self.check_suite("def f(a, b, foo=bar, *args, **kw): pass") |
| self.check_suite("def f(a, b, foo=bar, **kw): pass") |
| |
| self.check_suite("@staticmethod\n" |
| "def f(): pass") |
| self.check_suite("@staticmethod\n" |
| "@funcattrs(x, y)\n" |
| "def f(): pass") |
| self.check_suite("@funcattrs()\n" |
| "def f(): pass") |
| |
| def test_class_defs(self): |
| self.check_suite("class foo():pass") |
| |
| def test_import_from_statement(self): |
| self.check_suite("from sys.path import *") |
| self.check_suite("from sys.path import dirname") |
| self.check_suite("from sys.path import (dirname)") |
| self.check_suite("from sys.path import (dirname,)") |
| self.check_suite("from sys.path import dirname as my_dirname") |
| self.check_suite("from sys.path import (dirname as my_dirname)") |
| self.check_suite("from sys.path import (dirname as my_dirname,)") |
| self.check_suite("from sys.path import dirname, basename") |
| self.check_suite("from sys.path import (dirname, basename)") |
| self.check_suite("from sys.path import (dirname, basename,)") |
| self.check_suite( |
| "from sys.path import dirname as my_dirname, basename") |
| self.check_suite( |
| "from sys.path import (dirname as my_dirname, basename)") |
| self.check_suite( |
| "from sys.path import (dirname as my_dirname, basename,)") |
| self.check_suite( |
| "from sys.path import dirname, basename as my_basename") |
| self.check_suite( |
| "from sys.path import (dirname, basename as my_basename)") |
| self.check_suite( |
| "from sys.path import (dirname, basename as my_basename,)") |
| |
| def test_basic_import_statement(self): |
| self.check_suite("import sys") |
| self.check_suite("import sys as system") |
| self.check_suite("import sys, math") |
| self.check_suite("import sys as system, math") |
| self.check_suite("import sys, math as my_math") |
| |
| def test_pep263(self): |
| self.check_suite("# -*- coding: iso-8859-1 -*-\n" |
| "pass\n") |
| |
| def test_assert(self): |
| self.check_suite("assert alo < ahi and blo < bhi\n") |
| |
| # |
| # Second, we take *invalid* trees and make sure we get ParserError |
| # rejections for them. |
| # |
| |
| class IllegalSyntaxTestCase(unittest.TestCase): |
| |
| def check_bad_tree(self, tree, label): |
| try: |
| parser.sequence2st(tree) |
| except parser.ParserError: |
| pass |
| else: |
| self.fail("did not detect invalid tree for %r" % label) |
| |
| def test_junk(self): |
| # not even remotely valid: |
| self.check_bad_tree((1, 2, 3), "<junk>") |
| |
| def test_illegal_yield_1(self): |
| # Illegal yield statement: def f(): return 1; yield 1 |
| tree = \ |
| (257, |
| (264, |
| (285, |
| (259, |
| (1, 'def'), |
| (1, 'f'), |
| (260, (7, '('), (8, ')')), |
| (11, ':'), |
| (291, |
| (4, ''), |
| (5, ''), |
| (264, |
| (265, |
| (266, |
| (272, |
| (275, |
| (1, 'return'), |
| (313, |
| (292, |
| (293, |
| (294, |
| (295, |
| (297, |
| (298, |
| (299, |
| (300, |
| (301, |
| (302, (303, (304, (305, (2, '1')))))))))))))))))), |
| (264, |
| (265, |
| (266, |
| (272, |
| (276, |
| (1, 'yield'), |
| (313, |
| (292, |
| (293, |
| (294, |
| (295, |
| (297, |
| (298, |
| (299, |
| (300, |
| (301, |
| (302, |
| (303, (304, (305, (2, '1')))))))))))))))))), |
| (4, ''))), |
| (6, ''))))), |
| (4, ''), |
| (0, '')))) |
| self.check_bad_tree(tree, "def f():\n return 1\n yield 1") |
| |
| def test_illegal_yield_2(self): |
| # Illegal return in generator: def f(): return 1; yield 1 |
| tree = \ |
| (257, |
| (264, |
| (265, |
| (266, |
| (278, |
| (1, 'from'), |
| (281, (1, '__future__')), |
| (1, 'import'), |
| (279, (1, 'generators')))), |
| (4, ''))), |
| (264, |
| (285, |
| (259, |
| (1, 'def'), |
| (1, 'f'), |
| (260, (7, '('), (8, ')')), |
| (11, ':'), |
| (291, |
| (4, ''), |
| (5, ''), |
| (264, |
| (265, |
| (266, |
| (272, |
| (275, |
| (1, 'return'), |
| (313, |
| (292, |
| (293, |
| (294, |
| (295, |
| (297, |
| (298, |
| (299, |
| (300, |
| (301, |
| (302, (303, (304, (305, (2, '1')))))))))))))))))), |
| (264, |
| (265, |
| (266, |
| (272, |
| (276, |
| (1, 'yield'), |
| (313, |
| (292, |
| (293, |
| (294, |
| (295, |
| (297, |
| (298, |
| (299, |
| (300, |
| (301, |
| (302, |
| (303, (304, (305, (2, '1')))))))))))))))))), |
| (4, ''))), |
| (6, ''))))), |
| (4, ''), |
| (0, '')))) |
| self.check_bad_tree(tree, "def f():\n return 1\n yield 1") |
| |
| def test_print_chevron_comma(self): |
| # Illegal input: print >>fp, |
| tree = \ |
| (257, |
| (264, |
| (265, |
| (266, |
| (268, |
| (1, 'print'), |
| (35, '>>'), |
| (290, |
| (291, |
| (292, |
| (293, |
| (295, |
| (296, |
| (297, |
| (298, (299, (300, (301, (302, (303, (1, 'fp')))))))))))))), |
| (12, ','))), |
| (4, ''))), |
| (0, '')) |
| self.check_bad_tree(tree, "print >>fp,") |
| |
| def test_a_comma_comma_c(self): |
| # Illegal input: a,,c |
| tree = \ |
| (258, |
| (311, |
| (290, |
| (291, |
| (292, |
| (293, |
| (295, |
| (296, |
| (297, |
| (298, (299, (300, (301, (302, (303, (1, 'a')))))))))))))), |
| (12, ','), |
| (12, ','), |
| (290, |
| (291, |
| (292, |
| (293, |
| (295, |
| (296, |
| (297, |
| (298, (299, (300, (301, (302, (303, (1, 'c'))))))))))))))), |
| (4, ''), |
| (0, '')) |
| self.check_bad_tree(tree, "a,,c") |
| |
| def test_illegal_operator(self): |
| # Illegal input: a $= b |
| tree = \ |
| (257, |
| (264, |
| (265, |
| (266, |
| (267, |
| (312, |
| (291, |
| (292, |
| (293, |
| (294, |
| (296, |
| (297, |
| (298, |
| (299, |
| (300, (301, (302, (303, (304, (1, 'a'))))))))))))))), |
| (268, (37, '$=')), |
| (312, |
| (291, |
| (292, |
| (293, |
| (294, |
| (296, |
| (297, |
| (298, |
| (299, |
| (300, (301, (302, (303, (304, (1, 'b'))))))))))))))))), |
| (4, ''))), |
| (0, '')) |
| self.check_bad_tree(tree, "a $= b") |
| |
| def test_malformed_global(self): |
| #doesn't have global keyword in ast |
| tree = (257, |
| (264, |
| (265, |
| (266, |
| (282, (1, 'foo'))), (4, ''))), |
| (4, ''), |
| (0, '')) |
| self.check_bad_tree(tree, "malformed global ast") |
| |
| |
| class CompileTestCase(unittest.TestCase): |
| |
| # These tests are very minimal. :-( |
| |
| def test_compile_expr(self): |
| st = parser.expr('2 + 3') |
| code = parser.compilest(st) |
| self.assertEquals(eval(code), 5) |
| |
| def test_compile_suite(self): |
| st = parser.suite('x = 2; y = x + 3') |
| code = parser.compilest(st) |
| globs = {} |
| exec code in globs |
| self.assertEquals(globs['y'], 5) |
| |
| def test_compile_error(self): |
| st = parser.suite('1 = 3 + 4') |
| self.assertRaises(SyntaxError, parser.compilest, st) |
| |
| def test_main(): |
| test_support.run_unittest( |
| RoundtripLegalSyntaxTestCase, |
| IllegalSyntaxTestCase, |
| CompileTestCase, |
| ) |
| |
| |
| if __name__ == "__main__": |
| test_main() |