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_complex_args(self):
  48
  49         def comp_args((a, b)):
  50             return a,b
  51         self.assertEqual(comp_args((1, 2)), (1, 2))
  52
  53         def comp_args((a, b)=(3, 4)):
  54             return a, b
  55         self.assertEqual(comp_args((1, 2)), (1, 2))
  56         self.assertEqual(comp_args(), (3, 4))
  57
  58         def comp_args(a, (b, c)):
  59             return a, b, c
  60         self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
  61
  62         def comp_args(a=2, (b, c)=(3, 4)):
  63             return a, b, c
  64         self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
  65         self.assertEqual(comp_args(), (2, 3, 4))
  66
  67     def test_argument_order(self):
  68         try:
  69             exec 'def f(a=1, (b, c)): pass'
  70             self.fail("non-default args after default")
  71         except SyntaxError:
  72             pass
  73
  74     def test_float_literals(self):
  75         # testing bad float literals
  76         self.assertRaises(SyntaxError, eval, "2e")
  77         self.assertRaises(SyntaxError, eval, "2.0e+")
  78         self.assertRaises(SyntaxError, eval, "1e-")
  79         self.assertRaises(SyntaxError, eval, "3-4e/21")
  80
  81     def test_indentation(self):
  82         # testing compile() of indented block w/o trailing newline"
  83         s = """
  84 if 1:
  85     if 2:
  86         pass"""
  87         compile(s, "<string>", "exec")
  88
  89     def test_literals_with_leading_zeroes(self):
  90         for arg in ["077787", "0xj", "0x.", "0e",  "090000000000000",
  91                     "080000000000000", "000000000000009", "000000000000008"]:
  92             self.assertRaises(SyntaxError, eval, arg)
  93
  94         self.assertEqual(eval("0777"), 511)
  95         self.assertEqual(eval("0777L"), 511)
  96         self.assertEqual(eval("000777"), 511)
  97         self.assertEqual(eval("0xff"), 255)
  98         self.assertEqual(eval("0xffL"), 255)
  99         self.assertEqual(eval("0XfF"), 255)
 100         self.assertEqual(eval("0777."), 777)
 101         self.assertEqual(eval("0777.0"), 777)
 102         self.assertEqual(eval("000000000000000000000000000000000000000000000000000777e0"), 777)
 103         self.assertEqual(eval("0777e1"), 7770)
 104         self.assertEqual(eval("0e0"), 0)
 105         self.assertEqual(eval("0000E-012"), 0)
 106         self.assertEqual(eval("09.5"), 9.5)
 107         self.assertEqual(eval("0777j"), 777j)
 108         self.assertEqual(eval("00j"), 0j)
 109         self.assertEqual(eval("00.0"), 0)
 110         self.assertEqual(eval("0e3"), 0)
 111         self.assertEqual(eval("090000000000000."), 90000000000000.)
 112         self.assertEqual(eval("090000000000000.0000000000000000000000"), 90000000000000.)
 113         self.assertEqual(eval("090000000000000e0"), 90000000000000.)
 114         self.assertEqual(eval("090000000000000e-0"), 90000000000000.)
 115         self.assertEqual(eval("090000000000000j"), 90000000000000j)
 116         self.assertEqual(eval("000000000000007"), 7)
 117         self.assertEqual(eval("000000000000008."), 8.)
 118         self.assertEqual(eval("000000000000009."), 9.)
 119
 120     def test_unary_minus(self):
 121         # Verify treatment of unary minus on negative numbers SF bug #660455
 122         warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning)
 123         warnings.filterwarnings("ignore", "hex.* of negative int", FutureWarning)
 124         # XXX Of course the following test will have to be changed in Python 2.4
 125         # This test is in a <string> so the filterwarnings() can affect it
 126         all_one_bits = '0xffffffff'
 127         if sys.maxint != 2147483647:
 128             all_one_bits = '0xffffffffffffffff'
 129         self.assertEqual(eval(all_one_bits), -1)
 130         self.assertEqual(eval("-" + all_one_bits), 1)
 131
 132     def test_sequence_unpacking_error(self):
 133         # Verify sequence packing/unpacking with "or".  SF bug #757818
 134         i,j = (1, -1) or (-1, 1)
 135         self.assertEqual(i, 1)
 136         self.assertEqual(j, -1)
 137
 138
 139 def test_main():
 140     test_support.run_unittest(TestSpecifics)
 141
 142 if __name__ == "__main__":
 143     test_main()