|
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() |