| import compiler |
| from compiler.ast import flatten |
| import os, sys, time, unittest |
| import test.test_support |
| from random import random |
| |
| # How much time in seconds can pass before we print a 'Still working' message. |
| _PRINT_WORKING_MSG_INTERVAL = 5 * 60 |
| |
| class TrivialContext(object): |
| def __enter__(self): |
| return self |
| def __exit__(self, *exc_info): |
| pass |
| |
| class CompilerTest(unittest.TestCase): |
| |
| def testCompileLibrary(self): |
| # A simple but large test. Compile all the code in the |
| # standard library and its test suite. This doesn't verify |
| # that any of the code is correct, merely the compiler is able |
| # to generate some kind of code for it. |
| |
| next_time = time.time() + _PRINT_WORKING_MSG_INTERVAL |
| libdir = os.path.dirname(unittest.__file__) |
| testdir = os.path.dirname(test.test_support.__file__) |
| |
| for dir in [libdir, testdir]: |
| for basename in os.listdir(dir): |
| # Print still working message since this test can be really slow |
| if next_time <= time.time(): |
| next_time = time.time() + _PRINT_WORKING_MSG_INTERVAL |
| print(' testCompileLibrary still working, be patient...', file=sys.__stdout__) |
| sys.__stdout__.flush() |
| |
| if not basename.endswith(".py"): |
| continue |
| if not TEST_ALL and random() < 0.98: |
| continue |
| path = os.path.join(dir, basename) |
| if test.test_support.verbose: |
| print("compiling", path) |
| f = open(path, "U") |
| buf = f.read() |
| f.close() |
| if "badsyntax" in basename or "bad_coding" in basename: |
| self.assertRaises(SyntaxError, compiler.compile, |
| buf, basename, "exec") |
| else: |
| try: |
| compiler.compile(buf, basename, "exec") |
| except Exception as e: |
| args = list(e.args) |
| args[0] += "[in file %s]" % basename |
| e.args = tuple(args) |
| raise |
| |
| def testNewClassSyntax(self): |
| compiler.compile("class foo():pass\n\n","<string>","exec") |
| |
| def testYieldExpr(self): |
| compiler.compile("def g(): yield\n\n", "<string>", "exec") |
| |
| def testTryExceptFinally(self): |
| # Test that except and finally clauses in one try stmt are recognized |
| c = compiler.compile("try:\n 1/0\nexcept:\n e = 1\nfinally:\n f = 1", |
| "<string>", "exec") |
| dct = {} |
| exec(c, dct) |
| self.assertEquals(dct.get('e'), 1) |
| self.assertEquals(dct.get('f'), 1) |
| |
| def testDefaultArgs(self): |
| self.assertRaises(SyntaxError, compiler.parse, "def foo(a=1, b): pass") |
| |
| def testDocstrings(self): |
| c = compiler.compile('"doc"', '<string>', 'exec') |
| self.assert_('__doc__' in c.co_names) |
| c = compiler.compile('def f():\n "doc"', '<string>', 'exec') |
| g = {} |
| exec(c, g) |
| self.assertEquals(g['f'].__doc__, "doc") |
| |
| def testLineNo(self): |
| # Test that all nodes except Module have a correct lineno attribute. |
| filename = __file__ |
| if filename.endswith((".pyc", ".pyo")): |
| filename = filename[:-1] |
| tree = compiler.parseFile(filename) |
| self.check_lineno(tree) |
| |
| def check_lineno(self, node): |
| try: |
| self._check_lineno(node) |
| except AssertionError: |
| print(node.__class__, node.lineno) |
| raise |
| |
| def _check_lineno(self, node): |
| if not node.__class__ in NOLINENO: |
| self.assert_(isinstance(node.lineno, int), |
| "lineno=%s on %s" % (node.lineno, node.__class__)) |
| self.assert_(node.lineno > 0, |
| "lineno=%s on %s" % (node.lineno, node.__class__)) |
| for child in node.getChildNodes(): |
| self.check_lineno(child) |
| |
| def testFlatten(self): |
| self.assertEquals(flatten([1, [2]]), [1, 2]) |
| self.assertEquals(flatten((1, (2,))), [1, 2]) |
| |
| def testNestedScope(self): |
| c = compiler.compile('def g():\n' |
| ' a = 1\n' |
| ' def f(): return a + 2\n' |
| ' return f()\n' |
| 'result = g()', |
| '<string>', |
| 'exec') |
| dct = {} |
| exec(c, dct) |
| self.assertEquals(dct.get('result'), 3) |
| c = compiler.compile('def g(a):\n' |
| ' def f(): return a + 2\n' |
| ' return f()\n' |
| 'result = g(1)', |
| '<string>', |
| 'exec') |
| dct = {} |
| exec(c, dct) |
| self.assertEquals(dct.get('result'), 3) |
| c = compiler.compile('def g((a, b)):\n' |
| ' def f(): return a + b\n' |
| ' return f()\n' |
| 'result = g((1, 2))', |
| '<string>', |
| 'exec') |
| dct = {} |
| exec(c, dct) |
| self.assertEquals(dct.get('result'), 3) |
| |
| def testGenExp(self): |
| c = compiler.compile('list((i,j) for i in range(3) if i < 3' |
| ' for j in range(4) if j > 2)', |
| '<string>', |
| 'eval') |
| self.assertEquals(eval(c), [(0, 3), (1, 3), (2, 3)]) |
| |
| def testFuncAnnotations(self): |
| testdata = [ |
| ('def f(a: 1): pass', {'a': 1}), |
| ('''def f(a, (b:1, c:2, d), e:3=4, f=5, |
| *g:6, h:7, i=8, j:9=10, **k:11) -> 12: pass |
| ''', {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9, |
| 'k': 11, 'return': 12}), |
| ] |
| for sourcecode, expected in testdata: |
| # avoid IndentationError: unexpected indent from trailing lines |
| sourcecode = sourcecode.rstrip()+'\n' |
| c = compiler.compile(sourcecode, '<string>', 'exec') |
| dct = {} |
| exec(c, dct) |
| self.assertEquals(dct['f'].__annotations__, expected) |
| |
| def testWith(self): |
| # SF bug 1638243 |
| c = compiler.compile('from __future__ import with_statement\n' |
| 'def f():\n' |
| ' with TrivialContext():\n' |
| ' return 1\n' |
| 'result = f()', |
| '<string>', |
| 'exec' ) |
| dct = {'TrivialContext': TrivialContext} |
| exec(c, dct) |
| self.assertEquals(dct.get('result'), 1) |
| |
| def testWithAss(self): |
| c = compiler.compile('from __future__ import with_statement\n' |
| 'def f():\n' |
| ' with TrivialContext() as tc:\n' |
| ' return 1\n' |
| 'result = f()', |
| '<string>', |
| 'exec' ) |
| dct = {'TrivialContext': TrivialContext} |
| exec(c, dct) |
| self.assertEquals(dct.get('result'), 1) |
| |
| def testBytesLiteral(self): |
| c = compiler.compile("b'foo'", '<string>', 'eval') |
| b = eval(c) |
| |
| c = compiler.compile('def f(b=b"foo"):\n' |
| ' b[0] += 1\n' |
| ' return b\n' |
| 'f(); f(); result = f()\n', |
| '<string>', |
| 'exec') |
| dct = {} |
| exec(c, dct) |
| self.assertEquals(dct.get('result'), b"ioo") |
| |
| c = compiler.compile('def f():\n' |
| ' b = b"foo"\n' |
| ' b[0] += 1\n' |
| ' return b\n' |
| 'f(); f(); result = f()\n', |
| '<string>', |
| 'exec') |
| dct = {} |
| exec(c, dct) |
| self.assertEquals(dct.get('result'), b"goo") |
| |
| NOLINENO = (compiler.ast.Module, compiler.ast.Stmt, compiler.ast.Discard) |
| |
| ############################################################################### |
| # code below is just used to trigger some possible errors, for the benefit of |
| # testLineNo |
| ############################################################################### |
| |
| class Toto: |
| """docstring""" |
| pass |
| |
| a, b = 2, 3 |
| [c, d] = 5, 6 |
| l = [(x, y) for x, y in zip(range(5), range(5,10))] |
| l[0] |
| l[3:4] |
| d = {'a': 2} |
| d = {} |
| t = () |
| t = (1, 2) |
| l = [] |
| l = [1, 2] |
| if l: |
| pass |
| else: |
| a, b = b, a |
| |
| try: |
| print(yo) |
| except: |
| yo = 3 |
| else: |
| yo += 3 |
| |
| try: |
| a += b |
| finally: |
| b = 0 |
| |
| from math import * |
| |
| ############################################################################### |
| |
| def test_main(all=False): |
| global TEST_ALL |
| TEST_ALL = all or test.test_support.is_resource_enabled("compiler") |
| test.test_support.run_unittest(CompilerTest) |
| |
| if __name__ == "__main__": |
| import sys |
| test_main('all' in sys.argv) |