From 58422e582008fbdfb981795934d10dfd3073f5e1 Mon Sep 17 00:00:00 2001 From: Fred Drake Date: Mon, 4 Jun 2001 03:56:24 +0000 Subject: [PATCH] Convert the parser module test to use PyUnit. --- Lib/test/output/test_parser | 92 --------- Lib/test/test_parser.py | 390 ++++++++++++++++++------------------ 2 files changed, 197 insertions(+), 285 deletions(-) delete mode 100644 Lib/test/output/test_parser diff --git a/Lib/test/output/test_parser b/Lib/test/output/test_parser deleted file mode 100644 index 0381fb7514a..00000000000 --- a/Lib/test/output/test_parser +++ /dev/null @@ -1,92 +0,0 @@ -test_parser -Expressions: -expr: foo(1) -expr: [1, 2, 3] -expr: [x**3 for x in range(20)] -expr: [x**3 for x in range(20) if x % 3] -expr: foo(*args) -expr: foo(*args, **kw) -expr: foo(**kw) -expr: foo(key=value) -expr: foo(key=value, *args) -expr: foo(key=value, *args, **kw) -expr: foo(key=value, **kw) -expr: foo(a, b, c, *args) -expr: foo(a, b, c, *args, **kw) -expr: foo(a, b, c, **kw) -expr: foo + bar -expr: lambda: 0 -expr: lambda x: 0 -expr: lambda *y: 0 -expr: lambda *y, **z: 0 -expr: lambda **z: 0 -expr: lambda x, y: 0 -expr: lambda foo=bar: 0 -expr: lambda foo=bar, spaz=nifty+spit: 0 -expr: lambda foo=bar, **z: 0 -expr: lambda foo=bar, blaz=blat+2, **z: 0 -expr: lambda foo=bar, blaz=blat+2, *y, **z: 0 -expr: lambda x, *y, **z: 0 - -Statements: -suite: print -suite: print 1 -suite: print 1, -suite: print >>fp -suite: print >>fp, 1 -suite: print >>fp, 1, -suite: a -suite: a = b -suite: a = b = c = d = e -suite: a += b -suite: a -= b -suite: a *= b -suite: a /= b -suite: a %= b -suite: a &= b -suite: a |= b -suite: a ^= b -suite: a <<= b -suite: a >>= b -suite: a **= b -suite: def f(): pass -suite: def f(*args): pass -suite: def f(*args, **kw): pass -suite: def f(**kw): pass -suite: def f(foo=bar): pass -suite: def f(foo=bar, *args): pass -suite: def f(foo=bar, *args, **kw): pass -suite: def f(foo=bar, **kw): pass -suite: def f(a, b): pass -suite: def f(a, b, *args): pass -suite: def f(a, b, *args, **kw): pass -suite: def f(a, b, **kw): pass -suite: def f(a, b, foo=bar): pass -suite: def f(a, b, foo=bar, *args): pass -suite: def f(a, b, foo=bar, *args, **kw): pass -suite: def f(a, b, foo=bar, **kw): pass -suite: from sys.path import * -suite: from sys.path import dirname -suite: from sys.path import dirname as my_dirname -suite: from sys.path import dirname, basename -suite: from sys.path import dirname as my_dirname, basename -suite: from sys.path import dirname, basename as my_basename -suite: import sys -suite: import sys as system -suite: import sys, math -suite: import sys as system, math -suite: import sys, math as my_math - -Invalid parse trees: - - -caught expected exception for invalid tree - -print >>fp, -caught expected exception for invalid tree - -a,,c -caught expected exception for invalid tree - -a $= b -caught expected exception for invalid tree diff --git a/Lib/test/test_parser.py b/Lib/test/test_parser.py index 6885767b524..5b867d75c93 100644 --- a/Lib/test/test_parser.py +++ b/Lib/test/test_parser.py @@ -1,9 +1,6 @@ -import os.path import parser -import pprint -import sys - -from test_support import TestFailed +import test_support +import unittest # # First, we test that we can generate trees from valid source fragments, @@ -11,212 +8,219 @@ from test_support import TestFailed # of the parser module. # -def roundtrip(f, s): - st1 = f(s) - t = st1.totuple() - try: - st2 = parser.sequence2ast(t) - except parser.ParserError: - raise TestFailed, s +class RoundtripLegalSyntaxTestCase(unittest.TestCase): + def roundtrip(self, f, s): + st1 = f(s) + t = st1.totuple() + try: + st2 = parser.sequence2ast(t) + except parser.ParserError: + self.fail("could not roundtrip %r" % s) -def roundtrip_fromfile(filename): - roundtrip(parser.suite, open(filename).read()) + self.assertEquals(t, st2.totuple(), + "could not re-generate syntax tree") -def test_expr(s): - print "expr:", s - roundtrip(parser.expr, s) + def check_expr(self, s): + self.roundtrip(parser.expr, s) -def test_suite(s): - print "suite:", s - roundtrip(parser.suite, s) + def check_suite(self, s): + self.roundtrip(parser.suite, s) + 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("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("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") -print "Expressions:" + 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,") -test_expr("foo(1)") -test_expr("[1, 2, 3]") -test_expr("[x**3 for x in range(20)]") -test_expr("[x**3 for x in range(20) if x % 3]") -test_expr("foo(*args)") -test_expr("foo(*args, **kw)") -test_expr("foo(**kw)") -test_expr("foo(key=value)") -test_expr("foo(key=value, *args)") -test_expr("foo(key=value, *args, **kw)") -test_expr("foo(key=value, **kw)") -test_expr("foo(a, b, c, *args)") -test_expr("foo(a, b, c, *args, **kw)") -test_expr("foo(a, b, c, **kw)") -test_expr("foo + bar") -test_expr("lambda: 0") -test_expr("lambda x: 0") -test_expr("lambda *y: 0") -test_expr("lambda *y, **z: 0") -test_expr("lambda **z: 0") -test_expr("lambda x, y: 0") -test_expr("lambda foo=bar: 0") -test_expr("lambda foo=bar, spaz=nifty+spit: 0") -test_expr("lambda foo=bar, **z: 0") -test_expr("lambda foo=bar, blaz=blat+2, **z: 0") -test_expr("lambda foo=bar, blaz=blat+2, *y, **z: 0") -test_expr("lambda x, *y, **z: 0") + def test_simple_expression(self): + # expr_stmt + self.check_suite("a") -print -print "Statements:" -test_suite("print") -test_suite("print 1") -test_suite("print 1,") -test_suite("print >>fp") -test_suite("print >>fp, 1") -test_suite("print >>fp, 1,") + def test_simple_assignments(self): + self.check_suite("a = b") + self.check_suite("a = b = c = d = e") -# expr_stmt -test_suite("a") -test_suite("a = b") -test_suite("a = b = c = d = e") -test_suite("a += b") -test_suite("a -= b") -test_suite("a *= b") -test_suite("a /= b") -test_suite("a %= b") -test_suite("a &= b") -test_suite("a |= b") -test_suite("a ^= b") -test_suite("a <<= b") -test_suite("a >>= b") -test_suite("a **= b") + 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") -test_suite("def f(): pass") -test_suite("def f(*args): pass") -test_suite("def f(*args, **kw): pass") -test_suite("def f(**kw): pass") -test_suite("def f(foo=bar): pass") -test_suite("def f(foo=bar, *args): pass") -test_suite("def f(foo=bar, *args, **kw): pass") -test_suite("def f(foo=bar, **kw): pass") + 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") -test_suite("def f(a, b): pass") -test_suite("def f(a, b, *args): pass") -test_suite("def f(a, b, *args, **kw): pass") -test_suite("def f(a, b, **kw): pass") -test_suite("def f(a, b, foo=bar): pass") -test_suite("def f(a, b, foo=bar, *args): pass") -test_suite("def f(a, b, foo=bar, *args, **kw): pass") -test_suite("def f(a, b, 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") -test_suite("from sys.path import *") -test_suite("from sys.path import dirname") -test_suite("from sys.path import dirname as my_dirname") -test_suite("from sys.path import dirname, basename") -test_suite("from sys.path import dirname as my_dirname, basename") -test_suite("from sys.path import dirname, basename as my_basename") + 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 as my_dirname") + 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, basename as my_basename") -test_suite("import sys") -test_suite("import sys as system") -test_suite("import sys, math") -test_suite("import sys as system, math") -test_suite("import sys, math as my_math") - -#d = os.path.dirname(os.__file__) -#roundtrip_fromfile(os.path.join(d, "os.py")) -#roundtrip_fromfile(os.path.join(d, "test", "test_parser.py")) + 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") # # Second, we take *invalid* trees and make sure we get ParserError # rejections for them. # -print -print "Invalid parse trees:" +class IllegalSyntaxTestCase(unittest.TestCase): + def check_bad_tree(self, tree, label): + try: + parser.sequence2ast(tree) + except parser.ParserError: + pass + else: + self.fail("did not detect invalid tree for %r" % label) -def check_bad_tree(tree, label): - print - print label - try: - parser.sequence2ast(tree) - except parser.ParserError: - print "caught expected exception for invalid tree" - else: - print "test failed: did not properly detect invalid tree:" - pprint.pprint(tree) + def test_junk(self): + # not even remotely valid: + self.check_bad_tree((1, 2, 3), "") + + 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") -# not even remotely valid: -check_bad_tree((1, 2, 3), "") - -# 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, '')) - -check_bad_tree(tree, "print >>fp,") - -# 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, '')) - -check_bad_tree(tree, "a,,c") - -# 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, '')) - -check_bad_tree(tree, "a $= b") +test_support.run_unittest(RoundtripLegalSyntaxTestCase) +test_support.run_unittest(IllegalSyntaxTestCase)