summaryrefslogtreecommitdiff
path: root/Lib/test
diff options
context:
space:
mode:
Diffstat (limited to 'Lib/test')
-rw-r--r--Lib/test/crashers/mutation_inside_cyclegc.py31
-rw-r--r--Lib/test/test_builtin.py659
-rw-r--r--Lib/test/test_cmd_line_script.py1
-rw-r--r--Lib/test/test_contextlib.py1
-rw-r--r--Lib/test/test_decimal.py26
-rw-r--r--Lib/test/test_float.py110
-rw-r--r--Lib/test/test_frozen.py1
-rw-r--r--Lib/test/test_import.py2
-rw-r--r--Lib/test/test_int.py304
-rw-r--r--Lib/test/test_io.py8
-rw-r--r--Lib/test/test_list.py16
-rw-r--r--Lib/test/test_long.py222
-rw-r--r--Lib/test/test_sundry.py25
-rw-r--r--Lib/test/test_support.py6
-rw-r--r--Lib/test/test_textwrap.py4
-rw-r--r--Lib/test/test_trace.py12
-rw-r--r--Lib/test/test_traceback.py30
-rw-r--r--Lib/test/test_tuple.py7
-rw-r--r--Lib/test/test_urllib2.py6
-rw-r--r--Lib/test/test_warnings.py71
-rw-r--r--Lib/test/test_with.py1
-rw-r--r--Lib/test/test_xmlrpc.py2
22 files changed, 829 insertions, 716 deletions
diff --git a/Lib/test/crashers/mutation_inside_cyclegc.py b/Lib/test/crashers/mutation_inside_cyclegc.py
new file mode 100644
index 0000000000..2b67398bcc
--- /dev/null
+++ b/Lib/test/crashers/mutation_inside_cyclegc.py
@@ -0,0 +1,31 @@
+
+# The cycle GC collector can be executed when any GC-tracked object is
+# allocated, e.g. during a call to PyList_New(), PyDict_New(), ...
+# Moreover, it can invoke arbitrary Python code via a weakref callback.
+# This means that there are many places in the source where an arbitrary
+# mutation could unexpectedly occur.
+
+# The example below shows list_slice() not expecting the call to
+# PyList_New to mutate the input list. (Of course there are many
+# more examples like this one.)
+
+
+import weakref
+
+class A(object):
+ pass
+
+def callback(x):
+ del lst[:]
+
+
+keepalive = []
+
+for i in range(100):
+ lst = [str(i)]
+ a = A()
+ a.cycle = a
+ keepalive.append(weakref.ref(a, callback))
+ del a
+ while lst:
+ keepalive.append(lst[:])
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 7244aff8ef..52b337c21c 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -484,201 +484,6 @@ class BuiltinTest(unittest.TestCase):
self.assertEqual(list(filter(lambda x: x>=3, (1, 2, 3, 4))), [3, 4])
self.assertRaises(TypeError, list, filter(42, (1, 2)))
- def test_float(self):
- self.assertEqual(float(3.14), 3.14)
- self.assertEqual(float(314), 314.0)
- self.assertEqual(float(314), 314.0)
- self.assertEqual(float(" 3.14 "), 3.14)
- self.assertRaises(ValueError, float, " 0x3.1 ")
- self.assertRaises(ValueError, float, " -0x3.p-1 ")
- self.assertEqual(float(str(b" \u0663.\u0661\u0664 ",'raw-unicode-escape')), 3.14)
- self.assertEqual(float("1"*10000), 1e10000) # Inf on both sides
-
- @run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE')
- def test_float_with_comma(self):
- # set locale to something that doesn't use '.' for the decimal point
- # float must not accept the locale specific decimal point but
- # it still has to accept the normal python syntac
- import locale
- if not locale.localeconv()['decimal_point'] == ',':
- return
-
- self.assertEqual(float(" 3.14 "), 3.14)
- self.assertEqual(float("+3.14 "), 3.14)
- self.assertEqual(float("-3.14 "), -3.14)
- self.assertEqual(float(".14 "), .14)
- self.assertEqual(float("3. "), 3.0)
- self.assertEqual(float("3.e3 "), 3000.0)
- self.assertEqual(float("3.2e3 "), 3200.0)
- self.assertEqual(float("2.5e-1 "), 0.25)
- self.assertEqual(float("5e-1"), 0.5)
- self.assertRaises(ValueError, float, " 3,14 ")
- self.assertRaises(ValueError, float, " +3,14 ")
- self.assertRaises(ValueError, float, " -3,14 ")
- self.assertRaises(ValueError, float, " 0x3.1 ")
- self.assertRaises(ValueError, float, " -0x3.p-1 ")
- self.assertEqual(float(" 25.e-1 "), 2.5)
- self.assertEqual(fcmp(float(" .25e-1 "), .025), 0)
-
- def test_floatconversion(self):
- # Make sure that calls to __float__() work properly
- class Foo0:
- def __float__(self):
- return 42.
-
- class Foo1(object):
- def __float__(self):
- return 42.
-
- class Foo2(float):
- def __float__(self):
- return 42.
-
- class Foo3(float):
- def __new__(cls, value=0.):
- return float.__new__(cls, 2*value)
-
- def __float__(self):
- return self
-
- class Foo4(float):
- def __float__(self):
- return 42
-
- self.assertAlmostEqual(float(Foo0()), 42.)
- self.assertAlmostEqual(float(Foo1()), 42.)
- self.assertAlmostEqual(float(Foo2()), 42.)
- self.assertAlmostEqual(float(Foo3(21)), 42.)
- self.assertRaises(TypeError, float, Foo4(42))
-
- def test_format(self):
- # Test the basic machinery of the format() builtin. Don't test
- # the specifics of the various formatters
- self.assertEqual(format(3, ''), '3')
-
- # Returns some classes to use for various tests. There's
- # an old-style version, and a new-style version
- def classes_new():
- class A(object):
- def __init__(self, x):
- self.x = x
- def __format__(self, format_spec):
- return str(self.x) + format_spec
- class DerivedFromA(A):
- pass
-
- class Simple(object): pass
- class DerivedFromSimple(Simple):
- def __init__(self, x):
- self.x = x
- def __format__(self, format_spec):
- return str(self.x) + format_spec
- class DerivedFromSimple2(DerivedFromSimple): pass
- return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2
-
- # In 3.0, classes_classic has the same meaning as classes_new
- def classes_classic():
- class A:
- def __init__(self, x):
- self.x = x
- def __format__(self, format_spec):
- return str(self.x) + format_spec
- class DerivedFromA(A):
- pass
-
- class Simple: pass
- class DerivedFromSimple(Simple):
- def __init__(self, x):
- self.x = x
- def __format__(self, format_spec):
- return str(self.x) + format_spec
- class DerivedFromSimple2(DerivedFromSimple): pass
- return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2
-
- def class_test(A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2):
- self.assertEqual(format(A(3), 'spec'), '3spec')
- self.assertEqual(format(DerivedFromA(4), 'spec'), '4spec')
- self.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc')
- self.assertEqual(format(DerivedFromSimple2(10), 'abcdef'),
- '10abcdef')
-
- class_test(*classes_new())
- class_test(*classes_classic())
-
- def empty_format_spec(value):
- # test that:
- # format(x, '') == str(x)
- # format(x) == str(x)
- self.assertEqual(format(value, ""), str(value))
- self.assertEqual(format(value), str(value))
-
- # for builtin types, format(x, "") == str(x)
- empty_format_spec(17**13)
- empty_format_spec(1.0)
- empty_format_spec(3.1415e104)
- empty_format_spec(-3.1415e104)
- empty_format_spec(3.1415e-104)
- empty_format_spec(-3.1415e-104)
- empty_format_spec(object)
- empty_format_spec(None)
-
- # TypeError because self.__format__ returns the wrong type
- class BadFormatResult:
- def __format__(self, format_spec):
- return 1.0
- self.assertRaises(TypeError, format, BadFormatResult(), "")
-
- # TypeError because format_spec is not unicode or str
- self.assertRaises(TypeError, format, object(), 4)
- self.assertRaises(TypeError, format, object(), object())
-
- # tests for object.__format__ really belong elsewhere, but
- # there's no good place to put them
- x = object().__format__('')
- self.assert_(x.startswith('<object object at'))
-
- # first argument to object.__format__ must be string
- self.assertRaises(TypeError, object().__format__, 3)
- self.assertRaises(TypeError, object().__format__, object())
- self.assertRaises(TypeError, object().__format__, None)
-
- # make sure we can take a subclass of str as a format spec
- class DerivedFromStr(str): pass
- self.assertEqual(format(0, DerivedFromStr('10')), ' 0')
-
- def test_floatasratio(self):
- for f, ratio in [
- (0.875, (7, 8)),
- (-0.875, (-7, 8)),
- (0.0, (0, 1)),
- (11.5, (23, 2)),
- ]:
- self.assertEqual(f.as_integer_ratio(), ratio)
-
- for i in range(10000):
- f = random.random()
- f *= 10 ** random.randint(-100, 100)
- n, d = f.as_integer_ratio()
- self.assertEqual(float(n).__truediv__(d), f)
-
- R = fractions.Fraction
- self.assertEqual(R(0, 1),
- R(*float(0.0).as_integer_ratio()))
- self.assertEqual(R(5, 2),
- R(*float(2.5).as_integer_ratio()))
- self.assertEqual(R(1, 2),
- R(*float(0.5).as_integer_ratio()))
- self.assertEqual(R(4728779608739021, 2251799813685248),
- R(*float(2.1).as_integer_ratio()))
- self.assertEqual(R(-4728779608739021, 2251799813685248),
- R(*float(-2.1).as_integer_ratio()))
- self.assertEqual(R(-2100, 1),
- R(*float(-2100.0).as_integer_ratio()))
-
- self.assertRaises(OverflowError, float('inf').as_integer_ratio)
- self.assertRaises(OverflowError, float('-inf').as_integer_ratio)
- self.assertRaises(ValueError, float('nan').as_integer_ratio)
-
def test_getattr(self):
import sys
self.assert_(getattr(sys, 'stdout') is sys.stdout)
@@ -737,266 +542,6 @@ class BuiltinTest(unittest.TestCase):
# Test input() later, alphabetized as if it were raw_input
- def test_int(self):
- self.assertEqual(int(314), 314)
- self.assertEqual(int(3.14), 3)
- self.assertEqual(int(314), 314)
- # Check that conversion from float truncates towards zero
- self.assertEqual(int(-3.14), -3)
- self.assertEqual(int(3.9), 3)
- self.assertEqual(int(-3.9), -3)
- self.assertEqual(int(3.5), 3)
- self.assertEqual(int(-3.5), -3)
- # Different base:
- self.assertEqual(int("10",16), 16)
- # Test conversion from strings and various anomalies
- # Testing with no sign at front
- for s, v in test_conv_no_sign:
- for prefix in "", " ", "\t", " \t\t ":
- ss = prefix + s
- vv = v
- try:
- self.assertEqual(int(ss), vv)
- except v:
- pass
- # No whitespaces allowed between + or - sign and the number
- for s, v in test_conv_sign:
- for sign in "+", "-":
- for prefix in "", " ", "\t", " \t\t ":
- ss = prefix + sign + s
- vv = v
- if sign == "-" and v is not ValueError:
- vv = -v
- try:
- self.assertEqual(int(ss), vv)
- except v:
- pass
-
- s = repr(-1-sys.maxsize)
- x = int(s)
- self.assertEqual(x+1, -sys.maxsize)
- self.assert_(isinstance(x, int))
- # should return long
- self.assertEqual(int(s[1:]), sys.maxsize+1)
-
- # should return long
- x = int(1e100)
- self.assert_(isinstance(x, int))
- x = int(-1e100)
- self.assert_(isinstance(x, int))
-
-
- # SF bug 434186: 0x80000000/2 != 0x80000000>>1.
- # Worked by accident in Windows release build, but failed in debug build.
- # Failed in all Linux builds.
- x = -1-sys.maxsize
- self.assertEqual(x >> 1, x//2)
-
- self.assertRaises(ValueError, int, '123\0')
- self.assertRaises(ValueError, int, '53', 40)
-
- # SF bug 1545497: embedded NULs were not detected with
- # explicit base
- self.assertRaises(ValueError, int, '123\0', 10)
- self.assertRaises(ValueError, int, '123\x00 245', 20)
-
- x = int('1' * 600)
- self.assert_(isinstance(x, int))
-
- x = int(chr(0x661) * 600)
- self.assert_(isinstance(x, int))
-
- self.assertRaises(TypeError, int, 1, 12)
-
- # tests with base 0
- self.assertRaises(ValueError, int, ' 0123 ', 0) # old octal syntax
- self.assertEqual(int('000', 0), 0)
- self.assertEqual(int('0o123', 0), 83)
- self.assertEqual(int('0x123', 0), 291)
- self.assertEqual(int('0b100', 0), 4)
- self.assertEqual(int(' 0O123 ', 0), 83)
- self.assertEqual(int(' 0X123 ', 0), 291)
- self.assertEqual(int(' 0B100 ', 0), 4)
-
- # without base still base 10
- self.assertEqual(int('0123'), 123)
- self.assertEqual(int('0123', 10), 123)
-
- # tests with prefix and base != 0
- self.assertEqual(int('0x123', 16), 291)
- self.assertEqual(int('0o123', 8), 83)
- self.assertEqual(int('0b100', 2), 4)
- self.assertEqual(int('0X123', 16), 291)
- self.assertEqual(int('0O123', 8), 83)
- self.assertEqual(int('0B100', 2), 4)
-
- # Bug 1679: "0x" is not a valid hex literal
- self.assertRaises(ValueError, int, "0x", 16)
- self.assertRaises(ValueError, int, "0x", 0)
-
-
- # SF bug 1334662: int(string, base) wrong answers
- # Various representations of 2**32 evaluated to 0
- # rather than 2**32 in previous versions
-
- self.assertEqual(int('100000000000000000000000000000000', 2), 4294967296)
- self.assertEqual(int('102002022201221111211', 3), 4294967296)
- self.assertEqual(int('10000000000000000', 4), 4294967296)
- self.assertEqual(int('32244002423141', 5), 4294967296)
- self.assertEqual(int('1550104015504', 6), 4294967296)
- self.assertEqual(int('211301422354', 7), 4294967296)
- self.assertEqual(int('40000000000', 8), 4294967296)
- self.assertEqual(int('12068657454', 9), 4294967296)
- self.assertEqual(int('4294967296', 10), 4294967296)
- self.assertEqual(int('1904440554', 11), 4294967296)
- self.assertEqual(int('9ba461594', 12), 4294967296)
- self.assertEqual(int('535a79889', 13), 4294967296)
- self.assertEqual(int('2ca5b7464', 14), 4294967296)
- self.assertEqual(int('1a20dcd81', 15), 4294967296)
- self.assertEqual(int('100000000', 16), 4294967296)
- self.assertEqual(int('a7ffda91', 17), 4294967296)
- self.assertEqual(int('704he7g4', 18), 4294967296)
- self.assertEqual(int('4f5aff66', 19), 4294967296)
- self.assertEqual(int('3723ai4g', 20), 4294967296)
- self.assertEqual(int('281d55i4', 21), 4294967296)
- self.assertEqual(int('1fj8b184', 22), 4294967296)
- self.assertEqual(int('1606k7ic', 23), 4294967296)
- self.assertEqual(int('mb994ag', 24), 4294967296)
- self.assertEqual(int('hek2mgl', 25), 4294967296)
- self.assertEqual(int('dnchbnm', 26), 4294967296)
- self.assertEqual(int('b28jpdm', 27), 4294967296)
- self.assertEqual(int('8pfgih4', 28), 4294967296)
- self.assertEqual(int('76beigg', 29), 4294967296)
- self.assertEqual(int('5qmcpqg', 30), 4294967296)
- self.assertEqual(int('4q0jto4', 31), 4294967296)
- self.assertEqual(int('4000000', 32), 4294967296)
- self.assertEqual(int('3aokq94', 33), 4294967296)
- self.assertEqual(int('2qhxjli', 34), 4294967296)
- self.assertEqual(int('2br45qb', 35), 4294967296)
- self.assertEqual(int('1z141z4', 36), 4294967296)
-
- # SF bug 1334662: int(string, base) wrong answers
- # Checks for proper evaluation of 2**32 + 1
- self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297)
- self.assertEqual(int('102002022201221111212', 3), 4294967297)
- self.assertEqual(int('10000000000000001', 4), 4294967297)
- self.assertEqual(int('32244002423142', 5), 4294967297)
- self.assertEqual(int('1550104015505', 6), 4294967297)
- self.assertEqual(int('211301422355', 7), 4294967297)
- self.assertEqual(int('40000000001', 8), 4294967297)
- self.assertEqual(int('12068657455', 9), 4294967297)
- self.assertEqual(int('4294967297', 10), 4294967297)
- self.assertEqual(int('1904440555', 11), 4294967297)
- self.assertEqual(int('9ba461595', 12), 4294967297)
- self.assertEqual(int('535a7988a', 13), 4294967297)
- self.assertEqual(int('2ca5b7465', 14), 4294967297)
- self.assertEqual(int('1a20dcd82', 15), 4294967297)
- self.assertEqual(int('100000001', 16), 4294967297)
- self.assertEqual(int('a7ffda92', 17), 4294967297)
- self.assertEqual(int('704he7g5', 18), 4294967297)
- self.assertEqual(int('4f5aff67', 19), 4294967297)
- self.assertEqual(int('3723ai4h', 20), 4294967297)
- self.assertEqual(int('281d55i5', 21), 4294967297)
- self.assertEqual(int('1fj8b185', 22), 4294967297)
- self.assertEqual(int('1606k7id', 23), 4294967297)
- self.assertEqual(int('mb994ah', 24), 4294967297)
- self.assertEqual(int('hek2mgm', 25), 4294967297)
- self.assertEqual(int('dnchbnn', 26), 4294967297)
- self.assertEqual(int('b28jpdn', 27), 4294967297)
- self.assertEqual(int('8pfgih5', 28), 4294967297)
- self.assertEqual(int('76beigh', 29), 4294967297)
- self.assertEqual(int('5qmcpqh', 30), 4294967297)
- self.assertEqual(int('4q0jto5', 31), 4294967297)
- self.assertEqual(int('4000001', 32), 4294967297)
- self.assertEqual(int('3aokq95', 33), 4294967297)
- self.assertEqual(int('2qhxjlj', 34), 4294967297)
- self.assertEqual(int('2br45qc', 35), 4294967297)
- self.assertEqual(int('1z141z5', 36), 4294967297)
-
- def test_intconversion(self):
- # Test __int__()
- class ClassicMissingMethods:
- pass
- self.assertRaises(TypeError, int, ClassicMissingMethods())
-
- class MissingMethods(object):
- pass
- self.assertRaises(TypeError, int, MissingMethods())
-
- class Foo0:
- def __int__(self):
- return 42
-
- class Foo1(object):
- def __int__(self):
- return 42
-
- class Foo2(int):
- def __int__(self):
- return 42
-
- class Foo3(int):
- def __int__(self):
- return self
-
- class Foo4(int):
- def __int__(self):
- return 42
-
- class Foo5(int):
- def __int__(self):
- return 42.
-
- self.assertEqual(int(Foo0()), 42)
- self.assertEqual(int(Foo1()), 42)
- self.assertEqual(int(Foo2()), 42)
- self.assertEqual(int(Foo3()), 0)
- self.assertEqual(int(Foo4()), 42)
- self.assertRaises(TypeError, int, Foo5())
-
- class Classic:
- pass
- for base in (object, Classic):
- class IntOverridesTrunc(base):
- def __int__(self):
- return 42
- def __trunc__(self):
- return -12
- self.assertEqual(int(IntOverridesTrunc()), 42)
-
- class JustTrunc(base):
- def __trunc__(self):
- return 42
- self.assertEqual(int(JustTrunc()), 42)
-
- for trunc_result_base in (object, Classic):
- class Integral(trunc_result_base):
- def __int__(self):
- return 42
-
- class TruncReturnsNonInt(base):
- def __trunc__(self):
- return Integral()
- self.assertEqual(int(TruncReturnsNonInt()), 42)
-
- class NonIntegral(trunc_result_base):
- def __trunc__(self):
- # Check that we avoid infinite recursion.
- return NonIntegral()
-
- class TruncReturnsNonIntegral(base):
- def __trunc__(self):
- return NonIntegral()
- try:
- int(TruncReturnsNonIntegral())
- except TypeError as e:
- self.assertEquals(str(e),
- "__trunc__ returned non-Integral"
- " (type NonIntegral)")
- else:
- self.fail("Failed to raise TypeError with %s" %
- ((base, trunc_result_base),))
-
def test_iter(self):
self.assertRaises(TypeError, iter)
self.assertRaises(TypeError, iter, 42, 42)
@@ -1054,187 +599,6 @@ class BuiltinTest(unittest.TestCase):
raise ValueError
self.assertRaises(ValueError, len, BadSeq())
- def test_list(self):
- self.assertEqual(list([]), [])
- l0_3 = [0, 1, 2, 3]
- l0_3_bis = list(l0_3)
- self.assertEqual(l0_3, l0_3_bis)
- self.assert_(l0_3 is not l0_3_bis)
- self.assertEqual(list(()), [])
- self.assertEqual(list((0, 1, 2, 3)), [0, 1, 2, 3])
- self.assertEqual(list(''), [])
- self.assertEqual(list('spam'), ['s', 'p', 'a', 'm'])
-
- if sys.maxsize == 0x7fffffff:
- # This test can currently only work on 32-bit machines.
- # XXX If/when PySequence_Length() returns a ssize_t, it should be
- # XXX re-enabled.
- # Verify clearing of bug #556025.
- # This assumes that the max data size (sys.maxsize) == max
- # address size this also assumes that the address size is at
- # least 4 bytes with 8 byte addresses, the bug is not well
- # tested
- #
- # Note: This test is expected to SEGV under Cygwin 1.3.12 or
- # earlier due to a newlib bug. See the following mailing list
- # thread for the details:
-
- # http://sources.redhat.com/ml/newlib/2002/msg00369.html
- self.assertRaises(MemoryError, list, range(sys.maxsize // 2))
-
- # This code used to segfault in Py2.4a3
- x = []
- x.extend(-y for y in x)
- self.assertEqual(x, [])
-
- def test_long(self):
- self.assertEqual(int(314), 314)
- self.assertEqual(int(3.14), 3)
- self.assertEqual(int(314), 314)
- # Check that conversion from float truncates towards zero
- self.assertEqual(int(-3.14), -3)
- self.assertEqual(int(3.9), 3)
- self.assertEqual(int(-3.9), -3)
- self.assertEqual(int(3.5), 3)
- self.assertEqual(int(-3.5), -3)
- self.assertEqual(int("-3"), -3)
- # Different base:
- self.assertEqual(int("10",16), 16)
- # Check conversions from string (same test set as for int(), and then some)
- LL = [
- ('1' + '0'*20, 10**20),
- ('1' + '0'*100, 10**100)
- ]
- for s, v in LL:
- for sign in "", "+", "-":
- for prefix in "", " ", "\t", " \t\t ":
- ss = prefix + sign + s
- vv = v
- if sign == "-" and v is not ValueError:
- vv = -v
- try:
- self.assertEqual(int(ss), int(vv))
- except v:
- pass
-
- self.assertRaises(ValueError, int, '123\0')
- self.assertRaises(ValueError, int, '53', 40)
- self.assertRaises(TypeError, int, 1, 12)
-
- # SF patch #1638879: embedded NULs were not detected with
- # explicit base
- self.assertRaises(ValueError, int, '123\0', 10)
- self.assertRaises(ValueError, int, '123\x00 245', 20)
-
- self.assertEqual(int('100000000000000000000000000000000', 2),
- 4294967296)
- self.assertEqual(int('102002022201221111211', 3), 4294967296)
- self.assertEqual(int('10000000000000000', 4), 4294967296)
- self.assertEqual(int('32244002423141', 5), 4294967296)
- self.assertEqual(int('1550104015504', 6), 4294967296)
- self.assertEqual(int('211301422354', 7), 4294967296)
- self.assertEqual(int('40000000000', 8), 4294967296)
- self.assertEqual(int('12068657454', 9), 4294967296)
- self.assertEqual(int('4294967296', 10), 4294967296)
- self.assertEqual(int('1904440554', 11), 4294967296)
- self.assertEqual(int('9ba461594', 12), 4294967296)
- self.assertEqual(int('535a79889', 13), 4294967296)
- self.assertEqual(int('2ca5b7464', 14), 4294967296)
- self.assertEqual(int('1a20dcd81', 15), 4294967296)
- self.assertEqual(int('100000000', 16), 4294967296)
- self.assertEqual(int('a7ffda91', 17), 4294967296)
- self.assertEqual(int('704he7g4', 18), 4294967296)
- self.assertEqual(int('4f5aff66', 19), 4294967296)
- self.assertEqual(int('3723ai4g', 20), 4294967296)
- self.assertEqual(int('281d55i4', 21), 4294967296)
- self.assertEqual(int('1fj8b184', 22), 4294967296)
- self.assertEqual(int('1606k7ic', 23), 4294967296)
- self.assertEqual(int('mb994ag', 24), 4294967296)
- self.assertEqual(int('hek2mgl', 25), 4294967296)
- self.assertEqual(int('dnchbnm', 26), 4294967296)
- self.assertEqual(int('b28jpdm', 27), 4294967296)
- self.assertEqual(int('8pfgih4', 28), 4294967296)
- self.assertEqual(int('76beigg', 29), 4294967296)
- self.assertEqual(int('5qmcpqg', 30), 4294967296)
- self.assertEqual(int('4q0jto4', 31), 4294967296)
- self.assertEqual(int('4000000', 32), 4294967296)
- self.assertEqual(int('3aokq94', 33), 4294967296)
- self.assertEqual(int('2qhxjli', 34), 4294967296)
- self.assertEqual(int('2br45qb', 35), 4294967296)
- self.assertEqual(int('1z141z4', 36), 4294967296)
-
- self.assertEqual(int('100000000000000000000000000000001', 2),
- 4294967297)
- self.assertEqual(int('102002022201221111212', 3), 4294967297)
- self.assertEqual(int('10000000000000001', 4), 4294967297)
- self.assertEqual(int('32244002423142', 5), 4294967297)
- self.assertEqual(int('1550104015505', 6), 4294967297)
- self.assertEqual(int('211301422355', 7), 4294967297)
- self.assertEqual(int('40000000001', 8), 4294967297)
- self.assertEqual(int('12068657455', 9), 4294967297)
- self.assertEqual(int('4294967297', 10), 4294967297)
- self.assertEqual(int('1904440555', 11), 4294967297)
- self.assertEqual(int('9ba461595', 12), 4294967297)
- self.assertEqual(int('535a7988a', 13), 4294967297)
- self.assertEqual(int('2ca5b7465', 14), 4294967297)
- self.assertEqual(int('1a20dcd82', 15), 4294967297)
- self.assertEqual(int('100000001', 16), 4294967297)
- self.assertEqual(int('a7ffda92', 17), 4294967297)
- self.assertEqual(int('704he7g5', 18), 4294967297)
- self.assertEqual(int('4f5aff67', 19), 4294967297)
- self.assertEqual(int('3723ai4h', 20), 4294967297)
- self.assertEqual(int('281d55i5', 21), 4294967297)
- self.assertEqual(int('1fj8b185', 22), 4294967297)
- self.assertEqual(int('1606k7id', 23), 4294967297)
- self.assertEqual(int('mb994ah', 24), 4294967297)
- self.assertEqual(int('hek2mgm', 25), 4294967297)
- self.assertEqual(int('dnchbnn', 26), 4294967297)
- self.assertEqual(int('b28jpdn', 27), 4294967297)
- self.assertEqual(int('8pfgih5', 28), 4294967297)
- self.assertEqual(int('76beigh', 29), 4294967297)
- self.assertEqual(int('5qmcpqh', 30), 4294967297)
- self.assertEqual(int('4q0jto5', 31), 4294967297)
- self.assertEqual(int('4000001', 32), 4294967297)
- self.assertEqual(int('3aokq95', 33), 4294967297)
- self.assertEqual(int('2qhxjlj', 34), 4294967297)
- self.assertEqual(int('2br45qc', 35), 4294967297)
- self.assertEqual(int('1z141z5', 36), 4294967297)
-
- def test_longconversion(self):
- # Test __long__()
- class Foo0:
- def __long__(self):
- return 42
-
- class Foo1(object):
- def __long__(self):
- return 42
-
- class Foo2(int):
- def __long__(self):
- return 42
-
- class Foo3(int):
- def __long__(self):
- return self
-
- class Foo4(int):
- def __long__(self):
- return 42
-
- class Foo5(int):
- def __long__(self):
- return 42.
-
- self.assertEqual(int(Foo0()), 42)
- self.assertEqual(int(Foo1()), 42)
- # XXX invokes __int__ now
- # self.assertEqual(long(Foo2()), 42L)
- self.assertEqual(int(Foo3()), 0)
- # XXX likewise
- # self.assertEqual(long(Foo4()), 42)
- # self.assertRaises(TypeError, long, Foo5())
-
def test_map(self):
self.assertEqual(
list(map(lambda x: x*x, range(1,4))),
@@ -1726,19 +1090,6 @@ class BuiltinTest(unittest.TestCase):
self.assertRaises(TypeError, setattr, sys, 1, 'spam')
self.assertRaises(TypeError, setattr)
- def test_str(self):
- self.assertEqual(str(''), '')
- self.assertEqual(str(0), '0')
- self.assertEqual(str(0), '0')
- self.assertEqual(str(()), '()')
- self.assertEqual(str([]), '[]')
- self.assertEqual(str({}), '{}')
- a = []
- a.append(a)
- self.assertEqual(str(a), '[[...]]')
- a = {}
- a[0] = a
- self.assertEqual(str(a), '{0: {...}}')
def test_sum(self):
self.assertEqual(sum([]), 0)
@@ -1761,16 +1112,6 @@ class BuiltinTest(unittest.TestCase):
raise ValueError
self.assertRaises(ValueError, sum, BadSeq())
- def test_tuple(self):
- self.assertEqual(tuple(()), ())
- t0_3 = (0, 1, 2, 3)
- t0_3_bis = tuple(t0_3)
- self.assert_(t0_3 is t0_3_bis)
- self.assertEqual(tuple([]), ())
- self.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3))
- self.assertEqual(tuple(''), ())
- self.assertEqual(tuple('spam'), ('s', 'p', 'a', 'm'))
-
def test_type(self):
self.assertEqual(type(''), type('123'))
self.assertNotEqual(type(''), type(()))
diff --git a/Lib/test/test_cmd_line_script.py b/Lib/test/test_cmd_line_script.py
index e21191665f..74031c9be1 100644
--- a/Lib/test/test_cmd_line_script.py
+++ b/Lib/test/test_cmd_line_script.py
@@ -1,5 +1,4 @@
# Tests command line execution of scripts
-from __future__ import with_statement
import unittest
import os
diff --git a/Lib/test/test_contextlib.py b/Lib/test/test_contextlib.py
index a3a9a5be69..51d2436ee8 100644
--- a/Lib/test/test_contextlib.py
+++ b/Lib/test/test_contextlib.py
@@ -1,6 +1,5 @@
"""Unit tests for contextlib.py, and other context managers."""
-from __future__ import with_statement
import sys
import os
diff --git a/Lib/test/test_decimal.py b/Lib/test/test_decimal.py
index a76b505bfe..bb27eec3e8 100644
--- a/Lib/test/test_decimal.py
+++ b/Lib/test/test_decimal.py
@@ -23,7 +23,6 @@ or Behaviour) to test each part, or without parameter to test both parts. If
you're working through IDLE, you can import this test module and call test_main()
with the corresponding argument.
"""
-from __future__ import with_statement
import glob
import math
@@ -47,10 +46,12 @@ Signals = tuple(getcontext().flags.keys())
def init():
global ORIGINAL_CONTEXT
ORIGINAL_CONTEXT = getcontext().copy()
- DefaultContext.prec = 9
- DefaultContext.rounding = ROUND_HALF_EVEN
- DefaultContext.traps = dict.fromkeys(Signals, 0)
- setcontext(DefaultContext)
+ DefaultTestContext = Context(
+ prec = 9,
+ rounding = ROUND_HALF_EVEN,
+ traps = dict.fromkeys(Signals, 0)
+ )
+ setcontext(DefaultTestContext)
TESTDATADIR = 'decimaltestdata'
if __name__ == '__main__':
@@ -180,8 +181,6 @@ class DecimalTest(unittest.TestCase):
"""
def setUp(self):
self.context = Context()
- for key in DefaultContext.traps.keys():
- DefaultContext.traps[key] = 1
self.ignore_list = ['#']
# Basically, a # means return NaN InvalidOperation.
# Different from a sNaN in trim
@@ -192,13 +191,6 @@ class DecimalTest(unittest.TestCase):
'minexponent' : self.change_min_exponent,
'clamp' : self.change_clamp}
- def tearDown(self):
- """Cleaning up enviroment."""
- # leaving context in original state
- for key in DefaultContext.traps.keys():
- DefaultContext.traps[key] = 0
- return
-
def eval_file(self, file):
global skip_expected
if skip_expected:
@@ -949,8 +941,8 @@ def thfunc1(cls):
test2 = d1/d3
cls.finish1.set()
- cls.assertEqual(test1, Decimal('0.333333333'))
- cls.assertEqual(test2, Decimal('0.333333333'))
+ cls.assertEqual(test1, Decimal('0.3333333333333333333333333333'))
+ cls.assertEqual(test2, Decimal('0.3333333333333333333333333333'))
return
def thfunc2(cls):
@@ -963,7 +955,7 @@ def thfunc2(cls):
cls.synchro.set()
cls.finish2.set()
- cls.assertEqual(test1, Decimal('0.333333333'))
+ cls.assertEqual(test1, Decimal('0.3333333333333333333333333333'))
cls.assertEqual(test2, Decimal('0.333333333333333333'))
return
diff --git a/Lib/test/test_float.py b/Lib/test/test_float.py
index e89d723fb5..5653c16070 100644
--- a/Lib/test/test_float.py
+++ b/Lib/test/test_float.py
@@ -9,6 +9,116 @@ import operator
INF = float("inf")
NAN = float("nan")
+class GeneralFloatCases(unittest.TestCase):
+
+ def test_float(self):
+ self.assertEqual(float(3.14), 3.14)
+ self.assertEqual(float(314), 314.0)
+ self.assertEqual(float(" 3.14 "), 3.14)
+ self.assertRaises(ValueError, float, " 0x3.1 ")
+ self.assertRaises(ValueError, float, " -0x3.p-1 ")
+ self.assertRaises(ValueError, float, " +0x3.p-1 ")
+ self.assertRaises(ValueError, float, "++3.14")
+ self.assertRaises(ValueError, float, "+-3.14")
+ self.assertRaises(ValueError, float, "-+3.14")
+ self.assertRaises(ValueError, float, "--3.14")
+ if have_unicode:
+ self.assertEqual(float(unicode(" 3.14 ")), 3.14)
+ self.assertEqual(float(unicode(" \u0663.\u0661\u0664 ",'raw-unicode-escape')), 3.14)
+ # Implementation limitation in PyFloat_FromString()
+ self.assertRaises(ValueError, float, unicode("1"*10000))
+
+ @test_support.run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE')
+ def test_float_with_comma(self):
+ # set locale to something that doesn't use '.' for the decimal point
+ # float must not accept the locale specific decimal point but
+ # it still has to accept the normal python syntac
+ import locale
+ if not locale.localeconv()['decimal_point'] == ',':
+ return
+
+ self.assertEqual(float(" 3.14 "), 3.14)
+ self.assertEqual(float("+3.14 "), 3.14)
+ self.assertEqual(float("-3.14 "), -3.14)
+ self.assertEqual(float(".14 "), .14)
+ self.assertEqual(float("3. "), 3.0)
+ self.assertEqual(float("3.e3 "), 3000.0)
+ self.assertEqual(float("3.2e3 "), 3200.0)
+ self.assertEqual(float("2.5e-1 "), 0.25)
+ self.assertEqual(float("5e-1"), 0.5)
+ self.assertRaises(ValueError, float, " 3,14 ")
+ self.assertRaises(ValueError, float, " +3,14 ")
+ self.assertRaises(ValueError, float, " -3,14 ")
+ self.assertRaises(ValueError, float, " 0x3.1 ")
+ self.assertRaises(ValueError, float, " -0x3.p-1 ")
+ self.assertRaises(ValueError, float, " +0x3.p-1 ")
+ self.assertEqual(float(" 25.e-1 "), 2.5)
+ self.assertEqual(fcmp(float(" .25e-1 "), .025), 0)
+
+ def test_floatconversion(self):
+ # Make sure that calls to __float__() work properly
+ class Foo0:
+ def __float__(self):
+ return 42.
+
+ class Foo1(object):
+ def __float__(self):
+ return 42.
+
+ class Foo2(float):
+ def __float__(self):
+ return 42.
+
+ class Foo3(float):
+ def __new__(cls, value=0.):
+ return float.__new__(cls, 2*value)
+
+ def __float__(self):
+ return self
+
+ class Foo4(float):
+ def __float__(self):
+ return 42
+
+ self.assertAlmostEqual(float(Foo0()), 42.)
+ self.assertAlmostEqual(float(Foo1()), 42.)
+ self.assertAlmostEqual(float(Foo2()), 42.)
+ self.assertAlmostEqual(float(Foo3(21)), 42.)
+ self.assertRaises(TypeError, float, Foo4(42))
+
+ def test_floatasratio(self):
+ for f, ratio in [
+ (0.875, (7, 8)),
+ (-0.875, (-7, 8)),
+ (0.0, (0, 1)),
+ (11.5, (23, 2)),
+ ]:
+ self.assertEqual(f.as_integer_ratio(), ratio)
+
+ for i in range(10000):
+ f = random.random()
+ f *= 10 ** random.randint(-100, 100)
+ n, d = f.as_integer_ratio()
+ self.assertEqual(float(n).__truediv__(d), f)
+
+ R = fractions.Fraction
+ self.assertEqual(R(0, 1),
+ R(*float(0.0).as_integer_ratio()))
+ self.assertEqual(R(5, 2),
+ R(*float(2.5).as_integer_ratio()))
+ self.assertEqual(R(1, 2),
+ R(*float(0.5).as_integer_ratio()))
+ self.assertEqual(R(4728779608739021, 2251799813685248),
+ R(*float(2.1).as_integer_ratio()))
+ self.assertEqual(R(-4728779608739021, 2251799813685248),
+ R(*float(-2.1).as_integer_ratio()))
+ self.assertEqual(R(-2100, 1),
+ R(*float(-2100.0).as_integer_ratio()))
+
+ self.assertRaises(OverflowError, float('inf').as_integer_ratio)
+ self.assertRaises(OverflowError, float('-inf').as_integer_ratio)
+ self.assertRaises(ValueError, float('nan').as_integer_ratio)
+
class FormatFunctionsTestCase(unittest.TestCase):
def setUp(self):
diff --git a/Lib/test/test_frozen.py b/Lib/test/test_frozen.py
index c86a24d10d..de45b23a37 100644
--- a/Lib/test/test_frozen.py
+++ b/Lib/test/test_frozen.py
@@ -1,5 +1,4 @@
# Test the frozen module defined in frozen.c.
-from __future__ import with_statement
from test.test_support import captured_stdout, run_unittest
import unittest
diff --git a/Lib/test/test_import.py b/Lib/test/test_import.py
index fe1da52c8c..1c9dd3a026 100644
--- a/Lib/test/test_import.py
+++ b/Lib/test/test_import.py
@@ -271,4 +271,6 @@ def test_main(verbose=None):
run_unittest(ImportTest, PathsTests, RelativeImport)
if __name__ == '__main__':
+ # test needs to be a package, so we can do relative import
+ from test.test_import import test_main
test_main()
diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py
new file mode 100644
index 0000000000..91d52735bd
--- /dev/null
+++ b/Lib/test/test_int.py
@@ -0,0 +1,304 @@
+import sys
+
+import unittest
+from test.test_support import run_unittest
+
+L = [
+ ('0', 0),
+ ('1', 1),
+ ('9', 9),
+ ('10', 10),
+ ('99', 99),
+ ('100', 100),
+ ('314', 314),
+ (' 314', 314),
+ ('314 ', 314),
+ (' \t\t 314 \t\t ', 314),
+ (repr(sys.maxsize), sys.maxsize),
+ (' 1x', ValueError),
+ (' 1 ', 1),
+ (' 1\02 ', ValueError),
+ ('', ValueError),
+ (' ', ValueError),
+ (' \t\t ', ValueError)
+]
+
+class IntTestCases(unittest.TestCase):
+
+ def test_basic(self):
+ self.assertEqual(int(314), 314)
+ self.assertEqual(int(3.14), 3)
+ # Check that conversion from float truncates towards zero
+ self.assertEqual(int(-3.14), -3)
+ self.assertEqual(int(3.9), 3)
+ self.assertEqual(int(-3.9), -3)
+ self.assertEqual(int(3.5), 3)
+ self.assertEqual(int(-3.5), -3)
+ # Different base:
+ self.assertEqual(int("10",16), 16)
+ # Test conversion from strings and various anomalies
+ for s, v in L:
+ for sign in "", "+", "-":
+ for prefix in "", " ", "\t", " \t\t ":
+ ss = prefix + sign + s
+ vv = v
+ if sign == "-" and v is not ValueError:
+ vv = -v
+ try:
+ self.assertEqual(int(ss), vv)
+ except ValueError:
+ pass
+
+ s = repr(-1-sys.maxsize)
+ x = int(s)
+ self.assertEqual(x+1, -sys.maxsize)
+ self.assert_(isinstance(x, int))
+ # should return long
+ self.assertEqual(int(s[1:]), sys.maxsize+1)
+
+ # should return long
+ x = int(1e100)
+ self.assert_(isinstance(x, int))
+ x = int(-1e100)
+ self.assert_(isinstance(x, int))
+
+
+ # SF bug 434186: 0x80000000/2 != 0x80000000>>1.
+ # Worked by accident in Windows release build, but failed in debug build.
+ # Failed in all Linux builds.
+ x = -1-sys.maxsize
+ self.assertEqual(x >> 1, x//2)
+
+ self.assertRaises(ValueError, int, '123\0')
+ self.assertRaises(ValueError, int, '53', 40)
+
+ # SF bug 1545497: embedded NULs were not detected with
+ # explicit base
+ self.assertRaises(ValueError, int, '123\0', 10)
+ self.assertRaises(ValueError, int, '123\x00 245', 20)
+
+ x = int('1' * 600)
+ self.assert_(isinstance(x, int))
+
+ self.assertRaises(TypeError, int, 1, 12)
+
+ self.assertEqual(int('0o123', 0), 83)
+ self.assertEqual(int('0x123', 16), 291)
+
+ # Bug 1679: "0x" is not a valid hex literal
+ self.assertRaises(ValueError, int, "0x", 16)
+ self.assertRaises(ValueError, int, "0x", 0)
+
+ self.assertRaises(ValueError, int, "0o", 8)
+ self.assertRaises(ValueError, int, "0o", 0)
+
+ self.assertRaises(ValueError, int, "0b", 2)
+ self.assertRaises(ValueError, int, "0b", 0)
+
+
+ # SF bug 1334662: int(string, base) wrong answers
+ # Various representations of 2**32 evaluated to 0
+ # rather than 2**32 in previous versions
+
+ self.assertEqual(int('100000000000000000000000000000000', 2), 4294967296)
+ self.assertEqual(int('102002022201221111211', 3), 4294967296)
+ self.assertEqual(int('10000000000000000', 4), 4294967296)
+ self.assertEqual(int('32244002423141', 5), 4294967296)
+ self.assertEqual(int('1550104015504', 6), 4294967296)
+ self.assertEqual(int('211301422354', 7), 4294967296)
+ self.assertEqual(int('40000000000', 8), 4294967296)
+ self.assertEqual(int('12068657454', 9), 4294967296)
+ self.assertEqual(int('4294967296', 10), 4294967296)
+ self.assertEqual(int('1904440554', 11), 4294967296)
+ self.assertEqual(int('9ba461594', 12), 4294967296)
+ self.assertEqual(int('535a79889', 13), 4294967296)
+ self.assertEqual(int('2ca5b7464', 14), 4294967296)
+ self.assertEqual(int('1a20dcd81', 15), 4294967296)
+ self.assertEqual(int('100000000', 16), 4294967296)
+ self.assertEqual(int('a7ffda91', 17), 4294967296)
+ self.assertEqual(int('704he7g4', 18), 4294967296)
+ self.assertEqual(int('4f5aff66', 19), 4294967296)
+ self.assertEqual(int('3723ai4g', 20), 4294967296)
+ self.assertEqual(int('281d55i4', 21), 4294967296)
+ self.assertEqual(int('1fj8b184', 22), 4294967296)
+ self.assertEqual(int('1606k7ic', 23), 4294967296)
+ self.assertEqual(int('mb994ag', 24), 4294967296)
+ self.assertEqual(int('hek2mgl', 25), 4294967296)
+ self.assertEqual(int('dnchbnm', 26), 4294967296)
+ self.assertEqual(int('b28jpdm', 27), 4294967296)
+ self.assertEqual(int('8pfgih4', 28), 4294967296)
+ self.assertEqual(int('76beigg', 29), 4294967296)
+ self.assertEqual(int('5qmcpqg', 30), 4294967296)
+ self.assertEqual(int('4q0jto4', 31), 4294967296)
+ self.assertEqual(int('4000000', 32), 4294967296)
+ self.assertEqual(int('3aokq94', 33), 4294967296)
+ self.assertEqual(int('2qhxjli', 34), 4294967296)
+ self.assertEqual(int('2br45qb', 35), 4294967296)
+ self.assertEqual(int('1z141z4', 36), 4294967296)
+
+ # tests with base 0
+ # this fails on 3.0, but in 2.x the old octal syntax is allowed
+ self.assertEqual(int(' 0o123 ', 0), 83)
+ self.assertEqual(int(' 0o123 ', 0), 83)
+ self.assertEqual(int('000', 0), 0)
+ self.assertEqual(int('0o123', 0), 83)
+ self.assertEqual(int('0x123', 0), 291)
+ self.assertEqual(int('0b100', 0), 4)
+ self.assertEqual(int(' 0O123 ', 0), 83)
+ self.assertEqual(int(' 0X123 ', 0), 291)
+ self.assertEqual(int(' 0B100 ', 0), 4)
+
+ # without base still base 10
+ self.assertEqual(int('0123'), 123)
+ self.assertEqual(int('0123', 10), 123)
+
+ # tests with prefix and base != 0
+ self.assertEqual(int('0x123', 16), 291)
+ self.assertEqual(int('0o123', 8), 83)
+ self.assertEqual(int('0b100', 2), 4)
+ self.assertEqual(int('0X123', 16), 291)
+ self.assertEqual(int('0O123', 8), 83)
+ self.assertEqual(int('0B100', 2), 4)
+
+ # the code has special checks for the first character after the
+ # type prefix
+ self.assertRaises(ValueError, int, '0b2', 2)
+ self.assertRaises(ValueError, int, '0b02', 2)
+ self.assertRaises(ValueError, int, '0B2', 2)
+ self.assertRaises(ValueError, int, '0B02', 2)
+ self.assertRaises(ValueError, int, '0o8', 8)
+ self.assertRaises(ValueError, int, '0o08', 8)
+ self.assertRaises(ValueError, int, '0O8', 8)
+ self.assertRaises(ValueError, int, '0O08', 8)
+ self.assertRaises(ValueError, int, '0xg', 16)
+ self.assertRaises(ValueError, int, '0x0g', 16)
+ self.assertRaises(ValueError, int, '0Xg', 16)
+ self.assertRaises(ValueError, int, '0X0g', 16)
+
+ # SF bug 1334662: int(string, base) wrong answers
+ # Checks for proper evaluation of 2**32 + 1
+ self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297)
+ self.assertEqual(int('102002022201221111212', 3), 4294967297)
+ self.assertEqual(int('10000000000000001', 4), 4294967297)
+ self.assertEqual(int('32244002423142', 5), 4294967297)
+ self.assertEqual(int('1550104015505', 6), 4294967297)
+ self.assertEqual(int('211301422355', 7), 4294967297)
+ self.assertEqual(int('40000000001', 8), 4294967297)
+ self.assertEqual(int('12068657455', 9), 4294967297)
+ self.assertEqual(int('4294967297', 10), 4294967297)
+ self.assertEqual(int('1904440555', 11), 4294967297)
+ self.assertEqual(int('9ba461595', 12), 4294967297)
+ self.assertEqual(int('535a7988a', 13), 4294967297)
+ self.assertEqual(int('2ca5b7465', 14), 4294967297)
+ self.assertEqual(int('1a20dcd82', 15), 4294967297)
+ self.assertEqual(int('100000001', 16), 4294967297)
+ self.assertEqual(int('a7ffda92', 17), 4294967297)
+ self.assertEqual(int('704he7g5', 18), 4294967297)
+ self.assertEqual(int('4f5aff67', 19), 4294967297)
+ self.assertEqual(int('3723ai4h', 20), 4294967297)
+ self.assertEqual(int('281d55i5', 21), 4294967297)
+ self.assertEqual(int('1fj8b185', 22), 4294967297)
+ self.assertEqual(int('1606k7id', 23), 4294967297)
+ self.assertEqual(int('mb994ah', 24), 4294967297)
+ self.assertEqual(int('hek2mgm', 25), 4294967297)
+ self.assertEqual(int('dnchbnn', 26), 4294967297)
+ self.assertEqual(int('b28jpdn', 27), 4294967297)
+ self.assertEqual(int('8pfgih5', 28), 4294967297)
+ self.assertEqual(int('76beigh', 29), 4294967297)
+ self.assertEqual(int('5qmcpqh', 30), 4294967297)
+ self.assertEqual(int('4q0jto5', 31), 4294967297)
+ self.assertEqual(int('4000001', 32), 4294967297)
+ self.assertEqual(int('3aokq95', 33), 4294967297)
+ self.assertEqual(int('2qhxjlj', 34), 4294967297)
+ self.assertEqual(int('2br45qc', 35), 4294967297)
+ self.assertEqual(int('1z141z5', 36), 4294967297)
+
+ def test_intconversion(self):
+ # Test __int__()
+ class ClassicMissingMethods:
+ pass
+ self.assertRaises(TypeError, int, ClassicMissingMethods())
+
+ class MissingMethods(object):
+ pass
+ self.assertRaises(TypeError, int, MissingMethods())
+
+ class Foo0:
+ def __int__(self):
+ return 42
+
+ class Foo1(object):
+ def __int__(self):
+ return 42
+
+ class Foo2(int):
+ def __int__(self):
+ return 42
+
+ class Foo3(int):
+ def __int__(self):
+ return self
+
+ class Foo4(int):
+ def __int__(self):
+ return 42
+
+ class Foo5(int):
+ def __int__(self):
+ return 42.
+
+ self.assertEqual(int(Foo0()), 42)
+ self.assertEqual(int(Foo1()), 42)
+ self.assertEqual(int(Foo2()), 42)
+ self.assertEqual(int(Foo3()), 0)
+ self.assertEqual(int(Foo4()), 42)
+ self.assertRaises(TypeError, int, Foo5())
+
+ class Classic:
+ pass
+ for base in (object, Classic):
+ class IntOverridesTrunc(base):
+ def __int__(self):
+ return 42
+ def __trunc__(self):
+ return -12
+ self.assertEqual(int(IntOverridesTrunc()), 42)
+
+ class JustTrunc(base):
+ def __trunc__(self):
+ return 42
+ self.assertEqual(int(JustTrunc()), 42)
+
+ for trunc_result_base in (object, Classic):
+ class Integral(trunc_result_base):
+ def __int__(self):
+ return 42
+
+ class TruncReturnsNonInt(base):
+ def __trunc__(self):
+ return Integral()
+ self.assertEqual(int(TruncReturnsNonInt()), 42)
+
+ class NonIntegral(trunc_result_base):
+ def __trunc__(self):
+ # Check that we avoid infinite recursion.
+ return NonIntegral()
+
+ class TruncReturnsNonIntegral(base):
+ def __trunc__(self):
+ return NonIntegral()
+ try:
+ int(TruncReturnsNonIntegral())
+ except TypeError as e:
+ self.assertEquals(str(e),
+ "__trunc__ returned non-Integral"
+ " (type NonIntegral)")
+ else:
+ self.fail("Failed to raise TypeError with %s" %
+ ((base, trunc_result_base),))
+
+def test_main():
+ run_unittest(IntTestCases)
+
+if __name__ == "__main__":
+ test_main()
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 0c37cc7397..ba3ceeb76c 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -1161,10 +1161,10 @@ class MiscIOTest(unittest.TestCase):
def test_main():
test_support.run_unittest(IOTest, BytesIOTest, StringIOTest,
- BufferedReaderTest,
- BufferedWriterTest, BufferedRWPairTest,
- BufferedRandomTest, TextIOWrapperTest,
- MiscIOTest)
+ BufferedReaderTest, BufferedWriterTest,
+ BufferedRWPairTest, BufferedRandomTest,
+ StatefulIncrementalDecoderTest,
+ TextIOWrapperTest, MiscIOTest)
if __name__ == "__main__":
unittest.main()
diff --git a/Lib/test/test_list.py b/Lib/test/test_list.py
index b3b2195071..3b851176d4 100644
--- a/Lib/test/test_list.py
+++ b/Lib/test/test_list.py
@@ -4,6 +4,22 @@ from test import test_support, list_tests
class ListTest(list_tests.CommonTest):
type2test = list
+ def test_basic(self):
+ self.assertEqual(list([]), [])
+ l0_3 = [0, 1, 2, 3]
+ l0_3_bis = list(l0_3)
+ self.assertEqual(l0_3, l0_3_bis)
+ self.assert_(l0_3 is not l0_3_bis)
+ self.assertEqual(list(()), [])
+ self.assertEqual(list((0, 1, 2, 3)), [0, 1, 2, 3])
+ self.assertEqual(list(''), [])
+ self.assertEqual(list('spam'), ['s', 'p', 'a', 'm'])
+
+ # This code used to segfault in Py2.4a3
+ x = []
+ x.extend(-y for y in x)
+ self.assertEqual(x, [])
+
def test_truth(self):
super().test_truth()
self.assert_(not [])
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
index f98ba8deac..7e159aaffa 100644
--- a/Lib/test/test_long.py
+++ b/Lib/test/test_long.py
@@ -1,5 +1,6 @@
import unittest
from test import test_support
+import sys
import random
@@ -33,6 +34,26 @@ del p2
# add complements & negations
special += [~x for x in special] + [-x for x in special]
+L = [
+ ('0', 0),
+ ('1', 1),
+ ('9', 9),
+ ('10', 10),
+ ('99', 99),
+ ('100', 100),
+ ('314', 314),
+ (' 314', 314),
+ ('314 ', 314),
+ (' \t\t 314 \t\t ', 314),
+ (repr(sys.maxsize), sys.maxsize),
+ (' 1x', ValueError),
+ (' 1 ', 1),
+ (' 1\02 ', ValueError),
+ ('', ValueError),
+ (' ', ValueError),
+ (' \t\t ', ValueError)
+]
+
class LongTest(unittest.TestCase):
@@ -229,8 +250,206 @@ class LongTest(unittest.TestCase):
x = self.getran(lenx)
self.check_format_1(x)
+ def test_long(self):
+ self.assertEqual(int(314), 314)
+ self.assertEqual(int(3.14), 3)
+ self.assertEqual(int(314), 314)
+ # Check that conversion from float truncates towards zero
+ self.assertEqual(int(-3.14), -3)
+ self.assertEqual(int(3.9), 3)
+ self.assertEqual(int(-3.9), -3)
+ self.assertEqual(int(3.5), 3)
+ self.assertEqual(int(-3.5), -3)
+ self.assertEqual(int("-3"), -3)
+ # Different base:
+ self.assertEqual(int("10",16), 16)
+ # Check conversions from string (same test set as for int(), and then some)
+ LL = [
+ ('1' + '0'*20, 10**20),
+ ('1' + '0'*100, 10**100)
+ ]
+ L2 = L[:]
+ for s, v in L2 + LL:
+ for sign in "", "+", "-":
+ for prefix in "", " ", "\t", " \t\t ":
+ ss = prefix + sign + s
+ vv = v
+ if sign == "-" and v is not ValueError:
+ vv = -v
+ try:
+ self.assertEqual(int(ss), int(vv))
+ except ValueError:
+ pass
+
+ self.assertRaises(ValueError, int, '123\0')
+ self.assertRaises(ValueError, int, '53', 40)
+ self.assertRaises(TypeError, int, 1, 12)
+
+ # SF patch #1638879: embedded NULs were not detected with
+ # explicit base
+ self.assertRaises(ValueError, int, '123\0', 10)
+ self.assertRaises(ValueError, int, '123\x00 245', 20)
+
+ self.assertEqual(int('100000000000000000000000000000000', 2),
+ 4294967296)
+ self.assertEqual(int('102002022201221111211', 3), 4294967296)
+ self.assertEqual(int('10000000000000000', 4), 4294967296)
+ self.assertEqual(int('32244002423141', 5), 4294967296)
+ self.assertEqual(int('1550104015504', 6), 4294967296)
+ self.assertEqual(int('211301422354', 7), 4294967296)
+ self.assertEqual(int('40000000000', 8), 4294967296)
+ self.assertEqual(int('12068657454', 9), 4294967296)
+ self.assertEqual(int('4294967296', 10), 4294967296)
+ self.assertEqual(int('1904440554', 11), 4294967296)
+ self.assertEqual(int('9ba461594', 12), 4294967296)
+ self.assertEqual(int('535a79889', 13), 4294967296)
+ self.assertEqual(int('2ca5b7464', 14), 4294967296)
+ self.assertEqual(int('1a20dcd81', 15), 4294967296)
+ self.assertEqual(int('100000000', 16), 4294967296)
+ self.assertEqual(int('a7ffda91', 17), 4294967296)
+ self.assertEqual(int('704he7g4', 18), 4294967296)
+ self.assertEqual(int('4f5aff66', 19), 4294967296)
+ self.assertEqual(int('3723ai4g', 20), 4294967296)
+ self.assertEqual(int('281d55i4', 21), 4294967296)
+ self.assertEqual(int('1fj8b184', 22), 4294967296)
+ self.assertEqual(int('1606k7ic', 23), 4294967296)
+ self.assertEqual(int('mb994ag', 24), 4294967296)
+ self.assertEqual(int('hek2mgl', 25), 4294967296)
+ self.assertEqual(int('dnchbnm', 26), 4294967296)
+ self.assertEqual(int('b28jpdm', 27), 4294967296)
+ self.assertEqual(int('8pfgih4', 28), 4294967296)
+ self.assertEqual(int('76beigg', 29), 4294967296)
+ self.assertEqual(int('5qmcpqg', 30), 4294967296)
+ self.assertEqual(int('4q0jto4', 31), 4294967296)
+ self.assertEqual(int('4000000', 32), 4294967296)
+ self.assertEqual(int('3aokq94', 33), 4294967296)
+ self.assertEqual(int('2qhxjli', 34), 4294967296)
+ self.assertEqual(int('2br45qb', 35), 4294967296)
+ self.assertEqual(int('1z141z4', 36), 4294967296)
+
+ self.assertEqual(int('100000000000000000000000000000001', 2),
+ 4294967297)
+ self.assertEqual(int('102002022201221111212', 3), 4294967297)
+ self.assertEqual(int('10000000000000001', 4), 4294967297)
+ self.assertEqual(int('32244002423142', 5), 4294967297)
+ self.assertEqual(int('1550104015505', 6), 4294967297)
+ self.assertEqual(int('211301422355', 7), 4294967297)
+ self.assertEqual(int('40000000001', 8), 4294967297)
+ self.assertEqual(int('12068657455', 9), 4294967297)
+ self.assertEqual(int('4294967297', 10), 4294967297)
+ self.assertEqual(int('1904440555', 11), 4294967297)
+ self.assertEqual(int('9ba461595', 12), 4294967297)
+ self.assertEqual(int('535a7988a', 13), 4294967297)
+ self.assertEqual(int('2ca5b7465', 14), 4294967297)
+ self.assertEqual(int('1a20dcd82', 15), 4294967297)
+ self.assertEqual(int('100000001', 16), 4294967297)
+ self.assertEqual(int('a7ffda92', 17), 4294967297)
+ self.assertEqual(int('704he7g5', 18), 4294967297)
+ self.assertEqual(int('4f5aff67', 19), 4294967297)
+ self.assertEqual(int('3723ai4h', 20), 4294967297)
+ self.assertEqual(int('281d55i5', 21), 4294967297)
+ self.assertEqual(int('1fj8b185', 22), 4294967297)
+ self.assertEqual(int('1606k7id', 23), 4294967297)
+ self.assertEqual(int('mb994ah', 24), 4294967297)
+ self.assertEqual(int('hek2mgm', 25), 4294967297)
+ self.assertEqual(int('dnchbnn', 26), 4294967297)
+ self.assertEqual(int('b28jpdn', 27), 4294967297)
+ self.assertEqual(int('8pfgih5', 28), 4294967297)
+ self.assertEqual(int('76beigh', 29), 4294967297)
+ self.assertEqual(int('5qmcpqh', 30), 4294967297)
+ self.assertEqual(int('4q0jto5', 31), 4294967297)
+ self.assertEqual(int('4000001', 32), 4294967297)
+ self.assertEqual(int('3aokq95', 33), 4294967297)
+ self.assertEqual(int('2qhxjlj', 34), 4294967297)
+ self.assertEqual(int('2br45qc', 35), 4294967297)
+ self.assertEqual(int('1z141z5', 36), 4294967297)
+
+
+ def test_conversion(self):
+ # Test __long__()
+ class ClassicMissingMethods:
+ pass
+ self.assertRaises(TypeError, int, ClassicMissingMethods())
+
+ class MissingMethods(object):
+ pass
+ self.assertRaises(TypeError, int, MissingMethods())
+
+ class Foo0:
+ def __int__(self):
+ return 42
+
+ class Foo1(object):
+ def __int__(self):
+ return 42
+
+ class Foo2(int):
+ def __int__(self):
+ return 42
+
+ class Foo3(int):
+ def __int__(self):
+ return self
+
+ class Foo4(int):
+ def __int__(self):
+ return 42
+
+ class Foo5(int):
+ def __int__(self):
+ return 42.
+
+ self.assertEqual(int(Foo0()), 42)
+ self.assertEqual(int(Foo1()), 42)
+ self.assertEqual(int(Foo2()), 42)
+ self.assertEqual(int(Foo3()), 0)
+ self.assertEqual(int(Foo4()), 42)
+ self.assertRaises(TypeError, int, Foo5())
+
+ class Classic:
+ pass
+ for base in (object, Classic):
+ class LongOverridesTrunc(base):
+ def __long__(self):
+ return 42
+ def __trunc__(self):
+ return -12
+ self.assertEqual(int(LongOverridesTrunc()), 42)
+
+ class JustTrunc(base):
+ def __trunc__(self):
+ return 42
+ self.assertEqual(int(JustTrunc()), 42)
+
+ for trunc_result_base in (object, Classic):
+ class Integral(trunc_result_base):
+ def __int__(self):
+ return 42
+
+ class TruncReturnsNonLong(base):
+ def __trunc__(self):
+ return Integral()
+ self.assertEqual(int(TruncReturnsNonLong()), 42)
+
+ class NonIntegral(trunc_result_base):
+ def __trunc__(self):
+ # Check that we avoid infinite recursion.
+ return NonIntegral()
+
+ class TruncReturnsNonIntegral(base):
+ def __trunc__(self):
+ return NonIntegral()
+ try:
+ int(TruncReturnsNonIntegral())
+ except TypeError as e:
+ self.assertEquals(str(e),
+ "__trunc__ returned non-Integral"
+ " (type NonIntegral)")
+ else:
+ self.fail("Failed to raise TypeError with %s" %
+ ((base, trunc_result_base),))
+
def test_misc(self):
- import sys
# check the extremes in int<->long conversion
hugepos = sys.maxsize
@@ -403,7 +622,6 @@ class LongTest(unittest.TestCase):
def test_mixed_compares(self):
eq = self.assertEqual
import math
- import sys
# We're mostly concerned with that mixing floats and longs does the
# right stuff, even when longs are too large to fit in a float.
diff --git a/Lib/test/test_sundry.py b/Lib/test/test_sundry.py
index 77d3f88dc1..9f58706de3 100644
--- a/Lib/test/test_sundry.py
+++ b/Lib/test/test_sundry.py
@@ -8,40 +8,23 @@ import warnings
class TestUntestedModules(unittest.TestCase):
def test_at_least_import_untested_modules(self):
with test_support.catch_warning():
- import BaseHTTPServer
- import DocXMLRPCServer
import CGIHTTPServer
- import SimpleHTTPServer
- import SimpleXMLRPCServer
import aifc
import bdb
import cgitb
- import cmd
import code
import compileall
- import distutils.archive_util
import distutils.bcppcompiler
import distutils.ccompiler
- import distutils.cmd
- import distutils.core
import distutils.cygwinccompiler
- import distutils.dep_util
- import distutils.dir_util
import distutils.emxccompiler
- import distutils.errors
- import distutils.extension
- import distutils.file_util
import distutils.filelist
- import distutils.log
if sys.platform.startswith('win'):
import distutils.msvccompiler
import distutils.mwerkscompiler
- import distutils.sysconfig
import distutils.text_file
import distutils.unixccompiler
- import distutils.util
- import distutils.version
import distutils.command.bdist_dumb
if sys.platform.startswith('win'):
@@ -52,23 +35,18 @@ class TestUntestedModules(unittest.TestCase):
import distutils.command.build_clib
import distutils.command.build_ext
import distutils.command.build
- import distutils.command.build_py
- import distutils.command.build_scripts
import distutils.command.clean
import distutils.command.config
import distutils.command.install_data
import distutils.command.install_egg_info
import distutils.command.install_headers
import distutils.command.install_lib
- import distutils.command.install
- import distutils.command.install_scripts
import distutils.command.register
import distutils.command.sdist
import distutils.command.upload
import encodings
import formatter
- import ftplib
import getpass
import htmlentitydefs
import ihooks
@@ -78,7 +56,6 @@ class TestUntestedModules(unittest.TestCase):
import linecache
import macurl2path
import mailcap
- import mutex
import nntplib
import nturl2path
import opcode
@@ -88,14 +65,12 @@ class TestUntestedModules(unittest.TestCase):
import py_compile
import rlcompleter
import sched
- import smtplib
import sndhdr
import statvfs
import sunau
import sunaudio
import symbol
import tabnanny
- import telnetlib
import timeit
import token
try:
diff --git a/Lib/test/test_support.py b/Lib/test/test_support.py
index f61e70af10..431b66bb09 100644
--- a/Lib/test/test_support.py
+++ b/Lib/test/test_support.py
@@ -473,8 +473,10 @@ def captured_output(stream_name):
import io
orig_stdout = getattr(sys, stream_name)
setattr(sys, stream_name, io.StringIO())
- yield getattr(sys, stream_name)
- setattr(sys, stream_name, orig_stdout)
+ try:
+ yield getattr(sys, stream_name)
+ finally:
+ setattr(sys, stream_name, orig_stdout)
def captured_stdout():
return captured_output("stdout")
diff --git a/Lib/test/test_textwrap.py b/Lib/test/test_textwrap.py
index 3f2239d320..dc97d40d74 100644
--- a/Lib/test/test_textwrap.py
+++ b/Lib/test/test_textwrap.py
@@ -129,6 +129,10 @@ What a mess!
expect = ['And she said, "Go to hell!" Can you believe that?']
self.check(wrapper.wrap(text), expect)
+ text = 'File stdio.h is nice.'
+ expect = ['File stdio.h is nice.']
+ self.check(wrapper.wrap(text), expect)
+
def test_wrap_short(self):
# Wrapping to make short lines longer
diff --git a/Lib/test/test_trace.py b/Lib/test/test_trace.py
index 635e1bccbe..9ecd995841 100644
--- a/Lib/test/test_trace.py
+++ b/Lib/test/test_trace.py
@@ -4,6 +4,7 @@ from test import test_support
import unittest
import sys
import difflib
+import gc
# A very basic example. If this fails, we're in deep trouble.
def basic():
@@ -244,6 +245,17 @@ class Tracer:
return self.trace
class TraceTestCase(unittest.TestCase):
+
+ # Disable gc collection when tracing, otherwise the
+ # deallocators may be traced as well.
+ def setUp(self):
+ self.using_gc = gc.isenabled()
+ gc.disable()
+
+ def tearDown(self):
+ if self.using_gc:
+ gc.enable()
+
def compare_events(self, line_offset, events, expected_events):
events = [(l - line_offset, e) for (l, e) in events]
if events != expected_events:
diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py
index 93e512601d..600c7b5eef 100644
--- a/Lib/test/test_traceback.py
+++ b/Lib/test/test_traceback.py
@@ -1,10 +1,24 @@
"""Test cases for traceback module"""
+from _testcapi import traceback_print
+from io import StringIO
+import sys
import unittest
-from test.test_support import run_unittest, is_jython
+from test.test_support import run_unittest, is_jython, Error
import traceback
+try:
+ raise KeyError
+except KeyError:
+ type_, value, tb = sys.exc_info()
+ file_ = StringIO()
+ traceback_print(tb, file_)
+ example_traceback = file_.getvalue()
+else:
+ raise Error("unable to create test traceback string")
+
+
class TracebackCases(unittest.TestCase):
# For now, a very minimal set of tests. I want to be sure that
# formatting of SyntaxErrors works based on changes for 2.1.
@@ -76,8 +90,20 @@ class TracebackCases(unittest.TestCase):
self.assertEqual(err, ['None\n'])
+class TracebackFormatTests(unittest.TestCase):
+
+ def test_traceback_indentation(self):
+ # Make sure that the traceback is properly indented.
+ tb_lines = example_traceback.splitlines()
+ self.assertEquals(len(tb_lines), 3)
+ banner, location, source_line = tb_lines
+ self.assert_(banner.startswith('Traceback'))
+ self.assert_(location.startswith(' File'))
+ self.assert_(source_line.startswith('raise'))
+
+
def test_main():
- run_unittest(TracebackCases)
+ run_unittest(TracebackCases, TracebackFormatTests)
if __name__ == "__main__":
diff --git a/Lib/test/test_tuple.py b/Lib/test/test_tuple.py
index 62c5d71702..77672e7123 100644
--- a/Lib/test/test_tuple.py
+++ b/Lib/test/test_tuple.py
@@ -7,6 +7,13 @@ class TupleTest(seq_tests.CommonTest):
super().test_len()
# calling built-in types without argument must return empty
self.assertEqual(tuple(), ())
+ t0_3 = (0, 1, 2, 3)
+ t0_3_bis = tuple(t0_3)
+ self.assert_(t0_3 is t0_3_bis)
+ self.assertEqual(tuple([]), ())
+ self.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3))
+ self.assertEqual(tuple(''), ())
+ self.assertEqual(tuple('spam'), ('s', 'p', 'a', 'm'))
def test_truth(self):
super().test_truth()
diff --git a/Lib/test/test_urllib2.py b/Lib/test/test_urllib2.py
index 9f0b2c4002..d34a17746e 100644
--- a/Lib/test/test_urllib2.py
+++ b/Lib/test/test_urllib2.py
@@ -1059,6 +1059,12 @@ class MiscTests(unittest.TestCase):
o = build_opener(urllib2.HTTPHandler())
self.opener_has_handler(o, urllib2.HTTPHandler)
+ # Issue2670: multiple handlers sharing the same base class
+ class MyOtherHTTPHandler(urllib2.HTTPHandler): pass
+ o = build_opener(MyHTTPHandler, MyOtherHTTPHandler)
+ self.opener_has_handler(o, MyHTTPHandler)
+ self.opener_has_handler(o, MyOtherHTTPHandler)
+
def opener_has_handler(self, opener, handler_class):
for h in opener.handlers:
if h.__class__ == handler_class:
diff --git a/Lib/test/test_warnings.py b/Lib/test/test_warnings.py
index a6cbddf39e..0f3ee8b36f 100644
--- a/Lib/test/test_warnings.py
+++ b/Lib/test/test_warnings.py
@@ -229,6 +229,77 @@ class WarnTests(unittest.TestCase):
warning_tests.inner("spam7", stacklevel=9999)
self.assertEqual(os.path.basename(w.filename), "sys")
+ def test_missing_filename_not_main(self):
+ # If __file__ is not specified and __main__ is not the module name,
+ # then __file__ should be set to the module name.
+ filename = warning_tests.__file__
+ try:
+ del warning_tests.__file__
+ with warnings_state(self.module):
+ with test_support.catch_warning(self.module) as w:
+ warning_tests.inner("spam8", stacklevel=1)
+ self.assertEqual(w.filename, warning_tests.__name__)
+ finally:
+ warning_tests.__file__ = filename
+
+ def test_missing_filename_main_with_argv(self):
+ # If __file__ is not specified and the caller is __main__ and sys.argv
+ # exists, then use sys.argv[0] as the file.
+ if not hasattr(sys, 'argv'):
+ return
+ filename = warning_tests.__file__
+ module_name = warning_tests.__name__
+ try:
+ del warning_tests.__file__
+ warning_tests.__name__ = '__main__'
+ with warnings_state(self.module):
+ with test_support.catch_warning(self.module) as w:
+ warning_tests.inner('spam9', stacklevel=1)
+ self.assertEqual(w.filename, sys.argv[0])
+ finally:
+ warning_tests.__file__ = filename
+ warning_tests.__name__ = module_name
+
+ def test_missing_filename_main_without_argv(self):
+ # If __file__ is not specified, the caller is __main__, and sys.argv
+ # is not set, then '__main__' is the file name.
+ filename = warning_tests.__file__
+ module_name = warning_tests.__name__
+ argv = sys.argv
+ try:
+ del warning_tests.__file__
+ warning_tests.__name__ = '__main__'
+ del sys.argv
+ with warnings_state(self.module):
+ with test_support.catch_warning(self.module) as w:
+ warning_tests.inner('spam10', stacklevel=1)
+ self.assertEqual(w.filename, '__main__')
+ finally:
+ warning_tests.__file__ = filename
+ warning_tests.__name__ = module_name
+ sys.argv = argv
+
+ def BROKEN_test_missing_filename_main_with_argv_empty_string(self):
+ # If __file__ is not specified, the caller is __main__, and sys.argv[0]
+ # is the empty string, then '__main__ is the file name.
+ # Tests issue 2743.
+ file_name = warning_tests.__file__
+ module_name = warning_tests.__name__
+ argv = sys.argv
+ try:
+ del warning_tests.__file__
+ warning_tests.__name__ = '__main__'
+ sys.argv = ['']
+ with warnings_state(self.module):
+ with test_support.catch_warning(self.module) as w:
+ warning_tests.inner('spam11', stacklevel=1)
+ self.assertEqual(w.filename, '__main__')
+ finally:
+ warning_tests.__file__ = file_name
+ warning_tests.__name__ = module_name
+ sys.argv = argv
+
+
class CWarnTests(BaseTest, WarnTests):
module = c_warnings
diff --git a/Lib/test/test_with.py b/Lib/test/test_with.py
index e77846399d..6e439ac7a1 100644
--- a/Lib/test/test_with.py
+++ b/Lib/test/test_with.py
@@ -2,7 +2,6 @@
"""Unit tests for the with statement specified in PEP 343."""
-from __future__ import with_statement
__author__ = "Mike Bland"
__email__ = "mbland at acm dot org"
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
index a254eee0c9..7ff078db91 100644
--- a/Lib/test/test_xmlrpc.py
+++ b/Lib/test/test_xmlrpc.py
@@ -50,7 +50,7 @@ class XMLRPCTestCase(unittest.TestCase):
self.assertEquals(newdt, xmlrpclib.DateTime('20050210T11:41:23'))
def test_datetime_before_1900(self):
- # same as before but with an date before 1900
+ # same as before but with a date before 1900
dt = datetime.datetime(1, 2, 10, 11, 41, 23)
s = xmlrpclib.dumps((dt,))
(newdt,), m = xmlrpclib.loads(s, use_datetime=1)
View Lorry Controller Status