home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_compile.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  16.5 KB  |  469 lines
  1. import unittest
  2. import sys
  3. import _ast
  4. from test import test_support
  5.  
  6. class TestSpecifics(unittest.TestCase):
  7.  
  8.     def test_debug_assignment(self):
  9.         # catch assignments to __debug__
  10.         self.assertRaises(SyntaxError, compile, '__debug__ = 1', '?', 'single')
  11.         import __builtin__
  12.         prev = __builtin__.__debug__
  13.         setattr(__builtin__, '__debug__', 'sure')
  14.         setattr(__builtin__, '__debug__', prev)
  15.  
  16.     def test_argument_handling(self):
  17.         # detect duplicate positional and keyword arguments
  18.         self.assertRaises(SyntaxError, eval, 'lambda a,a:0')
  19.         self.assertRaises(SyntaxError, eval, 'lambda a,a=1:0')
  20.         self.assertRaises(SyntaxError, eval, 'lambda a=1,a=1:0')
  21.         try:
  22.             exec 'def f(a, a): pass'
  23.             self.fail("duplicate arguments")
  24.         except SyntaxError:
  25.             pass
  26.         try:
  27.             exec 'def f(a = 0, a = 1): pass'
  28.             self.fail("duplicate keyword arguments")
  29.         except SyntaxError:
  30.             pass
  31.         try:
  32.             exec 'def f(a): global a; a = 1'
  33.             self.fail("variable is global and local")
  34.         except SyntaxError:
  35.             pass
  36.  
  37.     def test_syntax_error(self):
  38.         self.assertRaises(SyntaxError, compile, "1+*3", "filename", "exec")
  39.  
  40.     def test_none_keyword_arg(self):
  41.         self.assertRaises(SyntaxError, compile, "f(None=1)", "<string>", "exec")
  42.  
  43.     def test_duplicate_global_local(self):
  44.         try:
  45.             exec 'def f(a): global a; a = 1'
  46.             self.fail("variable is global and local")
  47.         except SyntaxError:
  48.             pass
  49.  
  50.     def test_exec_with_general_mapping_for_locals(self):
  51.  
  52.         class M:
  53.             "Test mapping interface versus possible calls from eval()."
  54.             def __getitem__(self, key):
  55.                 if key == 'a':
  56.                     return 12
  57.                 raise KeyError
  58.             def __setitem__(self, key, value):
  59.                 self.results = (key, value)
  60.             def keys(self):
  61.                 return list('xyz')
  62.  
  63.         m = M()
  64.         g = globals()
  65.         exec 'z = a' in g, m
  66.         self.assertEqual(m.results, ('z', 12))
  67.         try:
  68.             exec 'z = b' in g, m
  69.         except NameError:
  70.             pass
  71.         else:
  72.             self.fail('Did not detect a KeyError')
  73.         exec 'z = dir()' in g, m
  74.         self.assertEqual(m.results, ('z', list('xyz')))
  75.         exec 'z = globals()' in g, m
  76.         self.assertEqual(m.results, ('z', g))
  77.         exec 'z = locals()' in g, m
  78.         self.assertEqual(m.results, ('z', m))
  79.         try:
  80.             exec 'z = b' in m
  81.         except TypeError:
  82.             pass
  83.         else:
  84.             self.fail('Did not validate globals as a real dict')
  85.  
  86.         class A:
  87.             "Non-mapping"
  88.             pass
  89.         m = A()
  90.         try:
  91.             exec 'z = a' in g, m
  92.         except TypeError:
  93.             pass
  94.         else:
  95.             self.fail('Did not validate locals as a mapping')
  96.  
  97.         # Verify that dict subclasses work as well
  98.         class D(dict):
  99.             def __getitem__(self, key):
  100.                 if key == 'a':
  101.                     return 12
  102.                 return dict.__getitem__(self, key)
  103.         d = D()
  104.         exec 'z = a' in g, d
  105.         self.assertEqual(d['z'], 12)
  106.  
  107.     def test_extended_arg(self):
  108.         longexpr = 'x = x or ' + '-x' * 2500
  109.         code = '''
  110. def f(x):
  111.     %s
  112.     %s
  113.     %s
  114.     %s
  115.     %s
  116.     %s
  117.     %s
  118.     %s
  119.     %s
  120.     %s
  121.     # the expressions above have no effect, x == argument
  122.     while x:
  123.         x -= 1
  124.         # EXTENDED_ARG/JUMP_ABSOLUTE here
  125.     return x
  126. ''' % ((longexpr,)*10)
  127.         exec code
  128.         self.assertEqual(f(5), 0)
  129.  
  130.     def test_complex_args(self):
  131.  
  132.         def comp_args((a, b)):
  133.             return a,b
  134.         self.assertEqual(comp_args((1, 2)), (1, 2))
  135.  
  136.         def comp_args((a, b)=(3, 4)):
  137.             return a, b
  138.         self.assertEqual(comp_args((1, 2)), (1, 2))
  139.         self.assertEqual(comp_args(), (3, 4))
  140.  
  141.         def comp_args(a, (b, c)):
  142.             return a, b, c
  143.         self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
  144.  
  145.         def comp_args(a=2, (b, c)=(3, 4)):
  146.             return a, b, c
  147.         self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
  148.         self.assertEqual(comp_args(), (2, 3, 4))
  149.  
  150.     def test_argument_order(self):
  151.         try:
  152.             exec 'def f(a=1, (b, c)): pass'
  153.             self.fail("non-default args after default")
  154.         except SyntaxError:
  155.             pass
  156.  
  157.     def test_float_literals(self):
  158.         # testing bad float literals
  159.         self.assertRaises(SyntaxError, eval, "2e")
  160.         self.assertRaises(SyntaxError, eval, "2.0e+")
  161.         self.assertRaises(SyntaxError, eval, "1e-")
  162.         self.assertRaises(SyntaxError, eval, "3-4e/21")
  163.  
  164.     def test_indentation(self):
  165.         # testing compile() of indented block w/o trailing newline"
  166.         s = """
  167. if 1:
  168.     if 2:
  169.         pass"""
  170.         compile(s, "<string>", "exec")
  171.  
  172.     # This test is probably specific to CPython and may not generalize
  173.     # to other implementations.  We are trying to ensure that when
  174.     # the first line of code starts after 256, correct line numbers
  175.     # in tracebacks are still produced.
  176.     def test_leading_newlines(self):
  177.         s256 = "".join(["\n"] * 256 + ["spam"])
  178.         co = compile(s256, 'fn', 'exec')
  179.         self.assertEqual(co.co_firstlineno, 257)
  180.         self.assertEqual(co.co_lnotab, '')
  181.  
  182.     def test_literals_with_leading_zeroes(self):
  183.         for arg in ["077787", "0xj", "0x.", "0e",  "090000000000000",
  184.                     "080000000000000", "000000000000009", "000000000000008",
  185.                     "0b42", "0BADCAFE", "0o123456789", "0b1.1", "0o4.2",
  186.                     "0b101j2", "0o153j2", "0b100e1", "0o777e1", "0o8", "0o78"]:
  187.             self.assertRaises(SyntaxError, eval, arg)
  188.  
  189.         self.assertEqual(eval("0777"), 511)
  190.         self.assertEqual(eval("0777L"), 511)
  191.         self.assertEqual(eval("000777"), 511)
  192.         self.assertEqual(eval("0xff"), 255)
  193.         self.assertEqual(eval("0xffL"), 255)
  194.         self.assertEqual(eval("0XfF"), 255)
  195.         self.assertEqual(eval("0777."), 777)
  196.         self.assertEqual(eval("0777.0"), 777)
  197.         self.assertEqual(eval("000000000000000000000000000000000000000000000000000777e0"), 777)
  198.         self.assertEqual(eval("0777e1"), 7770)
  199.         self.assertEqual(eval("0e0"), 0)
  200.         self.assertEqual(eval("0000E-012"), 0)
  201.         self.assertEqual(eval("09.5"), 9.5)
  202.         self.assertEqual(eval("0777j"), 777j)
  203.         self.assertEqual(eval("00j"), 0j)
  204.         self.assertEqual(eval("00.0"), 0)
  205.         self.assertEqual(eval("0e3"), 0)
  206.         self.assertEqual(eval("090000000000000."), 90000000000000.)
  207.         self.assertEqual(eval("090000000000000.0000000000000000000000"), 90000000000000.)
  208.         self.assertEqual(eval("090000000000000e0"), 90000000000000.)
  209.         self.assertEqual(eval("090000000000000e-0"), 90000000000000.)
  210.         self.assertEqual(eval("090000000000000j"), 90000000000000j)
  211.         self.assertEqual(eval("000000000000007"), 7)
  212.         self.assertEqual(eval("000000000000008."), 8.)
  213.         self.assertEqual(eval("000000000000009."), 9.)
  214.         self.assertEqual(eval("0b101010"), 42)
  215.         self.assertEqual(eval("-0b000000000010"), -2)
  216.         self.assertEqual(eval("0o777"), 511)
  217.         self.assertEqual(eval("-0o0000010"), -8)
  218.         self.assertEqual(eval("020000000000.0"), 20000000000.0)
  219.         self.assertEqual(eval("037777777777e0"), 37777777777.0)
  220.         self.assertEqual(eval("01000000000000000000000.0"),
  221.                          1000000000000000000000.0)
  222.  
  223.     def test_unary_minus(self):
  224.         # Verify treatment of unary minus on negative numbers SF bug #660455
  225.         if sys.maxint == 2147483647:
  226.             # 32-bit machine
  227.             all_one_bits = '0xffffffff'
  228.             self.assertEqual(eval(all_one_bits), 4294967295L)
  229.             self.assertEqual(eval("-" + all_one_bits), -4294967295L)
  230.         elif sys.maxint == 9223372036854775807:
  231.             # 64-bit machine
  232.             all_one_bits = '0xffffffffffffffff'
  233.             self.assertEqual(eval(all_one_bits), 18446744073709551615L)
  234.             self.assertEqual(eval("-" + all_one_bits), -18446744073709551615L)
  235.         else:
  236.             self.fail("How many bits *does* this machine have???")
  237.         # Verify treatment of contant folding on -(sys.maxint+1)
  238.         # i.e. -2147483648 on 32 bit platforms.  Should return int, not long.
  239.         self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 1)), int))
  240.         self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 2)), long))
  241.  
  242.     if sys.maxint == 9223372036854775807:
  243.         def test_32_63_bit_values(self):
  244.             a = +4294967296  # 1 << 32
  245.             b = -4294967296  # 1 << 32
  246.             c = +281474976710656  # 1 << 48
  247.             d = -281474976710656  # 1 << 48
  248.             e = +4611686018427387904  # 1 << 62
  249.             f = -4611686018427387904  # 1 << 62
  250.             g = +9223372036854775807  # 1 << 63 - 1
  251.             h = -9223372036854775807  # 1 << 63 - 1
  252.  
  253.             for variable in self.test_32_63_bit_values.func_code.co_consts:
  254.                 if variable is not None:
  255.                     self.assertTrue(isinstance(variable, int))
  256.  
  257.     def test_sequence_unpacking_error(self):
  258.         # Verify sequence packing/unpacking with "or".  SF bug #757818
  259.         i,j = (1, -1) or (-1, 1)
  260.         self.assertEqual(i, 1)
  261.         self.assertEqual(j, -1)
  262.  
  263.     def test_none_assignment(self):
  264.         stmts = [
  265.             'None = 0',
  266.             'None += 0',
  267.             '__builtins__.None = 0',
  268.             'def None(): pass',
  269.             'class None: pass',
  270.             '(a, None) = 0, 0',
  271.             'for None in range(10): pass',
  272.             'def f(None): pass',
  273.         ]
  274.         for stmt in stmts:
  275.             stmt += "\n"
  276.             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'single')
  277.             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
  278.  
  279.     def test_import(self):
  280.         succeed = [
  281.             'import sys',
  282.             'import os, sys',
  283.             'import os as bar',
  284.             'import os.path as bar',
  285.             'from __future__ import nested_scopes, generators',
  286.             'from __future__ import (nested_scopes,\ngenerators)',
  287.             'from __future__ import (nested_scopes,\ngenerators,)',
  288.             'from sys import stdin, stderr, stdout',
  289.             'from sys import (stdin, stderr,\nstdout)',
  290.             'from sys import (stdin, stderr,\nstdout,)',
  291.             'from sys import (stdin\n, stderr, stdout)',
  292.             'from sys import (stdin\n, stderr, stdout,)',
  293.             'from sys import stdin as si, stdout as so, stderr as se',
  294.             'from sys import (stdin as si, stdout as so, stderr as se)',
  295.             'from sys import (stdin as si, stdout as so, stderr as se,)',
  296.             ]
  297.         fail = [
  298.             'import (os, sys)',
  299.             'import (os), (sys)',
  300.             'import ((os), (sys))',
  301.             'import (sys',
  302.             'import sys)',
  303.             'import (os,)',
  304.             'import os As bar',
  305.             'import os.path a bar',
  306.             'from sys import stdin As stdout',
  307.             'from sys import stdin a stdout',
  308.             'from (sys) import stdin',
  309.             'from __future__ import (nested_scopes',
  310.             'from __future__ import nested_scopes)',
  311.             'from __future__ import nested_scopes,\ngenerators',
  312.             'from sys import (stdin',
  313.             'from sys import stdin)',
  314.             'from sys import stdin, stdout,\nstderr',
  315.             'from sys import stdin si',
  316.             'from sys import stdin,'
  317.             'from sys import (*)',
  318.             'from sys import (stdin,, stdout, stderr)',
  319.             'from sys import (stdin, stdout),',
  320.             ]
  321.         for stmt in succeed:
  322.             compile(stmt, 'tmp', 'exec')
  323.         for stmt in fail:
  324.             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
  325.  
  326.     def test_for_distinct_code_objects(self):
  327.         # SF bug 1048870
  328.         def f():
  329.             f1 = lambda x=1: x
  330.             f2 = lambda x=2: x
  331.             return f1, f2
  332.         f1, f2 = f()
  333.         self.assertNotEqual(id(f1.func_code), id(f2.func_code))
  334.  
  335.     def test_unicode_encoding(self):
  336.         code = u"# -*- coding: utf-8 -*-\npass\n"
  337.         self.assertRaises(SyntaxError, compile, code, "tmp", "exec")
  338.  
  339.     def test_subscripts(self):
  340.         # SF bug 1448804
  341.         # Class to make testing subscript results easy
  342.         class str_map(object):
  343.             def __init__(self):
  344.                 self.data = {}
  345.             def __getitem__(self, key):
  346.                 return self.data[str(key)]
  347.             def __setitem__(self, key, value):
  348.                 self.data[str(key)] = value
  349.             def __delitem__(self, key):
  350.                 del self.data[str(key)]
  351.             def __contains__(self, key):
  352.                 return str(key) in self.data
  353.         d = str_map()
  354.         # Index
  355.         d[1] = 1
  356.         self.assertEqual(d[1], 1)
  357.         d[1] += 1
  358.         self.assertEqual(d[1], 2)
  359.         del d[1]
  360.         self.assertEqual(1 in d, False)
  361.         # Tuple of indices
  362.         d[1, 1] = 1
  363.         self.assertEqual(d[1, 1], 1)
  364.         d[1, 1] += 1
  365.         self.assertEqual(d[1, 1], 2)
  366.         del d[1, 1]
  367.         self.assertEqual((1, 1) in d, False)
  368.         # Simple slice
  369.         d[1:2] = 1
  370.         self.assertEqual(d[1:2], 1)
  371.         d[1:2] += 1
  372.         self.assertEqual(d[1:2], 2)
  373.         del d[1:2]
  374.         self.assertEqual(slice(1, 2) in d, False)
  375.         # Tuple of simple slices
  376.         d[1:2, 1:2] = 1
  377.         self.assertEqual(d[1:2, 1:2], 1)
  378.         d[1:2, 1:2] += 1
  379.         self.assertEqual(d[1:2, 1:2], 2)
  380.         del d[1:2, 1:2]
  381.         self.assertEqual((slice(1, 2), slice(1, 2)) in d, False)
  382.         # Extended slice
  383.         d[1:2:3] = 1
  384.         self.assertEqual(d[1:2:3], 1)
  385.         d[1:2:3] += 1
  386.         self.assertEqual(d[1:2:3], 2)
  387.         del d[1:2:3]
  388.         self.assertEqual(slice(1, 2, 3) in d, False)
  389.         # Tuple of extended slices
  390.         d[1:2:3, 1:2:3] = 1
  391.         self.assertEqual(d[1:2:3, 1:2:3], 1)
  392.         d[1:2:3, 1:2:3] += 1
  393.         self.assertEqual(d[1:2:3, 1:2:3], 2)
  394.         del d[1:2:3, 1:2:3]
  395.         self.assertEqual((slice(1, 2, 3), slice(1, 2, 3)) in d, False)
  396.         # Ellipsis
  397.         d[...] = 1
  398.         self.assertEqual(d[...], 1)
  399.         d[...] += 1
  400.         self.assertEqual(d[...], 2)
  401.         del d[...]
  402.         self.assertEqual(Ellipsis in d, False)
  403.         # Tuple of Ellipses
  404.         d[..., ...] = 1
  405.         self.assertEqual(d[..., ...], 1)
  406.         d[..., ...] += 1
  407.         self.assertEqual(d[..., ...], 2)
  408.         del d[..., ...]
  409.         self.assertEqual((Ellipsis, Ellipsis) in d, False)
  410.  
  411.     def test_mangling(self):
  412.         class A:
  413.             def f():
  414.                 __mangled = 1
  415.                 __not_mangled__ = 2
  416.                 import __mangled_mod
  417.                 import __package__.module
  418.  
  419.         self.assert_("_A__mangled" in A.f.func_code.co_varnames)
  420.         self.assert_("__not_mangled__" in A.f.func_code.co_varnames)
  421.         self.assert_("_A__mangled_mod" in A.f.func_code.co_varnames)
  422.         self.assert_("__package__" in A.f.func_code.co_varnames)
  423.  
  424.     def test_compile_ast(self):
  425.         fname = __file__
  426.         if fname.lower().endswith(('pyc', 'pyo')):
  427.             fname = fname[:-1]
  428.         with open(fname, 'r') as f:
  429.             fcontents = f.read()
  430.         sample_code = [
  431.             ['<assign>', 'x = 5'],
  432.             ['<print1>', 'print 1'],
  433.             ['<printv>', 'print v'],
  434.             ['<printTrue>', 'print True'],
  435.             ['<printList>', 'print []'],
  436.             ['<ifblock>', """if True:\n    pass\n"""],
  437.             ['<forblock>', """for n in [1, 2, 3]:\n    print n\n"""],
  438.             ['<deffunc>', """def foo():\n    pass\nfoo()\n"""],
  439.             [fname, fcontents],
  440.         ]
  441.  
  442.         for fname, code in sample_code:
  443.             co1 = compile(code, '%s1' % fname, 'exec')
  444.             ast = compile(code, '%s2' % fname, 'exec', _ast.PyCF_ONLY_AST)
  445.             self.assert_(type(ast) == _ast.Module)
  446.             co2 = compile(ast, '%s3' % fname, 'exec')
  447.             self.assertEqual(co1, co2)
  448.             # the code object's filename comes from the second compilation step
  449.             self.assertEqual(co2.co_filename, '%s3' % fname)
  450.  
  451.         # raise exception when node type doesn't match with compile mode
  452.         co1 = compile('print 1', '<string>', 'exec', _ast.PyCF_ONLY_AST)
  453.         self.assertRaises(TypeError, compile, co1, '<ast>', 'eval')
  454.  
  455.         # raise exception when node type is no start node
  456.         self.assertRaises(TypeError, compile, _ast.If(), '<ast>', 'exec')
  457.  
  458.         # raise exception when node has invalid children
  459.         ast = _ast.Module()
  460.         ast.body = [_ast.BoolOp()]
  461.         self.assertRaises(TypeError, compile, ast, '<ast>', 'exec')
  462.  
  463.  
  464. def test_main():
  465.     test_support.run_unittest(TestSpecifics)
  466.  
  467. if __name__ == "__main__":
  468.     test_main()
  469.