home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / test_compile.py < prev    next >
Text File  |  2003-12-30  |  5KB  |  144 lines
  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()
  144.