diff -r 000000000000 -r ae805ac0140d python-2.5.2/win32/Lib/test/test_parser.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python-2.5.2/win32/Lib/test/test_parser.py Fri Apr 03 17:19:34 2009 +0100 @@ -0,0 +1,448 @@ +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), "") + + 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()