| 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 | # This test is probably specific to CPython and may not generalize
|
|---|
| 170 | # to other implementations. We are trying to ensure that when
|
|---|
| 171 | # the first line of code starts after 256, correct line numbers
|
|---|
| 172 | # in tracebacks are still produced.
|
|---|
| 173 | def test_leading_newlines(self):
|
|---|
| 174 | s256 = "".join(["\n"] * 256 + ["spam"])
|
|---|
| 175 | co = compile(s256, 'fn', 'exec')
|
|---|
| 176 | self.assertEqual(co.co_firstlineno, 257)
|
|---|
| 177 | self.assertEqual(co.co_lnotab, '')
|
|---|
| 178 |
|
|---|
| 179 | def test_literals_with_leading_zeroes(self):
|
|---|
| 180 | for arg in ["077787", "0xj", "0x.", "0e", "090000000000000",
|
|---|
| 181 | "080000000000000", "000000000000009", "000000000000008"]:
|
|---|
| 182 | self.assertRaises(SyntaxError, eval, arg)
|
|---|
| 183 |
|
|---|
| 184 | self.assertEqual(eval("0777"), 511)
|
|---|
| 185 | self.assertEqual(eval("0777L"), 511)
|
|---|
| 186 | self.assertEqual(eval("000777"), 511)
|
|---|
| 187 | self.assertEqual(eval("0xff"), 255)
|
|---|
| 188 | self.assertEqual(eval("0xffL"), 255)
|
|---|
| 189 | self.assertEqual(eval("0XfF"), 255)
|
|---|
| 190 | self.assertEqual(eval("0777."), 777)
|
|---|
| 191 | self.assertEqual(eval("0777.0"), 777)
|
|---|
| 192 | self.assertEqual(eval("000000000000000000000000000000000000000000000000000777e0"), 777)
|
|---|
| 193 | self.assertEqual(eval("0777e1"), 7770)
|
|---|
| 194 | self.assertEqual(eval("0e0"), 0)
|
|---|
| 195 | self.assertEqual(eval("0000E-012"), 0)
|
|---|
| 196 | self.assertEqual(eval("09.5"), 9.5)
|
|---|
| 197 | self.assertEqual(eval("0777j"), 777j)
|
|---|
| 198 | self.assertEqual(eval("00j"), 0j)
|
|---|
| 199 | self.assertEqual(eval("00.0"), 0)
|
|---|
| 200 | self.assertEqual(eval("0e3"), 0)
|
|---|
| 201 | self.assertEqual(eval("090000000000000."), 90000000000000.)
|
|---|
| 202 | self.assertEqual(eval("090000000000000.0000000000000000000000"), 90000000000000.)
|
|---|
| 203 | self.assertEqual(eval("090000000000000e0"), 90000000000000.)
|
|---|
| 204 | self.assertEqual(eval("090000000000000e-0"), 90000000000000.)
|
|---|
| 205 | self.assertEqual(eval("090000000000000j"), 90000000000000j)
|
|---|
| 206 | self.assertEqual(eval("000000000000007"), 7)
|
|---|
| 207 | self.assertEqual(eval("000000000000008."), 8.)
|
|---|
| 208 | self.assertEqual(eval("000000000000009."), 9.)
|
|---|
| 209 |
|
|---|
| 210 | def test_unary_minus(self):
|
|---|
| 211 | # Verify treatment of unary minus on negative numbers SF bug #660455
|
|---|
| 212 | if sys.maxint == 2147483647:
|
|---|
| 213 | # 32-bit machine
|
|---|
| 214 | all_one_bits = '0xffffffff'
|
|---|
| 215 | self.assertEqual(eval(all_one_bits), 4294967295L)
|
|---|
| 216 | self.assertEqual(eval("-" + all_one_bits), -4294967295L)
|
|---|
| 217 | elif sys.maxint == 9223372036854775807:
|
|---|
| 218 | # 64-bit machine
|
|---|
| 219 | all_one_bits = '0xffffffffffffffff'
|
|---|
| 220 | self.assertEqual(eval(all_one_bits), 18446744073709551615L)
|
|---|
| 221 | self.assertEqual(eval("-" + all_one_bits), -18446744073709551615L)
|
|---|
| 222 | else:
|
|---|
| 223 | self.fail("How many bits *does* this machine have???")
|
|---|
| 224 | # Verify treatment of contant folding on -(sys.maxint+1)
|
|---|
| 225 | # i.e. -2147483648 on 32 bit platforms. Should return int, not long.
|
|---|
| 226 | self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 1)), int))
|
|---|
| 227 | self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 2)), long))
|
|---|
| 228 |
|
|---|
| 229 | if sys.maxint == 9223372036854775807:
|
|---|
| 230 | def test_32_63_bit_values(self):
|
|---|
| 231 | a = +4294967296 # 1 << 32
|
|---|
| 232 | b = -4294967296 # 1 << 32
|
|---|
| 233 | c = +281474976710656 # 1 << 48
|
|---|
| 234 | d = -281474976710656 # 1 << 48
|
|---|
| 235 | e = +4611686018427387904 # 1 << 62
|
|---|
| 236 | f = -4611686018427387904 # 1 << 62
|
|---|
| 237 | g = +9223372036854775807 # 1 << 63 - 1
|
|---|
| 238 | h = -9223372036854775807 # 1 << 63 - 1
|
|---|
| 239 |
|
|---|
| 240 | for variable in self.test_32_63_bit_values.func_code.co_consts:
|
|---|
| 241 | if variable is not None:
|
|---|
| 242 | self.assertTrue(isinstance(variable, int))
|
|---|
| 243 |
|
|---|
| 244 | def test_sequence_unpacking_error(self):
|
|---|
| 245 | # Verify sequence packing/unpacking with "or". SF bug #757818
|
|---|
| 246 | i,j = (1, -1) or (-1, 1)
|
|---|
| 247 | self.assertEqual(i, 1)
|
|---|
| 248 | self.assertEqual(j, -1)
|
|---|
| 249 |
|
|---|
| 250 | def test_none_assignment(self):
|
|---|
| 251 | stmts = [
|
|---|
| 252 | 'None = 0',
|
|---|
| 253 | 'None += 0',
|
|---|
| 254 | '__builtins__.None = 0',
|
|---|
| 255 | 'def None(): pass',
|
|---|
| 256 | 'class None: pass',
|
|---|
| 257 | '(a, None) = 0, 0',
|
|---|
| 258 | 'for None in range(10): pass',
|
|---|
| 259 | 'def f(None): pass',
|
|---|
| 260 | ]
|
|---|
| 261 | for stmt in stmts:
|
|---|
| 262 | stmt += "\n"
|
|---|
| 263 | self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'single')
|
|---|
| 264 | self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
|
|---|
| 265 |
|
|---|
| 266 | def test_import(self):
|
|---|
| 267 | succeed = [
|
|---|
| 268 | 'import sys',
|
|---|
| 269 | 'import os, sys',
|
|---|
| 270 | 'import os as bar',
|
|---|
| 271 | 'import os.path as bar',
|
|---|
| 272 | 'from __future__ import nested_scopes, generators',
|
|---|
| 273 | 'from __future__ import (nested_scopes,\ngenerators)',
|
|---|
| 274 | 'from __future__ import (nested_scopes,\ngenerators,)',
|
|---|
| 275 | 'from sys import stdin, stderr, stdout',
|
|---|
| 276 | 'from sys import (stdin, stderr,\nstdout)',
|
|---|
| 277 | 'from sys import (stdin, stderr,\nstdout,)',
|
|---|
| 278 | 'from sys import (stdin\n, stderr, stdout)',
|
|---|
| 279 | 'from sys import (stdin\n, stderr, stdout,)',
|
|---|
| 280 | 'from sys import stdin as si, stdout as so, stderr as se',
|
|---|
| 281 | 'from sys import (stdin as si, stdout as so, stderr as se)',
|
|---|
| 282 | 'from sys import (stdin as si, stdout as so, stderr as se,)',
|
|---|
| 283 | ]
|
|---|
| 284 | fail = [
|
|---|
| 285 | 'import (os, sys)',
|
|---|
| 286 | 'import (os), (sys)',
|
|---|
| 287 | 'import ((os), (sys))',
|
|---|
| 288 | 'import (sys',
|
|---|
| 289 | 'import sys)',
|
|---|
| 290 | 'import (os,)',
|
|---|
| 291 | 'import os As bar',
|
|---|
| 292 | 'import os.path a bar',
|
|---|
| 293 | 'from sys import stdin As stdout',
|
|---|
| 294 | 'from sys import stdin a stdout',
|
|---|
| 295 | 'from (sys) import stdin',
|
|---|
| 296 | 'from __future__ import (nested_scopes',
|
|---|
| 297 | 'from __future__ import nested_scopes)',
|
|---|
| 298 | 'from __future__ import nested_scopes,\ngenerators',
|
|---|
| 299 | 'from sys import (stdin',
|
|---|
| 300 | 'from sys import stdin)',
|
|---|
| 301 | 'from sys import stdin, stdout,\nstderr',
|
|---|
| 302 | 'from sys import stdin si',
|
|---|
| 303 | 'from sys import stdin,'
|
|---|
| 304 | 'from sys import (*)',
|
|---|
| 305 | 'from sys import (stdin,, stdout, stderr)',
|
|---|
| 306 | 'from sys import (stdin, stdout),',
|
|---|
| 307 | ]
|
|---|
| 308 | for stmt in succeed:
|
|---|
| 309 | compile(stmt, 'tmp', 'exec')
|
|---|
| 310 | for stmt in fail:
|
|---|
| 311 | self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
|
|---|
| 312 |
|
|---|
| 313 | def test_for_distinct_code_objects(self):
|
|---|
| 314 | # SF bug 1048870
|
|---|
| 315 | def f():
|
|---|
| 316 | f1 = lambda x=1: x
|
|---|
| 317 | f2 = lambda x=2: x
|
|---|
| 318 | return f1, f2
|
|---|
| 319 | f1, f2 = f()
|
|---|
| 320 | self.assertNotEqual(id(f1.func_code), id(f2.func_code))
|
|---|
| 321 |
|
|---|
| 322 | def test_unicode_encoding(self):
|
|---|
| 323 | code = u"# -*- coding: utf-8 -*-\npass\n"
|
|---|
| 324 | self.assertRaises(SyntaxError, compile, code, "tmp", "exec")
|
|---|
| 325 |
|
|---|
| 326 | def test_subscripts(self):
|
|---|
| 327 | # SF bug 1448804
|
|---|
| 328 | # Class to make testing subscript results easy
|
|---|
| 329 | class str_map(object):
|
|---|
| 330 | def __init__(self):
|
|---|
| 331 | self.data = {}
|
|---|
| 332 | def __getitem__(self, key):
|
|---|
| 333 | return self.data[str(key)]
|
|---|
| 334 | def __setitem__(self, key, value):
|
|---|
| 335 | self.data[str(key)] = value
|
|---|
| 336 | def __delitem__(self, key):
|
|---|
| 337 | del self.data[str(key)]
|
|---|
| 338 | def __contains__(self, key):
|
|---|
| 339 | return str(key) in self.data
|
|---|
| 340 | d = str_map()
|
|---|
| 341 | # Index
|
|---|
| 342 | d[1] = 1
|
|---|
| 343 | self.assertEqual(d[1], 1)
|
|---|
| 344 | d[1] += 1
|
|---|
| 345 | self.assertEqual(d[1], 2)
|
|---|
| 346 | del d[1]
|
|---|
| 347 | self.assertEqual(1 in d, False)
|
|---|
| 348 | # Tuple of indices
|
|---|
| 349 | d[1, 1] = 1
|
|---|
| 350 | self.assertEqual(d[1, 1], 1)
|
|---|
| 351 | d[1, 1] += 1
|
|---|
| 352 | self.assertEqual(d[1, 1], 2)
|
|---|
| 353 | del d[1, 1]
|
|---|
| 354 | self.assertEqual((1, 1) in d, False)
|
|---|
| 355 | # Simple slice
|
|---|
| 356 | d[1:2] = 1
|
|---|
| 357 | self.assertEqual(d[1:2], 1)
|
|---|
| 358 | d[1:2] += 1
|
|---|
| 359 | self.assertEqual(d[1:2], 2)
|
|---|
| 360 | del d[1:2]
|
|---|
| 361 | self.assertEqual(slice(1, 2) in d, False)
|
|---|
| 362 | # Tuple of simple slices
|
|---|
| 363 | d[1:2, 1:2] = 1
|
|---|
| 364 | self.assertEqual(d[1:2, 1:2], 1)
|
|---|
| 365 | d[1:2, 1:2] += 1
|
|---|
| 366 | self.assertEqual(d[1:2, 1:2], 2)
|
|---|
| 367 | del d[1:2, 1:2]
|
|---|
| 368 | self.assertEqual((slice(1, 2), slice(1, 2)) in d, False)
|
|---|
| 369 | # Extended slice
|
|---|
| 370 | d[1:2:3] = 1
|
|---|
| 371 | self.assertEqual(d[1:2:3], 1)
|
|---|
| 372 | d[1:2:3] += 1
|
|---|
| 373 | self.assertEqual(d[1:2:3], 2)
|
|---|
| 374 | del d[1:2:3]
|
|---|
| 375 | self.assertEqual(slice(1, 2, 3) in d, False)
|
|---|
| 376 | # Tuple of extended slices
|
|---|
| 377 | d[1:2:3, 1:2:3] = 1
|
|---|
| 378 | self.assertEqual(d[1:2:3, 1:2:3], 1)
|
|---|
| 379 | d[1:2:3, 1:2:3] += 1
|
|---|
| 380 | self.assertEqual(d[1:2:3, 1:2:3], 2)
|
|---|
| 381 | del d[1:2:3, 1:2:3]
|
|---|
| 382 | self.assertEqual((slice(1, 2, 3), slice(1, 2, 3)) in d, False)
|
|---|
| 383 | # Ellipsis
|
|---|
| 384 | d[...] = 1
|
|---|
| 385 | self.assertEqual(d[...], 1)
|
|---|
| 386 | d[...] += 1
|
|---|
| 387 | self.assertEqual(d[...], 2)
|
|---|
| 388 | del d[...]
|
|---|
| 389 | self.assertEqual(Ellipsis in d, False)
|
|---|
| 390 | # Tuple of Ellipses
|
|---|
| 391 | d[..., ...] = 1
|
|---|
| 392 | self.assertEqual(d[..., ...], 1)
|
|---|
| 393 | d[..., ...] += 1
|
|---|
| 394 | self.assertEqual(d[..., ...], 2)
|
|---|
| 395 | del d[..., ...]
|
|---|
| 396 | self.assertEqual((Ellipsis, Ellipsis) in d, False)
|
|---|
| 397 |
|
|---|
| 398 | def test_main():
|
|---|
| 399 | test_support.run_unittest(TestSpecifics)
|
|---|
| 400 |
|
|---|
| 401 | if __name__ == "__main__":
|
|---|
| 402 | test_main()
|
|---|
