SF patch #736962. Converted test_compile to unittest format.
diff --git a/Lib/test/output/test_compile b/Lib/test/output/test_compile
deleted file mode 100644
index 303b745..0000000
--- a/Lib/test/output/test_compile
+++ /dev/null
@@ -1,7 +0,0 @@
-test_compile
-1 2
-1 2
-3 4
-1 2 3
-1 2 3
-2 3 4
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index f038249..4d4ba4f 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -1,163 +1,143 @@
-from test.test_support import verbose, TestFailed
+import unittest
+import warnings
+import sys
+from test import test_support
-if verbose:
- print "Testing whether compiler catches assignment to __debug__"
+class TestSpecifics(unittest.TestCase):
-try:
- compile('__debug__ = 1', '?', 'single')
-except SyntaxError:
- pass
+ def test_debug_assignment(self):
+ # catch assignments to __debug__
+ self.assertRaises(SyntaxError, compile, '__debug__ = 1', '?', 'single')
+ import __builtin__
+ prev = __builtin__.__debug__
+ setattr(__builtin__, '__debug__', 'sure')
+ setattr(__builtin__, '__debug__', prev)
-import __builtin__
-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')
+ try:
+ exec 'def f(a, a): pass'
+ self.fail("duplicate arguments")
+ except SyntaxError:
+ pass
+ try:
+ exec 'def f(a = 0, a = 1): pass'
+ self.fail("duplicate keyword arguments")
+ except SyntaxError:
+ pass
+ try:
+ exec 'def f(a): global a; a = 1'
+ self.fail("variable is global and local")
+ except SyntaxError:
+ pass
-if verbose:
- print 'Running tests on argument handling'
+ def test_syntax_error(self):
+ self.assertRaises(SyntaxError, compile, "1+*3", "filename", "exec")
-try:
- exec 'def f(a, a): pass'
- raise TestFailed, "duplicate arguments"
-except SyntaxError:
- pass
+ def test_duplicate_global_local(self):
+ try:
+ exec 'def f(a): global a; a = 1'
+ self.fail("variable is global and local")
+ except SyntaxError:
+ pass
-if verbose:
- print "compiling string with syntax error"
+ def test_complex_args(self):
-try:
- compile("1+*3", "filename", "exec")
-except SyntaxError, detail:
- if not detail.filename == "filename":
- raise TestFailed, "expected 'filename', got %r" % detail.filename
+ def comp_args((a, b)):
+ return a,b
+ self.assertEqual(comp_args((1, 2)), (1, 2))
-try:
- exec 'def f(a = 0, a = 1): pass'
- raise TestFailed, "duplicate keyword arguments"
-except SyntaxError:
- pass
+ def comp_args((a, b)=(3, 4)):
+ return a, b
+ self.assertEqual(comp_args((1, 2)), (1, 2))
+ self.assertEqual(comp_args(), (3, 4))
-try:
- exec 'def f(a): global a; a = 1'
- raise TestFailed, "variable is global and local"
-except SyntaxError:
- pass
+ def comp_args(a, (b, c)):
+ return a, b, c
+ self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
-if verbose:
- print "testing complex args"
+ def comp_args(a=2, (b, c)=(3, 4)):
+ return a, b, c
+ self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
+ self.assertEqual(comp_args(), (2, 3, 4))
-def comp_args((a, b)):
- print a,b
+ def test_argument_order(self):
+ try:
+ exec 'def f(a=1, (b, c)): pass'
+ self.fail("non-default args after default")
+ except SyntaxError:
+ pass
-comp_args((1, 2))
+ 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 comp_args((a, b)=(3, 4)):
- print a, b
-
-comp_args((1, 2))
-comp_args()
-
-def comp_args(a, (b, c)):
- print a, b, c
-
-comp_args(1, (2, 3))
-
-def comp_args(a=2, (b, c)=(3, 4)):
- print a, b, c
-
-comp_args(1, (2, 3))
-comp_args()
-
-try:
- exec 'def f(a=1, (b, c)): pass'
- raise TestFailed, "non-default args after default"
-except SyntaxError:
- pass
-
-if verbose:
- print "testing bad float literals"
-
-def expect_error(s):
- try:
- eval(s)
- raise TestFailed("%r accepted" % s)
- except SyntaxError:
- pass
-
-expect_error("2e")
-expect_error("2.0e+")
-expect_error("1e-")
-expect_error("3-4e/21")
-
-if verbose:
- print "testing compile() of indented block w/o trailing newline"
-
-s = """
+ def test_indentation(self):
+ # testing compile() of indented block w/o trailing newline"
+ s = """
if 1:
if 2:
pass"""
-compile(s, "<string>", "exec")
+ 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
+ warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning)
+ warnings.filterwarnings("ignore", "hex.* of negative int", FutureWarning)
+ # XXX Of course the following test will have to be changed in Python 2.4
+ # This test is in a <string> so the filterwarnings() can affect it
+ all_one_bits = '0xffffffff'
+ if sys.maxint != 2147483647:
+ all_one_bits = '0xffffffffffffffff'
+ self.assertEqual(eval(all_one_bits), -1)
+ self.assertEqual(eval("-" + all_one_bits), 1)
+
+ def test_sequence_unpacking_error(self):
+ # Verify sequence packing/unpacking with "or". SF bug #757818
+ i,j = (1, -1) or (-1, 1)
+ self.assertEqual(i, 1)
+ self.assertEqual(j, -1)
-if verbose:
- print "testing literals with leading zeroes"
+def test_main():
+ test_support.run_unittest(TestSpecifics)
-def expect_same(test_source, expected):
- got = eval(test_source)
- if got != expected:
- raise TestFailed("eval(%r) gave %r, but expected %r" %
- (test_source, got, expected))
-
-expect_error("077787")
-expect_error("0xj")
-expect_error("0x.")
-expect_error("0e")
-expect_same("0777", 511)
-expect_same("0777L", 511)
-expect_same("000777", 511)
-expect_same("0xff", 255)
-expect_same("0xffL", 255)
-expect_same("0XfF", 255)
-expect_same("0777.", 777)
-expect_same("0777.0", 777)
-expect_same("000000000000000000000000000000000000000000000000000777e0", 777)
-expect_same("0777e1", 7770)
-expect_same("0e0", 0)
-expect_same("0000E-012", 0)
-expect_same("09.5", 9.5)
-expect_same("0777j", 777j)
-expect_same("00j", 0j)
-expect_same("00.0", 0)
-expect_same("0e3", 0)
-expect_same("090000000000000.", 90000000000000.)
-expect_same("090000000000000.0000000000000000000000", 90000000000000.)
-expect_same("090000000000000e0", 90000000000000.)
-expect_same("090000000000000e-0", 90000000000000.)
-expect_same("090000000000000j", 90000000000000j)
-expect_error("090000000000000") # plain octal literal w/ decimal digit
-expect_error("080000000000000") # plain octal literal w/ decimal digit
-expect_error("000000000000009") # plain octal literal w/ decimal digit
-expect_error("000000000000008") # plain octal literal w/ decimal digit
-expect_same("000000000000007", 7)
-expect_same("000000000000008.", 8.)
-expect_same("000000000000009.", 9.)
-
-# Verify treatment of unary minus on negative numbers SF bug #660455
-import warnings
-warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning)
-warnings.filterwarnings("ignore", "hex.* of negative int", FutureWarning)
-# XXX Of course the following test will have to be changed in Python 2.4
-# This test is in a <string> so the filterwarnings() can affect it
-import sys
-all_one_bits = '0xffffffff'
-if sys.maxint != 2147483647:
- all_one_bits = '0xffffffffffffffff'
-exec """
-expect_same(all_one_bits, -1)
-expect_same("-" + all_one_bits, 1)
-"""
-
-# Verify sequence packing/unpacking with "or". SF bug #757818
-i,j = (1, -1) or (-1, 1)
-if i != 1 or j != -1:
- raise TestFailed, "Sequence packing/unpacking"
+if __name__ == "__main__":
+ test_main()