Lib/test/test_compile.py

   1 import unittest
   2 import warnings
   3 import sys
   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_duplicate_global_local(self):
  41         try:
  42             exec 'def f(a): global a; a = 1'
  43             self.fail("variable is global and local")
  44         except SyntaxError:
  45             pass
  46
  47     def test_exec_with_general_mapping_for_locals(self):
  48
  49         class M:
  50             "Test mapping interface versus possible calls from eval()."
  51             def __getitem__(self, key):
  52                 if key == 'a':
  53                     return 12
  54                 raise KeyError
  55             def __setitem__(self, key, value):
  56                 self.results = (key, value)
  57             def keys(self):
  58                 return list('xyz')
  59
  60         m = M()
  61         g = globals()
  62         exec 'z = a' in g, m
  63         self.assertEqual(m.results, ('z', 12))
  64         try:
  65             exec 'z = b' in g, m
  66         except NameError:
  67             pass
  68         else:
  69             self.fail('Did not detect a KeyError')
  70         exec 'z = dir()' in g, m
  71         self.assertEqual(m.results, ('z', list('xyz')))
  72         exec 'z = globals()' in g, m
  73         self.assertEqual(m.results, ('z', g))
  74         exec 'z = locals()' in g, m
  75         self.assertEqual(m.results, ('z', m))
  76         try:
  77             exec 'z = b' in m
  78         except TypeError:
  79             pass
  80         else:
  81             self.fail('Did not validate globals as a real dict')
  82
  83         class A:
  84             "Non-mapping"
  85             pass
  86         m = A()
  87         try:
  88             exec 'z = a' in g, m
  89         except TypeError:
  90             pass
  91         else:
  92             self.fail('Did not validate locals as a mapping')
  93
  94         # Verify that dict subclasses work as well
  95         class D(dict):
  96             def __getitem__(self, key):
  97                 if key == 'a':
  98                     return 12
  99                 return dict.__getitem__(self, key)
 100         d = D()
 101         exec 'z = a' in g, d
 102         self.assertEqual(d['z'], 12)
 103
 104     def test_extended_arg(self):
 105         longexpr = 'x = x or ' + '-x' * 2500
 106         code = '''
 107 def f(x):
 108     %s
 109     %s
 110     %s
 111     %s
 112     %s
 113     %s
 114     %s
 115     %s
 116     %s
 117     %s
 118     # the expressions above have no effect, x == argument
 119     while x:
 120         x -= 1
 121         # EXTENDED_ARG/JUMP_ABSOLUTE here
 122     return x
 123 ''' % ((longexpr,)*10)
 124         exec code
 125         self.assertEqual(f(5), 0)
 126
 127     def test_complex_args(self):
 128
 129         def comp_args((a, b)):
 130             return a,b
 131         self.assertEqual(comp_args((1, 2)), (1, 2))
 132
 133         def comp_args((a, b)=(3, 4)):
 134             return a, b
 135         self.assertEqual(comp_args((1, 2)), (1, 2))
 136         self.assertEqual(comp_args(), (3, 4))
 137
 138         def comp_args(a, (b, c)):
 139             return a, b, c
 140         self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
 141
 142         def comp_args(a=2, (b, c)=(3, 4)):
 143             return a, b, c
 144         self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
 145         self.assertEqual(comp_args(), (2, 3, 4))
 146
 147     def test_argument_order(self):
 148         try:
 149             exec 'def f(a=1, (b, c)): pass'
 150             self.fail("non-default args after default")
 151         except SyntaxError:
 152             pass
 153
 154     def test_float_literals(self):
 155         # testing bad float literals
 156         self.assertRaises(SyntaxError, eval, "2e")
 157         self.assertRaises(SyntaxError, eval, "2.0e+")
 158         self.assertRaises(SyntaxError, eval, "1e-")
 159         self.assertRaises(SyntaxError, eval, "3-4e/21")
 160
 161     def test_indentation(self):
 162         # testing compile() of indented block w/o trailing newline"
 163         s = """
 164 if 1:
 165     if 2:
 166         pass"""
 167         compile(s, "<string>", "exec")
 168
 169     def test_literals_with_leading_zeroes(self):
 170         for arg in ["077787", "0xj", "0x.", "0e",  "090000000000000",
 171                     "080000000000000", "000000000000009", "000000000000008"]:
 172             self.assertRaises(SyntaxError, eval, arg)
 173
 174         self.assertEqual(eval("0777"), 511)
 175         self.assertEqual(eval("0777L"), 511)
 176         self.assertEqual(eval("000777"), 511)
 177         self.assertEqual(eval("0xff"), 255)
 178         self.assertEqual(eval("0xffL"), 255)
 179         self.assertEqual(eval("0XfF"), 255)
 180         self.assertEqual(eval("0777."), 777)
 181         self.assertEqual(eval("0777.0"), 777)
 182         self.assertEqual(eval("000000000000000000000000000000000000000000000000000777e0"), 777)
 183         self.assertEqual(eval("0777e1"), 7770)
 184         self.assertEqual(eval("0e0"), 0)
 185         self.assertEqual(eval("0000E-012"), 0)
 186         self.assertEqual(eval("09.5"), 9.5)
 187         self.assertEqual(eval("0777j"), 777j)
 188         self.assertEqual(eval("00j"), 0j)
 189         self.assertEqual(eval("00.0"), 0)
 190         self.assertEqual(eval("0e3"), 0)
 191         self.assertEqual(eval("090000000000000."), 90000000000000.)
 192         self.assertEqual(eval("090000000000000.0000000000000000000000"), 90000000000000.)
 193         self.assertEqual(eval("090000000000000e0"), 90000000000000.)
 194         self.assertEqual(eval("090000000000000e-0"), 90000000000000.)
 195         self.assertEqual(eval("090000000000000j"), 90000000000000j)
 196         self.assertEqual(eval("000000000000007"), 7)
 197         self.assertEqual(eval("000000000000008."), 8.)
 198         self.assertEqual(eval("000000000000009."), 9.)
 199
 200     def test_unary_minus(self):
 201         # Verify treatment of unary minus on negative numbers SF bug #660455
 202         if sys.maxint == 2147483647:
 203             # 32-bit machine
 204             all_one_bits = '0xffffffff'
 205             self.assertEqual(eval(all_one_bits), 4294967295L)
 206             self.assertEqual(eval("-" + all_one_bits), -4294967295L)
 207         elif sys.maxint == 9223372036854775807:
 208             # 64-bit machine
 209             all_one_bits = '0xffffffffffffffff'
 210             self.assertEqual(eval(all_one_bits), 18446744073709551615L)
 211             self.assertEqual(eval("-" + all_one_bits), -18446744073709551615L)
 212         else:
 213             self.fail("How many bits *does* this machine have???")
 214
 215     def test_sequence_unpacking_error(self):
 216         # Verify sequence packing/unpacking with "or".  SF bug #757818
 217         i,j = (1, -1) or (-1, 1)
 218         self.assertEqual(i, 1)
 219         self.assertEqual(j, -1)
 220
 221     def test_none_assignment(self):
 222         stmts = [
 223             'None = 0',
 224             'None += 0',
 225             '__builtins__.None = 0',
 226             'def None(): pass',
 227             'class None: pass',
 228             '(a, None) = 0, 0',
 229             'for None in range(10): pass',
 230             'def f(None): pass',
 231         ]
 232         for stmt in stmts:
 233             stmt += "\n"
 234             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'single')
 235             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
 236
 237     def test_import(self):
 238         succeed = [
 239             'import sys',
 240             'import os, sys',
 241             'from __future__ import nested_scopes, generators',
 242             'from __future__ import (nested_scopes,\ngenerators)',
 243             'from __future__ import (nested_scopes,\ngenerators,)',
 244             'from sys import stdin, stderr, stdout',
 245             'from sys import (stdin, stderr,\nstdout)',
 246             'from sys import (stdin, stderr,\nstdout,)',
 247             'from sys import (stdin\n, stderr, stdout)',
 248             'from sys import (stdin\n, stderr, stdout,)',
 249             'from sys import stdin as si, stdout as so, stderr as se',
 250             'from sys import (stdin as si, stdout as so, stderr as se)',
 251             'from sys import (stdin as si, stdout as so, stderr as se,)',
 252             ]
 253         fail = [
 254             'import (os, sys)',
 255             'import (os), (sys)',
 256             'import ((os), (sys))',
 257             'import (sys',
 258             'import sys)',
 259             'import (os,)',
 260             'from (sys) import stdin',
 261             'from __future__ import (nested_scopes',
 262             'from __future__ import nested_scopes)',
 263             'from __future__ import nested_scopes,\ngenerators',
 264             'from sys import (stdin',
 265             'from sys import stdin)',
 266             'from sys import stdin, stdout,\nstderr',
 267             'from sys import stdin si',
 268             'from sys import stdin,'
 269             'from sys import (*)',
 270             'from sys import (stdin,, stdout, stderr)',
 271             'from sys import (stdin, stdout),',
 272             ]
 273         for stmt in succeed:
 274             compile(stmt, 'tmp', 'exec')
 275         for stmt in fail:
 276             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
 277
 278     def test_for_distinct_code_objects(self):
 279         # SF bug 1048870
 280         def f():
 281             f1 = lambda x=1: x
 282             f2 = lambda x=2: x
 283             return f1, f2
 284         f1, f2 = f()
 285         self.assertNotEqual(id(f1.func_code), id(f2.func_code))
 286
 287 def test_main():
 288     test_support.run_unittest(TestSpecifics)
 289
 290 if __name__ == "__main__":
 291     test_main()