[pypy-svn] r10207 - in pypy/dist/pypy/module/parser: . test
jriehl at codespeak.net
jriehl at codespeak.net
Fri Apr 1 00:16:46 CEST 2005
Author: jriehl
Date: Fri Apr 1 00:16:46 2005
New Revision: 10207
Modified:
pypy/dist/pypy/module/parser/DFAParser.py
pypy/dist/pypy/module/parser/PgenParser.py
pypy/dist/pypy/module/parser/test/test_parser.py
pypy/dist/pypy/module/parser/test/test_simple.py
Log:
Trying to remove some more of the Basil dependencies out of the parser
code.
Fixed(?) test modules so they at least appear to work from test_all.
Modified: pypy/dist/pypy/module/parser/DFAParser.py
==============================================================================
--- pypy/dist/pypy/module/parser/DFAParser.py (original)
+++ pypy/dist/pypy/module/parser/DFAParser.py Fri Apr 1 00:16:46 2005
@@ -54,6 +54,7 @@
E_SYNTAX = 2
__DEBUG__ = 0
+__BASIL__ = 0
if __DEBUG__:
import string
@@ -280,10 +281,7 @@
# ____________________________________________________________
# Build tokenizer
import sys
- try:
- from basil.lang.python import StdTokenizer
- except ImportError:
- import StdTokenizer
+ import StdTokenizer
if inputFile == None:
inputFile = "<stdin>"
fileObj = sys.stdin
@@ -293,32 +291,34 @@
# ____________________________________________________________
# Build parser
import pprint
- from basil.parsing import pgen
- gramAst = pgen.metaParser.parseFile(inputGrammar)
- myParser = pgen.buildParser(gramAst)
- grammar = myParser.toTuple()
+ import PgenParser
+ import PyPgen
+ gramAst = PgenParser.parseFile(inputGrammar)
+ grammarObj = PyPgen.PyPgen()(gramAst) # XXX - Maybe this API should change?
+ myParser = PyPgen.PyPgenParser(grammarObj)
if __DEBUG__:
- pprint.pprint(grammar)
+ pprint.pprint(grammarObj)
symbols = myParser.stringToSymbolMap()
# ____________________________________________________________
# Run parser
import time
t0 = time.time()
- parseTree = parsetok(tokenizer, grammar, symbols['file_input'])
+ parseTree = parsetok(tokenizer, grammarObj, symbols['file_input'])
t1 = time.time()
print "DFAParser took %g seconds" % (t1 - t0)
fileObj.close()
# ____________________________________________________________
# Display AST
- from basil.visuals.TreeBox import showTree
- showTree(parseTree).mainloop()
+ if __BASIL__:
+ from basil.visuals.TreeBox import showTree
+ showTree(parseTree).mainloop()
# ______________________________________________________________________
if __name__ == "__main__":
import sys
# XXX - Maybe this file location should not be hard coded??
- inputGrammar = "../../parsing/tests/test.pgen"
+ inputGrammar = "Grammar"
if len(sys.argv) == 1:
main(inputGrammar)
else:
Modified: pypy/dist/pypy/module/parser/PgenParser.py
==============================================================================
--- pypy/dist/pypy/module/parser/PgenParser.py (original)
+++ pypy/dist/pypy/module/parser/PgenParser.py Fri Apr 1 00:16:46 2005
@@ -212,8 +212,6 @@
parseTree = parseFile(sys.argv[1])
else:
parseTree = parseString(sys.stdin.read())
- from basil.visuals.TreeBox import showTree
- showTree(parseTree).mainloop()
# ______________________________________________________________________
Modified: pypy/dist/pypy/module/parser/test/test_parser.py
==============================================================================
--- pypy/dist/pypy/module/parser/test/test_parser.py (original)
+++ pypy/dist/pypy/module/parser/test/test_parser.py Fri Apr 1 00:16:46 2005
@@ -1,399 +1,399 @@
-import basil.common.python.pyparser as 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:
- self.fail("could not roundtrip %r" % s)
-
- 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(): 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")
-
- 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("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")
-
- 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")
-
- 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")
-
- 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):
-
- bad_trees = {}
-
- 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>")
-
- bad_trees['illegal_yield_1'] = \
- (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, ''))))
-
- def test_illegal_yield_1(self):
- # Illegal yield statement: def f(): return 1; yield 1
- tree = self.bad_trees['illegal_yield_1']
- self.check_bad_tree(tree, "def f():\n return 1\n yield 1")
-
- bad_trees['illegal_yield_2'] = \
- (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, ''))))
-
- def test_illegal_yield_2(self):
- # Illegal return in generator: def f(): return 1; yield 1
- tree = self.bad_trees['illegal_yield_2']
- self.check_bad_tree(tree, "def f():\n return 1\n yield 1")
-
- bad_trees['print_chevron_comma'] = \
- (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, ''))
-
- def test_print_chevron_comma(self):
- # Illegal input: print >>fp,
- tree = self.bad_trees['print_chevron_comma']
- self.check_bad_tree(tree, "print >>fp,")
-
- bad_trees['a_comma_comma_c'] = \
- (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, ''))
-
- def test_a_comma_comma_c(self):
- # Illegal input: a,,c
- tree = self.bad_trees['a_comma_comma_c']
- self.check_bad_tree(tree, "a,,c")
-
- bad_trees['illegal_operator'] = \
- (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, ''))
-
- def test_illegal_operator(self):
- # Illegal input: a $= b
- tree = self.bad_trees['illegal_operator']
- self.check_bad_tree(tree, "a $= b")
-
- bad_trees['malformed_global'] = \
- (257,
- (264,
- (265,
- (266,
- (282, (1, 'foo'))), (4, ''))),
- (4, ''),
- (0, ''))
-
- def test_malformed_global(self):
- #doesn't have global keyword in ast
- tree = self.bad_trees['malformed_global']
- self.check_bad_tree(tree, "malformed global ast")
-
-def test_main():
- test_support.run_unittest(
- RoundtripLegalSyntaxTestCase,
- IllegalSyntaxTestCase
- )
-
-
-if __name__ == "__main__":
- test_main()
+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:
+ self.fail("could not roundtrip %r" % s)
+
+ 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(): 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")
+
+ 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("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")
+
+ 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")
+
+ 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")
+
+ 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):
+
+ bad_trees = {}
+
+ 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>")
+
+ bad_trees['illegal_yield_1'] = \
+ (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, ''))))
+
+ def test_illegal_yield_1(self):
+ # Illegal yield statement: def f(): return 1; yield 1
+ tree = self.bad_trees['illegal_yield_1']
+ self.check_bad_tree(tree, "def f():\n return 1\n yield 1")
+
+ bad_trees['illegal_yield_2'] = \
+ (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, ''))))
+
+ def test_illegal_yield_2(self):
+ # Illegal return in generator: def f(): return 1; yield 1
+ tree = self.bad_trees['illegal_yield_2']
+ self.check_bad_tree(tree, "def f():\n return 1\n yield 1")
+
+ bad_trees['print_chevron_comma'] = \
+ (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, ''))
+
+ def test_print_chevron_comma(self):
+ # Illegal input: print >>fp,
+ tree = self.bad_trees['print_chevron_comma']
+ self.check_bad_tree(tree, "print >>fp,")
+
+ bad_trees['a_comma_comma_c'] = \
+ (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, ''))
+
+ def test_a_comma_comma_c(self):
+ # Illegal input: a,,c
+ tree = self.bad_trees['a_comma_comma_c']
+ self.check_bad_tree(tree, "a,,c")
+
+ bad_trees['illegal_operator'] = \
+ (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, ''))
+
+ def test_illegal_operator(self):
+ # Illegal input: a $= b
+ tree = self.bad_trees['illegal_operator']
+ self.check_bad_tree(tree, "a $= b")
+
+ bad_trees['malformed_global'] = \
+ (257,
+ (264,
+ (265,
+ (266,
+ (282, (1, 'foo'))), (4, ''))),
+ (4, ''),
+ (0, ''))
+
+ def test_malformed_global(self):
+ #doesn't have global keyword in ast
+ tree = self.bad_trees['malformed_global']
+ self.check_bad_tree(tree, "malformed global ast")
+
+def test_main():
+ test_support.run_unittest(
+ RoundtripLegalSyntaxTestCase,
+ IllegalSyntaxTestCase
+ )
+
+
+if __name__ == "__main__":
+ test_main()
Modified: pypy/dist/pypy/module/parser/test/test_simple.py
==============================================================================
--- pypy/dist/pypy/module/parser/test/test_simple.py (original)
+++ pypy/dist/pypy/module/parser/test/test_simple.py Fri Apr 1 00:16:46 2005
@@ -1,39 +1,129 @@
+#! /usr/bin/env python
+# ______________________________________________________________________
import unittest, inspect, compiler
import sys
-import parser as cpy_parser
-sys.path.insert(0, '..')
-del sys.modules['parser']
-import pyparser as parser
-assert hasattr(parser, 'PyTokenizer'), "not using Basil's common parser"
+
+# XXX - Is there a better way to detect that we are in PyPy?
+print sys.version
+if "pypy" in sys.version:
+ cpy_parser = None
+ import parser
+else:
+ import parser as cpy_parser
+ del sys.modules['parser']
+ import pypy.module.parser.pyparser as parser
+ print dir(parser)
+ #assert hasattr(parser, 'PyTokenizer'), "not using Basil's common parser"
+ from pypy.objspace.std import StdObjSpace
+ space = StdObjSpace()
+ # XXX - This is a hack to get around the object space. Should take a
+ # closer look at these tests and build real PyPy tests, not hacked
+ # CPython-style tests. One might also note this is an application level
+ # test of interpreter level code, unless it is run in the mode given above.
+ old_suite = parser.suite
+ def new_suite (source):
+ return old_suite(space, source)
+ parser.suite = new_suite
class SimpleParserTestCase(unittest.TestCase):
def test_compile_empty_function(self):
- ast1 = parser.suite('def f(): pass')
- ast2 = cpy_parser.suite('def f(): pass')
-
- tup1 = parser.ast2tuple(ast1)
- tup2 = cpy_parser.ast2tuple(ast2)
+ source = "def f(): pass"
+
+ if cpy_parser != None:
+ ast1 = parser.suite(source)
+ tup1 = ast1.totuple()
+ ast2 = cpy_parser.suite(source)
+ tup2 = cpy_parser.ast2tuple(ast2)
+ else:
+ ast1 = parser.suite(source)
+ tup1 = parser.ast2tuple(ast1)
+ # XXX - This is hand computed against the 2.3.5 parser!
+ tup2 = (257,
+ (264,
+ (285,
+ (259,
+ (1, 'def'),
+ (1, 'f'),
+ (260,
+ (7, '('),
+ (8, ')')),
+ (11, ':'),
+ (291,
+ (265,
+ (266,
+ (271,
+ (1, 'pass'))),
+ (4, '')))))),
+ (0, ''))
self.assertEquals(tup1, tup2)
def test_compile_function(self):
source = "def f(x, arg1=None): return x"
- ast1 = parser.suite(source)
- ast2 = cpy_parser.suite(source)
-
- tup1 = parser.ast2tuple(ast1)
- tup2 = cpy_parser.ast2tuple(ast2)
-
+ if cpy_parser != None:
+ ast1 = parser.suite(source)
+ tup1 = parser.ast2tuple(ast1)
+ ast2 = cpy_parser.suite(source)
+ tup2 = cpy_parser.ast2tuple(ast2)
+ else:
+ # XXX - This is hand computed against the 2.3.5 parser!
+ ast1 = parser.suite(source)
+ tup1 = parser.ast2tuple(ast1)
+ tup2 = (257,
+ (264,
+ (285,
+ (259,
+ (1, 'def'),
+ (1, 'f'),
+ (260, (7, '('),
+ (261,
+ (262, (1, 'x')), (12, ','),
+ (262, (1, 'arg1')), (22, '='),
+ (292,
+ (293,
+ (294,
+ (295,
+ (297,
+ (298,
+ (299,
+ (300,
+ (301,
+ (302,
+ (303, (304, (305, (1, 'None'))))))))))))))),
+ (8, ')')),
+ (11, ':'),
+ (291,
+ (265,
+ (266,
+ (272,
+ (275, (1, 'return'),
+ (313,
+ (292,
+ (293,
+ (294,
+ (295,
+ (297,
+ (298,
+ (299,
+ (300,
+ (301,
+ (302,
+ (303,
+ (304, (305, (1, 'x')))))))))))))))))),
+ (4, '')))))), (0, ''))
self.assertEquals(tup1, tup2)
class SimpleCompilerTestCase(unittest.TestCase):
def test_compile_simple(self):
source = "def f(arg): return arg + 1\ni = f(41)"
co1, co2 = self.compile2(source)
- d1, d2 = {}, {}
- exec co1 in d1
+ d1, d2 = {}, {}
exec co2 in d2
- self.assertEquals(d1['i'], d2['i'])
+ if co1 != None:
+ exec co1 in d1
+ self.assertEquals(d1['i'], d2['i'])
+ else:
+ self.assertEquals(d2['i'], 42)
def compile2(self, source):
#ast1 = cpy_parser.suite(source)
More information about the Pypy-commit
mailing list