Moved testing of builtin types out of test_builtin and into type specific modules
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
index 1709de5..b67c764 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
@@ -36,6 +37,46 @@
special = special + map(lambda x: ~x, special) + \
map(lambda x: -x, 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.maxint), sys.maxint),
+ (' 1x', ValueError),
+ (' 1 ', 1),
+ (' 1\02 ', ValueError),
+ ('', ValueError),
+ (' ', ValueError),
+ (' \t\t ', ValueError)
+]
+if test_support.have_unicode:
+ L += [
+ (unicode('0'), 0),
+ (unicode('1'), 1),
+ (unicode('9'), 9),
+ (unicode('10'), 10),
+ (unicode('99'), 99),
+ (unicode('100'), 100),
+ (unicode('314'), 314),
+ (unicode(' 314'), 314),
+ (unicode('\u0663\u0661\u0664 ','raw-unicode-escape'), 314),
+ (unicode(' \t\t 314 \t\t '), 314),
+ (unicode(' 1x'), ValueError),
+ (unicode(' 1 '), 1),
+ (unicode(' 1\02 '), ValueError),
+ (unicode(''), ValueError),
+ (unicode(' '), ValueError),
+ (unicode(' \t\t '), ValueError),
+ (unichr(0x200), ValueError),
+]
+
class LongTest(unittest.TestCase):
@@ -234,8 +275,215 @@
x = self.getran(lenx)
self.check_format_1(x)
+ def test_long(self):
+ self.assertEqual(long(314), 314L)
+ self.assertEqual(long(3.14), 3L)
+ self.assertEqual(long(314L), 314L)
+ # Check that conversion from float truncates towards zero
+ self.assertEqual(long(-3.14), -3L)
+ self.assertEqual(long(3.9), 3L)
+ self.assertEqual(long(-3.9), -3L)
+ self.assertEqual(long(3.5), 3L)
+ self.assertEqual(long(-3.5), -3L)
+ self.assertEqual(long("-3"), -3L)
+ if test_support.have_unicode:
+ self.assertEqual(long(unicode("-3")), -3L)
+ # Different base:
+ self.assertEqual(long("10",16), 16L)
+ if test_support.have_unicode:
+ self.assertEqual(long(unicode("10"),16), 16L)
+ # Check conversions from string (same test set as for int(), and then some)
+ LL = [
+ ('1' + '0'*20, 10L**20),
+ ('1' + '0'*100, 10L**100)
+ ]
+ L2 = L[:]
+ if test_support.have_unicode:
+ L2 += [
+ (unicode('1') + unicode('0')*20, 10L**20),
+ (unicode('1') + unicode('0')*100, 10L**100),
+ ]
+ 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(long(ss), long(vv))
+ except v:
+ pass
+
+ self.assertRaises(ValueError, long, '123\0')
+ self.assertRaises(ValueError, long, '53', 40)
+ self.assertRaises(TypeError, long, 1, 12)
+
+ # SF patch #1638879: embedded NULs were not detected with
+ # explicit base
+ self.assertRaises(ValueError, long, '123\0', 10)
+ self.assertRaises(ValueError, long, '123\x00 245', 20)
+
+ self.assertEqual(long('100000000000000000000000000000000', 2),
+ 4294967296)
+ self.assertEqual(long('102002022201221111211', 3), 4294967296)
+ self.assertEqual(long('10000000000000000', 4), 4294967296)
+ self.assertEqual(long('32244002423141', 5), 4294967296)
+ self.assertEqual(long('1550104015504', 6), 4294967296)
+ self.assertEqual(long('211301422354', 7), 4294967296)
+ self.assertEqual(long('40000000000', 8), 4294967296)
+ self.assertEqual(long('12068657454', 9), 4294967296)
+ self.assertEqual(long('4294967296', 10), 4294967296)
+ self.assertEqual(long('1904440554', 11), 4294967296)
+ self.assertEqual(long('9ba461594', 12), 4294967296)
+ self.assertEqual(long('535a79889', 13), 4294967296)
+ self.assertEqual(long('2ca5b7464', 14), 4294967296)
+ self.assertEqual(long('1a20dcd81', 15), 4294967296)
+ self.assertEqual(long('100000000', 16), 4294967296)
+ self.assertEqual(long('a7ffda91', 17), 4294967296)
+ self.assertEqual(long('704he7g4', 18), 4294967296)
+ self.assertEqual(long('4f5aff66', 19), 4294967296)
+ self.assertEqual(long('3723ai4g', 20), 4294967296)
+ self.assertEqual(long('281d55i4', 21), 4294967296)
+ self.assertEqual(long('1fj8b184', 22), 4294967296)
+ self.assertEqual(long('1606k7ic', 23), 4294967296)
+ self.assertEqual(long('mb994ag', 24), 4294967296)
+ self.assertEqual(long('hek2mgl', 25), 4294967296)
+ self.assertEqual(long('dnchbnm', 26), 4294967296)
+ self.assertEqual(long('b28jpdm', 27), 4294967296)
+ self.assertEqual(long('8pfgih4', 28), 4294967296)
+ self.assertEqual(long('76beigg', 29), 4294967296)
+ self.assertEqual(long('5qmcpqg', 30), 4294967296)
+ self.assertEqual(long('4q0jto4', 31), 4294967296)
+ self.assertEqual(long('4000000', 32), 4294967296)
+ self.assertEqual(long('3aokq94', 33), 4294967296)
+ self.assertEqual(long('2qhxjli', 34), 4294967296)
+ self.assertEqual(long('2br45qb', 35), 4294967296)
+ self.assertEqual(long('1z141z4', 36), 4294967296)
+
+ self.assertEqual(long('100000000000000000000000000000001', 2),
+ 4294967297)
+ self.assertEqual(long('102002022201221111212', 3), 4294967297)
+ self.assertEqual(long('10000000000000001', 4), 4294967297)
+ self.assertEqual(long('32244002423142', 5), 4294967297)
+ self.assertEqual(long('1550104015505', 6), 4294967297)
+ self.assertEqual(long('211301422355', 7), 4294967297)
+ self.assertEqual(long('40000000001', 8), 4294967297)
+ self.assertEqual(long('12068657455', 9), 4294967297)
+ self.assertEqual(long('4294967297', 10), 4294967297)
+ self.assertEqual(long('1904440555', 11), 4294967297)
+ self.assertEqual(long('9ba461595', 12), 4294967297)
+ self.assertEqual(long('535a7988a', 13), 4294967297)
+ self.assertEqual(long('2ca5b7465', 14), 4294967297)
+ self.assertEqual(long('1a20dcd82', 15), 4294967297)
+ self.assertEqual(long('100000001', 16), 4294967297)
+ self.assertEqual(long('a7ffda92', 17), 4294967297)
+ self.assertEqual(long('704he7g5', 18), 4294967297)
+ self.assertEqual(long('4f5aff67', 19), 4294967297)
+ self.assertEqual(long('3723ai4h', 20), 4294967297)
+ self.assertEqual(long('281d55i5', 21), 4294967297)
+ self.assertEqual(long('1fj8b185', 22), 4294967297)
+ self.assertEqual(long('1606k7id', 23), 4294967297)
+ self.assertEqual(long('mb994ah', 24), 4294967297)
+ self.assertEqual(long('hek2mgm', 25), 4294967297)
+ self.assertEqual(long('dnchbnn', 26), 4294967297)
+ self.assertEqual(long('b28jpdn', 27), 4294967297)
+ self.assertEqual(long('8pfgih5', 28), 4294967297)
+ self.assertEqual(long('76beigh', 29), 4294967297)
+ self.assertEqual(long('5qmcpqh', 30), 4294967297)
+ self.assertEqual(long('4q0jto5', 31), 4294967297)
+ self.assertEqual(long('4000001', 32), 4294967297)
+ self.assertEqual(long('3aokq95', 33), 4294967297)
+ self.assertEqual(long('2qhxjlj', 34), 4294967297)
+ self.assertEqual(long('2br45qc', 35), 4294967297)
+ self.assertEqual(long('1z141z5', 36), 4294967297)
+
+
+ def test_conversion(self):
+ # Test __long__()
+ class ClassicMissingMethods:
+ pass
+ self.assertRaises(AttributeError, long, ClassicMissingMethods())
+
+ class MissingMethods(object):
+ pass
+ self.assertRaises(TypeError, long, MissingMethods())
+
+ class Foo0:
+ def __long__(self):
+ return 42L
+
+ class Foo1(object):
+ def __long__(self):
+ return 42L
+
+ class Foo2(long):
+ def __long__(self):
+ return 42L
+
+ class Foo3(long):
+ def __long__(self):
+ return self
+
+ class Foo4(long):
+ def __long__(self):
+ return 42
+
+ class Foo5(long):
+ def __long__(self):
+ return 42.
+
+ self.assertEqual(long(Foo0()), 42L)
+ self.assertEqual(long(Foo1()), 42L)
+ self.assertEqual(long(Foo2()), 42L)
+ self.assertEqual(long(Foo3()), 0)
+ self.assertEqual(long(Foo4()), 42)
+ self.assertRaises(TypeError, long, Foo5())
+
+ class Classic:
+ pass
+ for base in (object, Classic):
+ class LongOverridesTrunc(base):
+ def __long__(self):
+ return 42
+ def __trunc__(self):
+ return -12
+ self.assertEqual(long(LongOverridesTrunc()), 42)
+
+ class JustTrunc(base):
+ def __trunc__(self):
+ return 42
+ self.assertEqual(long(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(long(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:
+ long(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.maxint
@@ -417,7 +665,6 @@
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.