diff options
Diffstat (limited to 'Lib/test/test_int.py')
| -rw-r--r-- | Lib/test/test_int.py | 701 |
1 files changed, 314 insertions, 387 deletions
diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py index 6fdf52e..ea5c0e3 100644 --- a/Lib/test/test_int.py +++ b/Lib/test/test_int.py @@ -1,9 +1,9 @@ import sys import unittest -from test import support -from test.test_grammar import (VALID_UNDERSCORE_LITERALS, - INVALID_UNDERSCORE_LITERALS) +from test import test_support +from test.test_support import run_unittest, have_unicode +import math L = [ ('0', 0), @@ -16,35 +16,74 @@ L = [ (' 314', 314), ('314 ', 314), (' \t\t 314 \t\t ', 314), - (repr(sys.maxsize), sys.maxsize), + (repr(sys.maxint), sys.maxint), (' 1x', ValueError), (' 1 ', 1), (' 1\02 ', ValueError), ('', ValueError), (' ', ValueError), - (' \t\t ', ValueError), - ("\u0200", ValueError) + (' \t\t ', ValueError) +] +if 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 IntSubclass(int): pass -class IntTestCases(unittest.TestCase): +class IntLongCommonTests(object): + + """Mixin of test cases to share between both test_int and test_long.""" + + # Change to int or long in the TestCase subclass. + ntype = None + + def test_no_args(self): + self.assertEqual(self.ntype(), 0) + + def test_keyword_args(self): + # Test invoking constructor using keyword arguments. + self.assertEqual(self.ntype(x=1.2), 1) + self.assertEqual(self.ntype('100', base=2), 4) + self.assertEqual(self.ntype(x='100', base=2), 4) + self.assertRaises(TypeError, self.ntype, base=10) + self.assertRaises(TypeError, self.ntype, base=0) + +class IntTestCases(IntLongCommonTests, unittest.TestCase): + + ntype = int def test_basic(self): self.assertEqual(int(314), 314) self.assertEqual(int(3.14), 3) + self.assertEqual(int(314L), 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) - self.assertEqual(int(" -3 "), -3) - self.assertEqual(int("\N{EM SPACE}-3\N{EN SPACE}"), -3) # Different base: - self.assertEqual(int("10",16), 16) + self.assertEqual(int("10",16), 16L) + if have_unicode: + self.assertEqual(int(unicode("10"),16), 16L) # Test conversion from strings and various anomalies for s, v in L: for sign in "", "+", "-": @@ -55,36 +94,47 @@ class IntTestCases(unittest.TestCase): vv = -v try: self.assertEqual(int(ss), vv) - except ValueError: + except v: pass - s = repr(-1-sys.maxsize) + s = repr(-1-sys.maxint) x = int(s) - self.assertEqual(x+1, -sys.maxsize) + self.assertEqual(x+1, -sys.maxint) self.assertIsInstance(x, int) - # should return int - self.assertEqual(int(s[1:]), sys.maxsize+1) + # should return long + self.assertEqual(int(s[1:]), sys.maxint+1) - # should return int + # should return long x = int(1e100) - self.assertIsInstance(x, int) + self.assertIsInstance(x, long) x = int(-1e100) - self.assertIsInstance(x, int) + self.assertIsInstance(x, long) # 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 + x = -1-sys.maxint 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.assertIsInstance(x, int) + self.assertIsInstance(x, long) + if have_unicode: + x = int(unichr(0x661) * 600) + self.assertIsInstance(x, long) self.assertRaises(TypeError, int, 1, 12) - self.assertEqual(int('0o123', 0), 83) + self.assertEqual(int('0123', 0), 83) self.assertEqual(int('0x123', 16), 291) # Bug 1679: "0x" is not a valid hex literal @@ -97,50 +147,51 @@ class IntTestCases(unittest.TestCase): 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) + self.assertEqual(int('100000000000000000000000000000000', 2), 4294967296L) + self.assertEqual(int('102002022201221111211', 3), 4294967296L) + self.assertEqual(int('10000000000000000', 4), 4294967296L) + self.assertEqual(int('32244002423141', 5), 4294967296L) + self.assertEqual(int('1550104015504', 6), 4294967296L) + self.assertEqual(int('211301422354', 7), 4294967296L) + self.assertEqual(int('40000000000', 8), 4294967296L) + self.assertEqual(int('12068657454', 9), 4294967296L) + self.assertEqual(int('4294967296', 10), 4294967296L) + self.assertEqual(int('1904440554', 11), 4294967296L) + self.assertEqual(int('9ba461594', 12), 4294967296L) + self.assertEqual(int('535a79889', 13), 4294967296L) + self.assertEqual(int('2ca5b7464', 14), 4294967296L) + self.assertEqual(int('1a20dcd81', 15), 4294967296L) + self.assertEqual(int('100000000', 16), 4294967296L) + self.assertEqual(int('a7ffda91', 17), 4294967296L) + self.assertEqual(int('704he7g4', 18), 4294967296L) + self.assertEqual(int('4f5aff66', 19), 4294967296L) + self.assertEqual(int('3723ai4g', 20), 4294967296L) + self.assertEqual(int('281d55i4', 21), 4294967296L) + self.assertEqual(int('1fj8b184', 22), 4294967296L) + self.assertEqual(int('1606k7ic', 23), 4294967296L) + self.assertEqual(int('mb994ag', 24), 4294967296L) + self.assertEqual(int('hek2mgl', 25), 4294967296L) + self.assertEqual(int('dnchbnm', 26), 4294967296L) + self.assertEqual(int('b28jpdm', 27), 4294967296L) + self.assertEqual(int('8pfgih4', 28), 4294967296L) + self.assertEqual(int('76beigg', 29), 4294967296L) + self.assertEqual(int('5qmcpqg', 30), 4294967296L) + self.assertEqual(int('4q0jto4', 31), 4294967296L) + self.assertEqual(int('4000000', 32), 4294967296L) + self.assertEqual(int('3aokq94', 33), 4294967296L) + self.assertEqual(int('2qhxjli', 34), 4294967296L) + self.assertEqual(int('2br45qb', 35), 4294967296L) + self.assertEqual(int('1z141z4', 36), 4294967296L) # 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(' 0123 ', 0), 83) + self.assertEqual(int(' 0123 ', 0), 83) self.assertEqual(int('000', 0), 0) self.assertEqual(int('0o123', 0), 83) self.assertEqual(int('0x123', 0), 291) @@ -148,6 +199,12 @@ class IntTestCases(unittest.TestCase): self.assertEqual(int(' 0O123 ', 0), 83) self.assertEqual(int(' 0X123 ', 0), 291) self.assertEqual(int(' 0B100 ', 0), 4) + self.assertEqual(int('0', 0), 0) + self.assertEqual(int('+0', 0), 0) + self.assertEqual(int('-0', 0), 0) + self.assertEqual(int('00', 0), 0) + self.assertRaises(ValueError, int, '08', 0) + self.assertRaises(ValueError, int, '-012395', 0) # without base still base 10 self.assertEqual(int('0123'), 123) @@ -178,173 +235,175 @@ class IntTestCases(unittest.TestCase): # 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_underscores(self): - for lit in VALID_UNDERSCORE_LITERALS: - if any(ch in lit for ch in '.eEjJ'): - continue - self.assertEqual(int(lit, 0), eval(lit)) - self.assertEqual(int(lit, 0), int(lit.replace('_', ''), 0)) - for lit in INVALID_UNDERSCORE_LITERALS: - if any(ch in lit for ch in '.eEjJ'): - continue - self.assertRaises(ValueError, int, lit, 0) - # Additional test cases with bases != 0, only for the constructor: - self.assertEqual(int("1_00", 3), 9) - self.assertEqual(int("0_100"), 100) # not valid as a literal! - self.assertEqual(int(b"1_00"), 100) # byte underscore - self.assertRaises(ValueError, int, "_100") - self.assertRaises(ValueError, int, "+_100") - self.assertRaises(ValueError, int, "1__00") - self.assertRaises(ValueError, int, "100_") - - @support.cpython_only - def test_small_ints(self): - # Bug #3236: Return small longs from PyLong_FromString - self.assertIs(int('10'), 10) - self.assertIs(int('-1'), -1) - self.assertIs(int(b'10'), 10) - self.assertIs(int(b'-1'), -1) - - def test_no_args(self): - self.assertEqual(int(), 0) - - def test_keyword_args(self): - # Test invoking int() using keyword arguments. - self.assertEqual(int('100', base=2), 4) - with self.assertRaisesRegex(TypeError, 'keyword argument'): - int(x=1.2) - with self.assertRaisesRegex(TypeError, 'keyword argument'): - int(x='100', base=2) - self.assertRaises(TypeError, int, base=10) - self.assertRaises(TypeError, int, base=0) - - def test_int_base_limits(self): - """Testing the supported limits of the int() base parameter.""" - self.assertEqual(int('0', 5), 0) - with self.assertRaises(ValueError): - int('0', 1) - with self.assertRaises(ValueError): - int('0', 37) - with self.assertRaises(ValueError): - int('0', -909) # An old magic value base from Python 2. - with self.assertRaises(ValueError): - int('0', base=0-(2**234)) - with self.assertRaises(ValueError): - int('0', base=2**234) - # Bases 2 through 36 are supported. - for base in range(2,37): - self.assertEqual(int('0', base=base), 0) - - def test_int_base_bad_types(self): - """Not integer types are not valid bases; issue16772.""" - with self.assertRaises(TypeError): - int('0', 5.5) - with self.assertRaises(TypeError): - int('0', 5.0) - - def test_int_base_indexable(self): - class MyIndexable(object): - def __init__(self, value): - self.value = value - def __index__(self): - return self.value - - # Check out of range bases. - for base in 2**100, -2**100, 1, 37: - with self.assertRaises(ValueError): - int('43', base) - - # Check in-range bases. - self.assertEqual(int('101', base=MyIndexable(2)), 5) - self.assertEqual(int('101', base=MyIndexable(10)), 101) - self.assertEqual(int('101', base=MyIndexable(36)), 1 + 36**2) - - def test_non_numeric_input_types(self): - # Test possible non-numeric types for the argument x, including - # subclasses of the explicitly documented accepted types. + self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297L) + self.assertEqual(int('102002022201221111212', 3), 4294967297L) + self.assertEqual(int('10000000000000001', 4), 4294967297L) + self.assertEqual(int('32244002423142', 5), 4294967297L) + self.assertEqual(int('1550104015505', 6), 4294967297L) + self.assertEqual(int('211301422355', 7), 4294967297L) + self.assertEqual(int('40000000001', 8), 4294967297L) + self.assertEqual(int('12068657455', 9), 4294967297L) + self.assertEqual(int('4294967297', 10), 4294967297L) + self.assertEqual(int('1904440555', 11), 4294967297L) + self.assertEqual(int('9ba461595', 12), 4294967297L) + self.assertEqual(int('535a7988a', 13), 4294967297L) + self.assertEqual(int('2ca5b7465', 14), 4294967297L) + self.assertEqual(int('1a20dcd82', 15), 4294967297L) + self.assertEqual(int('100000001', 16), 4294967297L) + self.assertEqual(int('a7ffda92', 17), 4294967297L) + self.assertEqual(int('704he7g5', 18), 4294967297L) + self.assertEqual(int('4f5aff67', 19), 4294967297L) + self.assertEqual(int('3723ai4h', 20), 4294967297L) + self.assertEqual(int('281d55i5', 21), 4294967297L) + self.assertEqual(int('1fj8b185', 22), 4294967297L) + self.assertEqual(int('1606k7id', 23), 4294967297L) + self.assertEqual(int('mb994ah', 24), 4294967297L) + self.assertEqual(int('hek2mgm', 25), 4294967297L) + self.assertEqual(int('dnchbnn', 26), 4294967297L) + self.assertEqual(int('b28jpdn', 27), 4294967297L) + self.assertEqual(int('8pfgih5', 28), 4294967297L) + self.assertEqual(int('76beigh', 29), 4294967297L) + self.assertEqual(int('5qmcpqh', 30), 4294967297L) + self.assertEqual(int('4q0jto5', 31), 4294967297L) + self.assertEqual(int('4000001', 32), 4294967297L) + self.assertEqual(int('3aokq95', 33), 4294967297L) + self.assertEqual(int('2qhxjlj', 34), 4294967297L) + self.assertEqual(int('2br45qc', 35), 4294967297L) + self.assertEqual(int('1z141z5', 36), 4294967297L) + + def test_bit_length(self): + tiny = 1e-10 + for x in xrange(-65000, 65000): + k = x.bit_length() + # Check equivalence with Python version + self.assertEqual(k, len(bin(x).lstrip('-0b'))) + # Behaviour as specified in the docs + if x != 0: + self.assertTrue(2**(k-1) <= abs(x) < 2**k) + else: + self.assertEqual(k, 0) + # Alternative definition: x.bit_length() == 1 + floor(log_2(x)) + if x != 0: + # When x is an exact power of 2, numeric errors can + # cause floor(log(x)/log(2)) to be one too small; for + # small x this can be fixed by adding a small quantity + # to the quotient before taking the floor. + self.assertEqual(k, 1 + math.floor( + math.log(abs(x))/math.log(2) + tiny)) + + self.assertEqual((0).bit_length(), 0) + self.assertEqual((1).bit_length(), 1) + self.assertEqual((-1).bit_length(), 1) + self.assertEqual((2).bit_length(), 2) + self.assertEqual((-2).bit_length(), 2) + for i in [2, 3, 15, 16, 17, 31, 32, 33, 63, 64]: + a = 2**i + self.assertEqual((a-1).bit_length(), i) + self.assertEqual((1-a).bit_length(), i) + self.assertEqual((a).bit_length(), i+1) + self.assertEqual((-a).bit_length(), i+1) + self.assertEqual((a+1).bit_length(), i+1) + self.assertEqual((-a-1).bit_length(), i+1) + + @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), + "test requires IEEE 754 doubles") + def test_float_conversion(self): + # values exactly representable as floats + exact_values = [-2, -1, 0, 1, 2, 2**52, 2**53-1, 2**53, 2**53+2, + 2**53+4, 2**54-4, 2**54-2, 2**63, -2**63, 2**64, + -2**64, 10**20, 10**21, 10**22] + for value in exact_values: + self.assertEqual(int(float(int(value))), value) + + # test round-half-to-even + self.assertEqual(int(float(2**53+1)), 2**53) + self.assertEqual(int(float(2**53+2)), 2**53+2) + self.assertEqual(int(float(2**53+3)), 2**53+4) + self.assertEqual(int(float(2**53+5)), 2**53+4) + self.assertEqual(int(float(2**53+6)), 2**53+6) + self.assertEqual(int(float(2**53+7)), 2**53+8) + + self.assertEqual(int(float(-2**53-1)), -2**53) + self.assertEqual(int(float(-2**53-2)), -2**53-2) + self.assertEqual(int(float(-2**53-3)), -2**53-4) + self.assertEqual(int(float(-2**53-5)), -2**53-4) + self.assertEqual(int(float(-2**53-6)), -2**53-6) + self.assertEqual(int(float(-2**53-7)), -2**53-8) + + self.assertEqual(int(float(2**54-2)), 2**54-2) + self.assertEqual(int(float(2**54-1)), 2**54) + self.assertEqual(int(float(2**54+2)), 2**54) + self.assertEqual(int(float(2**54+3)), 2**54+4) + self.assertEqual(int(float(2**54+5)), 2**54+4) + self.assertEqual(int(float(2**54+6)), 2**54+8) + self.assertEqual(int(float(2**54+10)), 2**54+8) + self.assertEqual(int(float(2**54+11)), 2**54+12) + + def test_valid_non_numeric_input_types_for_x(self): + # Test possible valid non-numeric types for x, including subclasses + # of the allowed built-in types. class CustomStr(str): pass - class CustomBytes(bytes): pass class CustomByteArray(bytearray): pass + factories = [str, bytearray, CustomStr, CustomByteArray, buffer] - factories = [ - bytes, - bytearray, - lambda b: CustomStr(b.decode()), - CustomBytes, - CustomByteArray, - memoryview, - ] - try: - from array import array - except ImportError: - pass - else: - factories.append(lambda b: array('B', b)) + if have_unicode: + class CustomUnicode(unicode): pass + factories += [unicode, CustomUnicode] for f in factories: - x = f(b'100') - with self.subTest(type(x)): - self.assertEqual(int(x), 100) - if isinstance(x, (str, bytes, bytearray)): - self.assertEqual(int(x, 2), 4) - else: - msg = "can't convert non-string" - with self.assertRaisesRegex(TypeError, msg): - int(x, 2) - with self.assertRaisesRegex(ValueError, 'invalid literal'): - int(f(b'A' * 0x10)) - - def test_int_memoryview(self): - self.assertEqual(int(memoryview(b'123')[1:3]), 23) - self.assertEqual(int(memoryview(b'123\x00')[1:3]), 23) - self.assertEqual(int(memoryview(b'123 ')[1:3]), 23) - self.assertEqual(int(memoryview(b'123A')[1:3]), 23) - self.assertEqual(int(memoryview(b'1234')[1:3]), 23) - - def test_string_float(self): + with test_support.check_py3k_warnings(quiet=True): + x = f('100') + msg = 'x has value %s and type %s' % (x, type(x).__name__) + try: + self.assertEqual(int(x), 100, msg=msg) + if isinstance(x, basestring): + self.assertEqual(int(x, 2), 4, msg=msg) + except TypeError, err: + raise AssertionError('For %s got TypeError: %s' % + (type(x).__name__, err)) + if not isinstance(x, basestring): + errmsg = "can't convert non-string" + with self.assertRaisesRegexp(TypeError, errmsg, msg=msg): + int(x, 2) + errmsg = 'invalid literal' + with self.assertRaisesRegexp(ValueError, errmsg, msg=msg), \ + test_support.check_py3k_warnings(quiet=True): + int(f('A' * 0x10)) + + def test_int_buffer(self): + with test_support.check_py3k_warnings(): + self.assertEqual(int(buffer('123', 1, 2)), 23) + self.assertEqual(int(buffer('123\x00', 1, 2)), 23) + self.assertEqual(int(buffer('123 ', 1, 2)), 23) + self.assertEqual(int(buffer('123A', 1, 2)), 23) + self.assertEqual(int(buffer('1234', 1, 2)), 23) + + def test_error_on_string_float_for_x(self): self.assertRaises(ValueError, int, '1.2') + def test_error_on_bytearray_for_x(self): + self.assertRaises(TypeError, int, bytearray('100'), 2) + + def test_error_on_invalid_int_bases(self): + for base in [-1, 1, 1000]: + self.assertRaises(ValueError, int, '100', base) + + def test_error_on_string_base(self): + self.assertRaises(TypeError, int, 100, base='foo') + + @test_support.cpython_only + def test_small_ints(self): + self.assertIs(int('10'), 10) + self.assertIs(int('-1'), -1) + if have_unicode: + self.assertIs(int(u'10'), 10) + self.assertIs(int(u'-1'), -1) + def test_intconversion(self): # Test __int__() class ClassicMissingMethods: pass - self.assertRaises(TypeError, int, ClassicMissingMethods()) + self.assertRaises(AttributeError, int, ClassicMissingMethods()) class MissingMethods(object): pass @@ -354,7 +413,32 @@ class IntTestCases(unittest.TestCase): 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 42L + + 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()), 42L) + self.assertRaises(TypeError, int, Foo5()) class Classic: pass @@ -371,29 +455,14 @@ class IntTestCases(unittest.TestCase): return 42 self.assertEqual(int(JustTrunc()), 42) - class ExceptionalTrunc(base): - def __trunc__(self): - 1 / 0 - with self.assertRaises(ZeroDivisionError): - int(ExceptionalTrunc()) - for trunc_result_base in (object, Classic): - class Index(trunc_result_base): - def __index__(self): - return 42 - - class TruncReturnsNonInt(base): - def __trunc__(self): - return Index() - self.assertEqual(int(TruncReturnsNonInt()), 42) - - class Intable(trunc_result_base): + class Integral(trunc_result_base): def __int__(self): return 42 - class TruncReturnsNonIndex(base): + class TruncReturnsNonInt(base): def __trunc__(self): - return Intable() + return Integral() self.assertEqual(int(TruncReturnsNonInt()), 42) class NonIntegral(trunc_result_base): @@ -414,162 +483,20 @@ class IntTestCases(unittest.TestCase): self.fail("Failed to raise TypeError with %s" % ((base, trunc_result_base),)) - # Regression test for bugs.python.org/issue16060. - class BadInt(trunc_result_base): - def __int__(self): - return 42.0 - - class TruncReturnsBadInt(base): + class TruncReturnsIntSubclass(base): def __trunc__(self): - return BadInt() - - with self.assertRaises(TypeError): - int(TruncReturnsBadInt()) + return True + good_int = TruncReturnsIntSubclass() + n = int(good_int) + self.assertEqual(n, 1) + self.assertIs(type(n), bool) + n = IntSubclass(good_int) + self.assertEqual(n, 1) + self.assertIs(type(n), IntSubclass) - def test_int_subclass_with_index(self): - class MyIndex(int): - def __index__(self): - return 42 - - class BadIndex(int): - def __index__(self): - return 42.0 - - my_int = MyIndex(7) - self.assertEqual(my_int, 7) - self.assertEqual(int(my_int), 7) - - self.assertEqual(int(BadIndex()), 0) - - def test_int_subclass_with_int(self): - class MyInt(int): - def __int__(self): - return 42 - - class BadInt(int): - def __int__(self): - return 42.0 - - my_int = MyInt(7) - self.assertEqual(my_int, 7) - self.assertEqual(int(my_int), 42) - - my_int = BadInt(7) - self.assertEqual(my_int, 7) - self.assertRaises(TypeError, int, my_int) - - def test_int_returns_int_subclass(self): - class BadIndex: - def __index__(self): - return True - - class BadIndex2(int): - def __index__(self): - return True - - class BadInt: - def __int__(self): - return True - - class BadInt2(int): - def __int__(self): - return True - - class TruncReturnsBadIndex: - def __trunc__(self): - return BadIndex() - - class TruncReturnsBadInt: - def __trunc__(self): - return BadInt() - - class TruncReturnsIntSubclass: - def __trunc__(self): - return True - - bad_int = BadIndex() - with self.assertWarns(DeprecationWarning): - n = int(bad_int) - self.assertEqual(n, 1) - self.assertIs(type(n), int) - - bad_int = BadIndex2() - n = int(bad_int) - self.assertEqual(n, 0) - self.assertIs(type(n), int) - - bad_int = BadInt() - with self.assertWarns(DeprecationWarning): - n = int(bad_int) - self.assertEqual(n, 1) - self.assertIs(type(n), int) - - bad_int = BadInt2() - with self.assertWarns(DeprecationWarning): - n = int(bad_int) - self.assertEqual(n, 1) - self.assertIs(type(n), int) - - bad_int = TruncReturnsBadIndex() - with self.assertWarns(DeprecationWarning): - n = int(bad_int) - self.assertEqual(n, 1) - self.assertIs(type(n), int) - - bad_int = TruncReturnsBadInt() - with self.assertWarns(DeprecationWarning): - n = int(bad_int) - self.assertEqual(n, 1) - self.assertIs(type(n), int) - - good_int = TruncReturnsIntSubclass() - n = int(good_int) - self.assertEqual(n, 1) - self.assertIs(type(n), int) - n = IntSubclass(good_int) - self.assertEqual(n, 1) - self.assertIs(type(n), IntSubclass) - - def test_error_message(self): - def check(s, base=None): - with self.assertRaises(ValueError, - msg="int(%r, %r)" % (s, base)) as cm: - if base is None: - int(s) - else: - int(s, base) - self.assertEqual(cm.exception.args[0], - "invalid literal for int() with base %d: %r" % - (10 if base is None else base, s)) - - check('\xbd') - check('123\xbd') - check(' 123 456 ') - - check('123\x00') - # SF bug 1545497: embedded NULs were not detected with explicit base - check('123\x00', 10) - check('123\x00 245', 20) - check('123\x00 245', 16) - check('123\x00245', 20) - check('123\x00245', 16) - # byte string with embedded NUL - check(b'123\x00') - check(b'123\x00', 10) - # non-UTF-8 byte string - check(b'123\xbd') - check(b'123\xbd', 10) - # lone surrogate in Unicode string - check('123\ud800') - check('123\ud800', 10) - - def test_issue31619(self): - self.assertEqual(int('1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1', 2), - 0b1010101010101010101010101010101) - self.assertEqual(int('1_2_3_4_5_6_7_0_1_2_3', 8), 0o12345670123) - self.assertEqual(int('1_2_3_4_5_6_7_8_9', 16), 0x123456789) - self.assertEqual(int('1_2_3_4_5_6_7', 32), 1144132807) +def test_main(): + run_unittest(IntTestCases) if __name__ == "__main__": - unittest.main() + test_main() |