Skip to content

C
cpython
Kaydet (Commit) 58422e58 authored tarafından Fred Drake's avatar Fred Drake
Dosyalara gözat
Seçenekler

Convert the parser module test to use PyUnit.

üst 194bfb28
Hide whitespace changes
Inline Side-by-side
Showing with 212 additions and 300 deletions
Lib/test/output/test_parser deleted 100644 → 0
Dosyayı görüntüle @ 194bfb28
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:
<junk>
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
Lib/test/test_parser.py
Dosyayı görüntüle @ 58422e58
import os.path
import parser import parser
import pprint import test_support
import sys import unittest
from test_support import TestFailed
# #
# First, we test that we can generate trees from valid source fragments, # First, we test that we can generate trees from valid source fragments,
...@@ -11,212 +8,219 @@ from test_support import TestFailed ...@@ -11,212 +8,219 @@ from test_support import TestFailed
# of the parser module. # of the parser module.
# #
def roundtrip(f, s): class RoundtripLegalSyntaxTestCase(unittest.TestCase):
st1 = f(s) def roundtrip(self, f, s):
t = st1.totuple() st1 = f(s)
try: t = st1.totuple()
st2 = parser.sequence2ast(t) try:
except parser.ParserError: st2 = parser.sequence2ast(t)
raise TestFailed, s 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 def check_expr(self, s):
roundtrip(parser.expr, s) self.roundtrip(parser.expr, s)
def test_suite(s): def check_suite(self, s):
print "suite:", s self.roundtrip(parser.suite, s)
roundtrip(parser.suite, s)
def test_expressions(self):
self.check_expr("foo(1)")
print "Expressions:" self.check_expr("[1, 2, 3]")
self.check_expr("[x**3 for x in range(20)]")
test_expr("foo(1)") self.check_expr("[x**3 for x in range(20) if x % 3]")
test_expr("[1, 2, 3]") self.check_expr("foo(*args)")
test_expr("[x**3 for x in range(20)]") self.check_expr("foo(*args, **kw)")
test_expr("[x**3 for x in range(20) if x % 3]") self.check_expr("foo(**kw)")
test_expr("foo(*args)") self.check_expr("foo(key=value)")
test_expr("foo(*args, **kw)") self.check_expr("foo(key=value, *args)")
test_expr("foo(**kw)") self.check_expr("foo(key=value, *args, **kw)")
test_expr("foo(key=value)") self.check_expr("foo(key=value, **kw)")
test_expr("foo(key=value, *args)") self.check_expr("foo(a, b, c, *args)")
test_expr("foo(key=value, *args, **kw)") self.check_expr("foo(a, b, c, *args, **kw)")
test_expr("foo(key=value, **kw)") self.check_expr("foo(a, b, c, **kw)")
test_expr("foo(a, b, c, *args)") self.check_expr("foo + bar")
test_expr("foo(a, b, c, *args, **kw)") self.check_expr("lambda: 0")
test_expr("foo(a, b, c, **kw)") self.check_expr("lambda x: 0")
test_expr("foo + bar") self.check_expr("lambda *y: 0")
test_expr("lambda: 0") self.check_expr("lambda *y, **z: 0")
test_expr("lambda x: 0") self.check_expr("lambda **z: 0")
test_expr("lambda *y: 0") self.check_expr("lambda x, y: 0")
test_expr("lambda *y, **z: 0") self.check_expr("lambda foo=bar: 0")
test_expr("lambda **z: 0") self.check_expr("lambda foo=bar, spaz=nifty+spit: 0")
test_expr("lambda x, y: 0") self.check_expr("lambda foo=bar, **z: 0")
test_expr("lambda foo=bar: 0") self.check_expr("lambda foo=bar, blaz=blat+2, **z: 0")
test_expr("lambda foo=bar, spaz=nifty+spit: 0") self.check_expr("lambda foo=bar, blaz=blat+2, *y, **z: 0")
test_expr("lambda foo=bar, **z: 0") self.check_expr("lambda x, *y, **z: 0")
test_expr("lambda foo=bar, blaz=blat+2, **z: 0")
test_expr("lambda foo=bar, blaz=blat+2, *y, **z: 0") def test_print(self):
test_expr("lambda x, *y, **z: 0") self.check_suite("print")
self.check_suite("print 1")
print self.check_suite("print 1,")
print "Statements:" self.check_suite("print >>fp")
test_suite("print") self.check_suite("print >>fp, 1")
test_suite("print 1") self.check_suite("print >>fp, 1,")
test_suite("print 1,")
test_suite("print >>fp") def test_simple_expression(self):
test_suite("print >>fp, 1") # expr_stmt
test_suite("print >>fp, 1,") self.check_suite("a")
# expr_stmt def test_simple_assignments(self):
test_suite("a") self.check_suite("a = b")
test_suite("a = b") self.check_suite("a = b = c = d = e")
test_suite("a = b = c = d = e")
test_suite("a += b") def test_simple_augmented_assignments(self):
test_suite("a -= b") self.check_suite("a += b")
test_suite("a *= b") self.check_suite("a -= b")
test_suite("a /= b") self.check_suite("a *= b")
test_suite("a %= b") self.check_suite("a /= b")
test_suite("a &= b") self.check_suite("a %= b")
test_suite("a |= b") self.check_suite("a &= b")
test_suite("a ^= b") self.check_suite("a |= b")
test_suite("a <<= b") self.check_suite("a ^= b")
test_suite("a >>= b") self.check_suite("a <<= b")
test_suite("a **= b") self.check_suite("a >>= b")
self.check_suite("a **= b")
test_suite("def f(): pass")
test_suite("def f(*args): pass") def test_function_defs(self):
test_suite("def f(*args, **kw): pass") self.check_suite("def f(): pass")
test_suite("def f(**kw): pass") self.check_suite("def f(*args): pass")
test_suite("def f(foo=bar): pass") self.check_suite("def f(*args, **kw): pass")
test_suite("def f(foo=bar, *args): pass") self.check_suite("def f(**kw): pass")
test_suite("def f(foo=bar, *args, **kw): pass") self.check_suite("def f(foo=bar): pass")
test_suite("def f(foo=bar, **kw): pass") self.check_suite("def f(foo=bar, *args): pass")
self.check_suite("def f(foo=bar, *args, **kw): pass")
test_suite("def f(a, b): pass") self.check_suite("def f(foo=bar, **kw): pass")
test_suite("def f(a, b, *args): pass")
test_suite("def f(a, b, *args, **kw): pass") self.check_suite("def f(a, b): pass")
test_suite("def f(a, b, **kw): pass") self.check_suite("def f(a, b, *args): pass")
test_suite("def f(a, b, foo=bar): pass") self.check_suite("def f(a, b, *args, **kw): pass")
test_suite("def f(a, b, foo=bar, *args): pass") self.check_suite("def f(a, b, **kw): pass")
test_suite("def f(a, b, foo=bar, *args, **kw): pass") self.check_suite("def f(a, b, foo=bar): pass")
test_suite("def f(a, b, foo=bar, **kw): pass") self.check_suite("def f(a, b, foo=bar, *args): pass")
self.check_suite("def f(a, b, foo=bar, *args, **kw): pass")
test_suite("from sys.path import *") self.check_suite("def f(a, b, foo=bar, **kw): pass")
test_suite("from sys.path import dirname")
test_suite("from sys.path import dirname as my_dirname") def test_import_from_statement(self):
test_suite("from sys.path import dirname, basename") self.check_suite("from sys.path import *")
test_suite("from sys.path import dirname as my_dirname, basename") self.check_suite("from sys.path import dirname")
test_suite("from sys.path import dirname, basename as my_basename") self.check_suite("from sys.path import dirname as my_dirname")
self.check_suite("from sys.path import dirname, basename")
test_suite("import sys") self.check_suite(
test_suite("import sys as system") "from sys.path import dirname as my_dirname, basename")
test_suite("import sys, math") self.check_suite(
test_suite("import sys as system, math") "from sys.path import dirname, basename as my_basename")
test_suite("import sys, math as my_math")
def test_basic_import_statement(self):
#d = os.path.dirname(os.__file__) self.check_suite("import sys")
#roundtrip_fromfile(os.path.join(d, "os.py")) self.check_suite("import sys as system")
#roundtrip_fromfile(os.path.join(d, "test", "test_parser.py")) 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 # Second, we take *invalid* trees and make sure we get ParserError
# rejections for them. # rejections for them.
# #
print class IllegalSyntaxTestCase(unittest.TestCase):
print "Invalid parse trees:" def check_bad_tree(self, tree, label):
try:
def check_bad_tree(tree, label): parser.sequence2ast(tree)
print except parser.ParserError:
print label pass
try: else:
parser.sequence2ast(tree) self.fail("did not detect invalid tree for %r" % label)
except parser.ParserError:
print "caught expected exception for invalid tree" def test_junk(self):
else: # not even remotely valid:
print "test failed: did not properly detect invalid tree:" self.check_bad_tree((1, 2, 3), "<junk>")
pprint.pprint(tree)
def test_print_chevron_comma(self):
"Illegal input: print >>fp,"""
# not even remotely valid: tree = \
check_bad_tree((1, 2, 3), "<junk>") (257,
(264,
# print >>fp, (265,
tree = \ (266,
(257, (268,
(264, (1, 'print'),
(265, (35, '>>'),
(266, (290,
(268, (291,
(1, 'print'), (292,
(35, '>>'), (293,
(290, (295,
(291, (296,
(292, (297,
(293, (298, (299, (300, (301, (302, (303, (1, 'fp')))))))))))))),
(295, (12, ','))),
(296, (4, ''))),
(297, (0, ''))
(298, (299, (300, (301, (302, (303, (1, 'fp')))))))))))))), self.check_bad_tree(tree, "print >>fp,")
(12, ','))),
(4, ''))), def test_a_comma_comma_c(self):
(0, '')) """Illegal input: a,,c"""
tree = \
check_bad_tree(tree, "print >>fp,") (258,
(311,
# a,,c (290,
tree = \ (291,
(258, (292,
(311, (293,
(290, (295,
(291, (296,
(292, (297,
(293, (298, (299, (300, (301, (302, (303, (1, 'a')))))))))))))),
(295, (12, ','),
(296, (297, (298, (299, (300, (301, (302, (303, (1, 'a')))))))))))))), (12, ','),
(12, ','), (290,
(12, ','), (291,
(290, (292,
(291, (293,
(292, (295,
(293, (296,
(295, (297,
(296, (297, (298, (299, (300, (301, (302, (303, (1, 'c'))))))))))))))), (298, (299, (300, (301, (302, (303, (1, 'c'))))))))))))))),
(4, ''), (4, ''),
(0, '')) (0, ''))
self.check_bad_tree(tree, "a,,c")
check_bad_tree(tree, "a,,c")
def test_illegal_operator(self):
# a $= b """Illegal input: a $= b"""
tree = \ tree = \
(257, (257,
(264, (264,
(265, (265,
(266, (266,
(267, (267,
(312, (312,
(291, (291,
(292, (292,
(293, (293,
(294, (294,
(296, (296,
(297, (297,
(298, (298,
(299, (300, (301, (302, (303, (304, (1, 'a'))))))))))))))), (299,
(268, (37, '$=')), (300, (301, (302, (303, (304, (1, 'a'))))))))))))))),
(312, (268, (37, '$=')),
(291, (312,
(292, (291,
(293, (292,
(294, (293,
(296, (294,
(297, (296,
(298, (297,
(299, (300, (301, (302, (303, (304, (1, 'b'))))))))))))))))), (298,
(4, ''))), (299,
(0, '')) (300, (301, (302, (303, (304, (1, 'b'))))))))))))))))),
(4, ''))),
check_bad_tree(tree, "a $= b") (0, ''))
self.check_bad_tree(tree, "a $= b")
test_support.run_unittest(RoundtripLegalSyntaxTestCase)
test_support.run_unittest(IllegalSyntaxTestCase)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment