Lib/test/test_int.py

   1 import sys
   2
   3 import unittest
   4 from test.test_support import run_unittest, have_unicode
   5 import math
   6
   7 L = [
   8         ('0', 0),
   9         ('1', 1),
  10         ('9', 9),
  11         ('10', 10),
  12         ('99', 99),
  13         ('100', 100),
  14         ('314', 314),
  15         (' 314', 314),
  16         ('314 ', 314),
  17         ('  \t\t  314  \t\t  ', 314),
  18         (repr(sys.maxint), sys.maxint),
  19         ('  1x', ValueError),
  20         ('  1  ', 1),
  21         ('  1\02  ', ValueError),
  22         ('', ValueError),
  23         (' ', ValueError),
  24         ('  \t\t  ', ValueError)
  25 ]
  26 if have_unicode:
  27     L += [
  28         (unicode('0'), 0),
  29         (unicode('1'), 1),
  30         (unicode('9'), 9),
  31         (unicode('10'), 10),
  32         (unicode('99'), 99),
  33         (unicode('100'), 100),
  34         (unicode('314'), 314),
  35         (unicode(' 314'), 314),
  36         (unicode('\u0663\u0661\u0664 ','raw-unicode-escape'), 314),
  37         (unicode('  \t\t  314  \t\t  '), 314),
  38         (unicode('  1x'), ValueError),
  39         (unicode('  1  '), 1),
  40         (unicode('  1\02  '), ValueError),
  41         (unicode(''), ValueError),
  42         (unicode(' '), ValueError),
  43         (unicode('  \t\t  '), ValueError),
  44         (unichr(0x200), ValueError),
  45 ]
  46
  47 class IntTestCases(unittest.TestCase):
  48
  49     def test_basic(self):
  50         self.assertEqual(int(314), 314)
  51         self.assertEqual(int(3.14), 3)
  52         self.assertEqual(int(314L), 314)
  53         # Check that conversion from float truncates towards zero
  54         self.assertEqual(int(-3.14), -3)
  55         self.assertEqual(int(3.9), 3)
  56         self.assertEqual(int(-3.9), -3)
  57         self.assertEqual(int(3.5), 3)
  58         self.assertEqual(int(-3.5), -3)
  59         # Different base:
  60         self.assertEqual(int("10",16), 16L)
  61         if have_unicode:
  62             self.assertEqual(int(unicode("10"),16), 16L)
  63         # Test conversion from strings and various anomalies
  64         for s, v in L:
  65             for sign in "", "+", "-":
  66                 for prefix in "", " ", "\t", "  \t\t  ":
  67                     ss = prefix + sign + s
  68                     vv = v
  69                     if sign == "-" and v is not ValueError:
  70                         vv = -v
  71                     try:
  72                         self.assertEqual(int(ss), vv)
  73                     except v:
  74                         pass
  75
  76         s = repr(-1-sys.maxint)
  77         x = int(s)
  78         self.assertEqual(x+1, -sys.maxint)
  79         self.assertTrue(isinstance(x, int))
  80         # should return long
  81         self.assertEqual(int(s[1:]), sys.maxint+1)
  82
  83         # should return long
  84         x = int(1e100)
  85         self.assertTrue(isinstance(x, long))
  86         x = int(-1e100)
  87         self.assertTrue(isinstance(x, long))
  88
  89
  90         # SF bug 434186:  0x80000000/2 != 0x80000000>>1.
  91         # Worked by accident in Windows release build, but failed in debug build.
  92         # Failed in all Linux builds.
  93         x = -1-sys.maxint
  94         self.assertEqual(x >> 1, x//2)
  95
  96         self.assertRaises(ValueError, int, '123\0')
  97         self.assertRaises(ValueError, int, '53', 40)
  98
  99         # SF bug 1545497: embedded NULs were not detected with
 100         # explicit base
 101         self.assertRaises(ValueError, int, '123\0', 10)
 102         self.assertRaises(ValueError, int, '123\x00 245', 20)
 103
 104         x = int('1' * 600)
 105         self.assertTrue(isinstance(x, long))
 106
 107         if have_unicode:
 108             x = int(unichr(0x661) * 600)
 109             self.assertTrue(isinstance(x, long))
 110
 111         self.assertRaises(TypeError, int, 1, 12)
 112
 113         self.assertEqual(int('0123', 0), 83)
 114         self.assertEqual(int('0x123', 16), 291)
 115
 116         # Bug 1679: "0x" is not a valid hex literal
 117         self.assertRaises(ValueError, int, "0x", 16)
 118         self.assertRaises(ValueError, int, "0x", 0)
 119
 120         self.assertRaises(ValueError, int, "0o", 8)
 121         self.assertRaises(ValueError, int, "0o", 0)
 122
 123         self.assertRaises(ValueError, int, "0b", 2)
 124         self.assertRaises(ValueError, int, "0b", 0)
 125
 126
 127         # SF bug 1334662: int(string, base) wrong answers
 128         # Various representations of 2**32 evaluated to 0
 129         # rather than 2**32 in previous versions
 130
 131         self.assertEqual(int('100000000000000000000000000000000', 2), 4294967296L)
 132         self.assertEqual(int('102002022201221111211', 3), 4294967296L)
 133         self.assertEqual(int('10000000000000000', 4), 4294967296L)
 134         self.assertEqual(int('32244002423141', 5), 4294967296L)
 135         self.assertEqual(int('1550104015504', 6), 4294967296L)
 136         self.assertEqual(int('211301422354', 7), 4294967296L)
 137         self.assertEqual(int('40000000000', 8), 4294967296L)
 138         self.assertEqual(int('12068657454', 9), 4294967296L)
 139         self.assertEqual(int('4294967296', 10), 4294967296L)
 140         self.assertEqual(int('1904440554', 11), 4294967296L)
 141         self.assertEqual(int('9ba461594', 12), 4294967296L)
 142         self.assertEqual(int('535a79889', 13), 4294967296L)
 143         self.assertEqual(int('2ca5b7464', 14), 4294967296L)
 144         self.assertEqual(int('1a20dcd81', 15), 4294967296L)
 145         self.assertEqual(int('100000000', 16), 4294967296L)
 146         self.assertEqual(int('a7ffda91', 17), 4294967296L)
 147         self.assertEqual(int('704he7g4', 18), 4294967296L)
 148         self.assertEqual(int('4f5aff66', 19), 4294967296L)
 149         self.assertEqual(int('3723ai4g', 20), 4294967296L)
 150         self.assertEqual(int('281d55i4', 21), 4294967296L)
 151         self.assertEqual(int('1fj8b184', 22), 4294967296L)
 152         self.assertEqual(int('1606k7ic', 23), 4294967296L)
 153         self.assertEqual(int('mb994ag', 24), 4294967296L)
 154         self.assertEqual(int('hek2mgl', 25), 4294967296L)
 155         self.assertEqual(int('dnchbnm', 26), 4294967296L)
 156         self.assertEqual(int('b28jpdm', 27), 4294967296L)
 157         self.assertEqual(int('8pfgih4', 28), 4294967296L)
 158         self.assertEqual(int('76beigg', 29), 4294967296L)
 159         self.assertEqual(int('5qmcpqg', 30), 4294967296L)
 160         self.assertEqual(int('4q0jto4', 31), 4294967296L)
 161         self.assertEqual(int('4000000', 32), 4294967296L)
 162         self.assertEqual(int('3aokq94', 33), 4294967296L)
 163         self.assertEqual(int('2qhxjli', 34), 4294967296L)
 164         self.assertEqual(int('2br45qb', 35), 4294967296L)
 165         self.assertEqual(int('1z141z4', 36), 4294967296L)
 166
 167         # tests with base 0
 168         # this fails on 3.0, but in 2.x the old octal syntax is allowed
 169         self.assertEqual(int(' 0123  ', 0), 83)
 170         self.assertEqual(int(' 0123  ', 0), 83)
 171         self.assertEqual(int('000', 0), 0)
 172         self.assertEqual(int('0o123', 0), 83)
 173         self.assertEqual(int('0x123', 0), 291)
 174         self.assertEqual(int('0b100', 0), 4)
 175         self.assertEqual(int(' 0O123   ', 0), 83)
 176         self.assertEqual(int(' 0X123  ', 0), 291)
 177         self.assertEqual(int(' 0B100 ', 0), 4)
 178
 179         # without base still base 10
 180         self.assertEqual(int('0123'), 123)
 181         self.assertEqual(int('0123', 10), 123)
 182
 183         # tests with prefix and base != 0
 184         self.assertEqual(int('0x123', 16), 291)
 185         self.assertEqual(int('0o123', 8), 83)
 186         self.assertEqual(int('0b100', 2), 4)
 187         self.assertEqual(int('0X123', 16), 291)
 188         self.assertEqual(int('0O123', 8), 83)
 189         self.assertEqual(int('0B100', 2), 4)
 190
 191         # the code has special checks for the first character after the
 192         #  type prefix
 193         self.assertRaises(ValueError, int, '0b2', 2)
 194         self.assertRaises(ValueError, int, '0b02', 2)
 195         self.assertRaises(ValueError, int, '0B2', 2)
 196         self.assertRaises(ValueError, int, '0B02', 2)
 197         self.assertRaises(ValueError, int, '0o8', 8)
 198         self.assertRaises(ValueError, int, '0o08', 8)
 199         self.assertRaises(ValueError, int, '0O8', 8)
 200         self.assertRaises(ValueError, int, '0O08', 8)
 201         self.assertRaises(ValueError, int, '0xg', 16)
 202         self.assertRaises(ValueError, int, '0x0g', 16)
 203         self.assertRaises(ValueError, int, '0Xg', 16)
 204         self.assertRaises(ValueError, int, '0X0g', 16)
 205
 206         # SF bug 1334662: int(string, base) wrong answers
 207         # Checks for proper evaluation of 2**32 + 1
 208         self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297L)
 209         self.assertEqual(int('102002022201221111212', 3), 4294967297L)
 210         self.assertEqual(int('10000000000000001', 4), 4294967297L)
 211         self.assertEqual(int('32244002423142', 5), 4294967297L)
 212         self.assertEqual(int('1550104015505', 6), 4294967297L)
 213         self.assertEqual(int('211301422355', 7), 4294967297L)
 214         self.assertEqual(int('40000000001', 8), 4294967297L)
 215         self.assertEqual(int('12068657455', 9), 4294967297L)
 216         self.assertEqual(int('4294967297', 10), 4294967297L)
 217         self.assertEqual(int('1904440555', 11), 4294967297L)
 218         self.assertEqual(int('9ba461595', 12), 4294967297L)
 219         self.assertEqual(int('535a7988a', 13), 4294967297L)
 220         self.assertEqual(int('2ca5b7465', 14), 4294967297L)
 221         self.assertEqual(int('1a20dcd82', 15), 4294967297L)
 222         self.assertEqual(int('100000001', 16), 4294967297L)
 223         self.assertEqual(int('a7ffda92', 17), 4294967297L)
 224         self.assertEqual(int('704he7g5', 18), 4294967297L)
 225         self.assertEqual(int('4f5aff67', 19), 4294967297L)
 226         self.assertEqual(int('3723ai4h', 20), 4294967297L)
 227         self.assertEqual(int('281d55i5', 21), 4294967297L)
 228         self.assertEqual(int('1fj8b185', 22), 4294967297L)
 229         self.assertEqual(int('1606k7id', 23), 4294967297L)
 230         self.assertEqual(int('mb994ah', 24), 4294967297L)
 231         self.assertEqual(int('hek2mgm', 25), 4294967297L)
 232         self.assertEqual(int('dnchbnn', 26), 4294967297L)
 233         self.assertEqual(int('b28jpdn', 27), 4294967297L)
 234         self.assertEqual(int('8pfgih5', 28), 4294967297L)
 235         self.assertEqual(int('76beigh', 29), 4294967297L)
 236         self.assertEqual(int('5qmcpqh', 30), 4294967297L)
 237         self.assertEqual(int('4q0jto5', 31), 4294967297L)
 238         self.assertEqual(int('4000001', 32), 4294967297L)
 239         self.assertEqual(int('3aokq95', 33), 4294967297L)
 240         self.assertEqual(int('2qhxjlj', 34), 4294967297L)
 241         self.assertEqual(int('2br45qc', 35), 4294967297L)
 242         self.assertEqual(int('1z141z5', 36), 4294967297L)
 243
 244     def test_bit_length(self):
 245         tiny = 1e-10
 246         for x in xrange(-65000, 65000):
 247             k = x.bit_length()
 248             # Check equivalence with Python version
 249             self.assertEqual(k, len(bin(x).lstrip('-0b')))
 250             # Behaviour as specified in the docs
 251             if x != 0:
 252                 self.assertTrue(2**(k-1) <= abs(x) < 2**k)
 253             else:
 254                 self.assertEqual(k, 0)
 255             # Alternative definition: x.bit_length() == 1 + floor(log_2(x))
 256             if x != 0:
 257                 # When x is an exact power of 2, numeric errors can
 258                 # cause floor(log(x)/log(2)) to be one too small; for
 259                 # small x this can be fixed by adding a small quantity
 260                 # to the quotient before taking the floor.
 261                 self.assertEqual(k, 1 + math.floor(
 262                         math.log(abs(x))/math.log(2) + tiny))
 263
 264         self.assertEqual((0).bit_length(), 0)
 265         self.assertEqual((1).bit_length(), 1)
 266         self.assertEqual((-1).bit_length(), 1)
 267         self.assertEqual((2).bit_length(), 2)
 268         self.assertEqual((-2).bit_length(), 2)
 269         for i in [2, 3, 15, 16, 17, 31, 32, 33, 63, 64]:
 270             a = 2**i
 271             self.assertEqual((a-1).bit_length(), i)
 272             self.assertEqual((1-a).bit_length(), i)
 273             self.assertEqual((a).bit_length(), i+1)
 274             self.assertEqual((-a).bit_length(), i+1)
 275             self.assertEqual((a+1).bit_length(), i+1)
 276             self.assertEqual((-a-1).bit_length(), i+1)
 277
 278     @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
 279                          "test requires IEEE 754 doubles")
 280     def test_float_conversion(self):
 281         # values exactly representable as floats
 282         exact_values = [-2, -1, 0, 1, 2, 2**52, 2**53-1, 2**53, 2**53+2,
 283                          2**53+4, 2**54-4, 2**54-2, 2**63, -2**63, 2**64,
 284                          -2**64, 10**20, 10**21, 10**22]
 285         for value in exact_values:
 286             self.assertEqual(int(float(int(value))), value)
 287
 288         # test round-half-to-even
 289         self.assertEqual(int(float(2**53+1)), 2**53)
 290         self.assertEqual(int(float(2**53+2)), 2**53+2)
 291         self.assertEqual(int(float(2**53+3)), 2**53+4)
 292         self.assertEqual(int(float(2**53+5)), 2**53+4)
 293         self.assertEqual(int(float(2**53+6)), 2**53+6)
 294         self.assertEqual(int(float(2**53+7)), 2**53+8)
 295
 296         self.assertEqual(int(float(-2**53-1)), -2**53)
 297         self.assertEqual(int(float(-2**53-2)), -2**53-2)
 298         self.assertEqual(int(float(-2**53-3)), -2**53-4)
 299         self.assertEqual(int(float(-2**53-5)), -2**53-4)
 300         self.assertEqual(int(float(-2**53-6)), -2**53-6)
 301         self.assertEqual(int(float(-2**53-7)), -2**53-8)
 302
 303         self.assertEqual(int(float(2**54-2)), 2**54-2)
 304         self.assertEqual(int(float(2**54-1)), 2**54)
 305         self.assertEqual(int(float(2**54+2)), 2**54)
 306         self.assertEqual(int(float(2**54+3)), 2**54+4)
 307         self.assertEqual(int(float(2**54+5)), 2**54+4)
 308         self.assertEqual(int(float(2**54+6)), 2**54+8)
 309         self.assertEqual(int(float(2**54+10)), 2**54+8)
 310         self.assertEqual(int(float(2**54+11)), 2**54+12)
 311
 312     def test_intconversion(self):
 313         # Test __int__()
 314         class ClassicMissingMethods:
 315             pass
 316         self.assertRaises(AttributeError, int, ClassicMissingMethods())
 317
 318         class MissingMethods(object):
 319             pass
 320         self.assertRaises(TypeError, int, MissingMethods())
 321
 322         class Foo0:
 323             def __int__(self):
 324                 return 42
 325
 326         class Foo1(object):
 327             def __int__(self):
 328                 return 42
 329
 330         class Foo2(int):
 331             def __int__(self):
 332                 return 42
 333
 334         class Foo3(int):
 335             def __int__(self):
 336                 return self
 337
 338         class Foo4(int):
 339             def __int__(self):
 340                 return 42L
 341
 342         class Foo5(int):
 343             def __int__(self):
 344                 return 42.
 345
 346         self.assertEqual(int(Foo0()), 42)
 347         self.assertEqual(int(Foo1()), 42)
 348         self.assertEqual(int(Foo2()), 42)
 349         self.assertEqual(int(Foo3()), 0)
 350         self.assertEqual(int(Foo4()), 42L)
 351         self.assertRaises(TypeError, int, Foo5())
 352
 353         class Classic:
 354             pass
 355         for base in (object, Classic):
 356             class IntOverridesTrunc(base):
 357                 def __int__(self):
 358                     return 42
 359                 def __trunc__(self):
 360                     return -12
 361             self.assertEqual(int(IntOverridesTrunc()), 42)
 362
 363             class JustTrunc(base):
 364                 def __trunc__(self):
 365                     return 42
 366             self.assertEqual(int(JustTrunc()), 42)
 367
 368             for trunc_result_base in (object, Classic):
 369                 class Integral(trunc_result_base):
 370                     def __int__(self):
 371                         return 42
 372
 373                 class TruncReturnsNonInt(base):
 374                     def __trunc__(self):
 375                         return Integral()
 376                 self.assertEqual(int(TruncReturnsNonInt()), 42)
 377
 378                 class NonIntegral(trunc_result_base):
 379                     def __trunc__(self):
 380                         # Check that we avoid infinite recursion.
 381                         return NonIntegral()
 382
 383                 class TruncReturnsNonIntegral(base):
 384                     def __trunc__(self):
 385                         return NonIntegral()
 386                 try:
 387                     int(TruncReturnsNonIntegral())
 388                 except TypeError as e:
 389                     self.assertEquals(str(e),
 390                                       "__trunc__ returned non-Integral"
 391                                       " (type NonIntegral)")
 392                 else:
 393                     self.fail("Failed to raise TypeError with %s" %
 394                               ((base, trunc_result_base),))
 395
 396 def test_main():
 397     run_unittest(IntTestCases)
 398
 399 if __name__ == "__main__":
 400     test_main()