Convert the parser module test to use PyUnit.
diff --git a/Lib/test/test_parser.py b/Lib/test/test_parser.py
index 6885767..5b867d7 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 @@
# 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), "<junk>")
+
+ 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), "<junk>")
-
-# 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)