from test
import test_support
class TestSpecifics(unittest
.TestCase
):
def test_debug_assignment(self
):
# catch assignments to __debug__
self
.assertRaises(SyntaxError, compile, '__debug__ = 1', '?', 'single')
prev
= __builtin__
.__debug
__
setattr(__builtin__
, '__debug__', 'sure')
setattr(__builtin__
, '__debug__', prev
)
def test_argument_handling(self
):
# detect duplicate positional and keyword arguments
self
.assertRaises(SyntaxError, eval, 'lambda a,a:0')
self
.assertRaises(SyntaxError, eval, 'lambda a,a=1:0')
self
.assertRaises(SyntaxError, eval, 'lambda a=1,a=1:0')
self
.fail("duplicate arguments")
exec 'def f(a = 0, a = 1): pass'
self
.fail("duplicate keyword arguments")
exec 'def f(a): global a; a = 1'
self
.fail("variable is global and local")
def test_syntax_error(self
):
self
.assertRaises(SyntaxError, compile, "1+*3", "filename", "exec")
def test_duplicate_global_local(self
):
exec 'def f(a): global a; a = 1'
self
.fail("variable is global and local")
def test_exec_with_general_mapping_for_locals(self
):
"Test mapping interface versus possible calls from eval()."
def __getitem__(self
, key
):
def __setitem__(self
, key
, value
):
self
.results
= (key
, value
)
self
.assertEqual(m
.results
, ('z', 12))
self
.fail('Did not detect a KeyError')
self
.assertEqual(m
.results
, ('z', list('xyz')))
exec 'z = globals()' in g
, m
self
.assertEqual(m
.results
, ('z', g
))
exec 'z = locals()' in g
, m
self
.assertEqual(m
.results
, ('z', m
))
self
.fail('Did not validate globals as a real dict')
self
.fail('Did not validate locals as a mapping')
# Verify that dict subclasses work as well
def __getitem__(self
, key
):
return dict.__getitem
__(self
, key
)
self
.assertEqual(d
['z'], 12)
def test_complex_args(self
):
self
.assertEqual(comp_args((1, 2)), (1, 2))
def comp_args((a
, b
)=(3, 4)):
self
.assertEqual(comp_args((1, 2)), (1, 2))
self
.assertEqual(comp_args(), (3, 4))
def comp_args(a
, (b
, c
)):
self
.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
def comp_args(a
=2, (b
, c
)=(3, 4)):
self
.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
self
.assertEqual(comp_args(), (2, 3, 4))
def test_argument_order(self
):
exec 'def f(a=1, (b, c)): pass'
self
.fail("non-default args after default")
def test_float_literals(self
):
# testing bad float literals
self
.assertRaises(SyntaxError, eval, "2e")
self
.assertRaises(SyntaxError, eval, "2.0e+")
self
.assertRaises(SyntaxError, eval, "1e-")
self
.assertRaises(SyntaxError, eval, "3-4e/21")
def test_indentation(self
):
# testing compile() of indented block w/o trailing newline"
compile(s
, "<string>", "exec")
def test_literals_with_leading_zeroes(self
):
for arg
in ["077787", "0xj", "0x.", "0e", "090000000000000",
"080000000000000", "000000000000009", "000000000000008"]:
self
.assertRaises(SyntaxError, eval, arg
)
self
.assertEqual(eval("0777"), 511)
self
.assertEqual(eval("0777L"), 511)
self
.assertEqual(eval("000777"), 511)
self
.assertEqual(eval("0xff"), 255)
self
.assertEqual(eval("0xffL"), 255)
self
.assertEqual(eval("0XfF"), 255)
self
.assertEqual(eval("0777."), 777)
self
.assertEqual(eval("0777.0"), 777)
self
.assertEqual(eval("000000000000000000000000000000000000000000000000000777e0"), 777)
self
.assertEqual(eval("0777e1"), 7770)
self
.assertEqual(eval("0e0"), 0)
self
.assertEqual(eval("0000E-012"), 0)
self
.assertEqual(eval("09.5"), 9.5)
self
.assertEqual(eval("0777j"), 777j
)
self
.assertEqual(eval("00j"), 0j
)
self
.assertEqual(eval("00.0"), 0)
self
.assertEqual(eval("0e3"), 0)
self
.assertEqual(eval("090000000000000."), 90000000000000.)
self
.assertEqual(eval("090000000000000.0000000000000000000000"), 90000000000000.)
self
.assertEqual(eval("090000000000000e0"), 90000000000000.)
self
.assertEqual(eval("090000000000000e-0"), 90000000000000.)
self
.assertEqual(eval("090000000000000j"), 90000000000000j
)
self
.assertEqual(eval("000000000000007"), 7)
self
.assertEqual(eval("000000000000008."), 8.)
self
.assertEqual(eval("000000000000009."), 9.)
def test_unary_minus(self
):
# Verify treatment of unary minus on negative numbers SF bug #660455
if sys
.maxint
== 2147483647:
all_one_bits
= '0xffffffff'
self
.assertEqual(eval(all_one_bits
), 4294967295L)
self
.assertEqual(eval("-" + all_one_bits
), -4294967295L)
elif sys
.maxint
== 9223372036854775807:
all_one_bits
= '0xffffffffffffffff'
self
.assertEqual(eval(all_one_bits
), 18446744073709551615L)
self
.assertEqual(eval("-" + all_one_bits
), -18446744073709551615L)
self
.fail("How many bits *does* this machine have???")
def test_sequence_unpacking_error(self
):
# Verify sequence packing/unpacking with "or". SF bug #757818
def test_none_assignment(self
):
'for None in range(10): pass',
self
.assertRaises(SyntaxError, compile, stmt
, 'tmp', 'single')
self
.assertRaises(SyntaxError, compile, stmt
, 'tmp', 'exec')
'from __future__ import nested_scopes, generators',
'from __future__ import (nested_scopes,\ngenerators)',
'from __future__ import (nested_scopes,\ngenerators,)',
'from sys import stdin, stderr, stdout',
'from sys import (stdin, stderr,\nstdout)',
'from sys import (stdin, stderr,\nstdout,)',
'from sys import (stdin\n, stderr, stdout)',
'from sys import (stdin\n, stderr, stdout,)',
'from sys import stdin as si, stdout as so, stderr as se',
'from sys import (stdin as si, stdout as so, stderr as se)',
'from sys import (stdin as si, stdout as so, stderr as se,)',
'from (sys) import stdin',
'from __future__ import (nested_scopes',
'from __future__ import nested_scopes)',
'from __future__ import nested_scopes,\ngenerators',
'from sys import (stdin',
'from sys import stdin)',
'from sys import stdin, stdout,\nstderr',
'from sys import stdin si',
'from sys import (stdin,, stdout, stderr)',
'from sys import (stdin, stdout),',
compile(stmt
, 'tmp', 'exec')
self
.assertRaises(SyntaxError, compile, stmt
, 'tmp', 'exec')
def test_for_distinct_code_objects(self
):
self
.assertNotEqual(id(f1
.func_code
), id(f2
.func_code
))
test_support
.run_unittest(TestSpecifics
)
if __name__
== "__main__":