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