Home | History | Annotate | Download | only in test 
      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.assertIsInstance(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.assertIsInstance(x, long)
     86         x = int(-1e100)
     87         self.assertIsInstance(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.assertIsInstance(x, long)
    106 
    107         if have_unicode:
    108             x = int(unichr(0x661) * 600)
    109             self.assertIsInstance(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         self.assertEqual(int('0', 0), 0)
    179         self.assertEqual(int('+0', 0), 0)
    180         self.assertEqual(int('-0', 0), 0)
    181         self.assertEqual(int('00', 0), 0)
    182         self.assertRaises(ValueError, int, '08', 0)
    183         self.assertRaises(ValueError, int, '-012395', 0)
    184 
    185         # without base still base 10

    186         self.assertEqual(int('0123'), 123)
    187         self.assertEqual(int('0123', 10), 123)
    188 
    189         # tests with prefix and base != 0

    190         self.assertEqual(int('0x123', 16), 291)
    191         self.assertEqual(int('0o123', 8), 83)
    192         self.assertEqual(int('0b100', 2), 4)
    193         self.assertEqual(int('0X123', 16), 291)
    194         self.assertEqual(int('0O123', 8), 83)
    195         self.assertEqual(int('0B100', 2), 4)
    196 
    197         # the code has special checks for the first character after the

    198         #  type prefix

    199         self.assertRaises(ValueError, int, '0b2', 2)
    200         self.assertRaises(ValueError, int, '0b02', 2)
    201         self.assertRaises(ValueError, int, '0B2', 2)
    202         self.assertRaises(ValueError, int, '0B02', 2)
    203         self.assertRaises(ValueError, int, '0o8', 8)
    204         self.assertRaises(ValueError, int, '0o08', 8)
    205         self.assertRaises(ValueError, int, '0O8', 8)
    206         self.assertRaises(ValueError, int, '0O08', 8)
    207         self.assertRaises(ValueError, int, '0xg', 16)
    208         self.assertRaises(ValueError, int, '0x0g', 16)
    209         self.assertRaises(ValueError, int, '0Xg', 16)
    210         self.assertRaises(ValueError, int, '0X0g', 16)
    211 
    212         # SF bug 1334662: int(string, base) wrong answers

    213         # Checks for proper evaluation of 2**32 + 1

    214         self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297L)
    215         self.assertEqual(int('102002022201221111212', 3), 4294967297L)
    216         self.assertEqual(int('10000000000000001', 4), 4294967297L)
    217         self.assertEqual(int('32244002423142', 5), 4294967297L)
    218         self.assertEqual(int('1550104015505', 6), 4294967297L)
    219         self.assertEqual(int('211301422355', 7), 4294967297L)
    220         self.assertEqual(int('40000000001', 8), 4294967297L)
    221         self.assertEqual(int('12068657455', 9), 4294967297L)
    222         self.assertEqual(int('4294967297', 10), 4294967297L)
    223         self.assertEqual(int('1904440555', 11), 4294967297L)
    224         self.assertEqual(int('9ba461595', 12), 4294967297L)
    225         self.assertEqual(int('535a7988a', 13), 4294967297L)
    226         self.assertEqual(int('2ca5b7465', 14), 4294967297L)
    227         self.assertEqual(int('1a20dcd82', 15), 4294967297L)
    228         self.assertEqual(int('100000001', 16), 4294967297L)
    229         self.assertEqual(int('a7ffda92', 17), 4294967297L)
    230         self.assertEqual(int('704he7g5', 18), 4294967297L)
    231         self.assertEqual(int('4f5aff67', 19), 4294967297L)
    232         self.assertEqual(int('3723ai4h', 20), 4294967297L)
    233         self.assertEqual(int('281d55i5', 21), 4294967297L)
    234         self.assertEqual(int('1fj8b185', 22), 4294967297L)
    235         self.assertEqual(int('1606k7id', 23), 4294967297L)
    236         self.assertEqual(int('mb994ah', 24), 4294967297L)
    237         self.assertEqual(int('hek2mgm', 25), 4294967297L)
    238         self.assertEqual(int('dnchbnn', 26), 4294967297L)
    239         self.assertEqual(int('b28jpdn', 27), 4294967297L)
    240         self.assertEqual(int('8pfgih5', 28), 4294967297L)
    241         self.assertEqual(int('76beigh', 29), 4294967297L)
    242         self.assertEqual(int('5qmcpqh', 30), 4294967297L)
    243         self.assertEqual(int('4q0jto5', 31), 4294967297L)
    244         self.assertEqual(int('4000001', 32), 4294967297L)
    245         self.assertEqual(int('3aokq95', 33), 4294967297L)
    246         self.assertEqual(int('2qhxjlj', 34), 4294967297L)
    247         self.assertEqual(int('2br45qc', 35), 4294967297L)
    248         self.assertEqual(int('1z141z5', 36), 4294967297L)
    249 
    250     def test_bit_length(self):
    251         tiny = 1e-10
    252         for x in xrange(-65000, 65000):
    253             k = x.bit_length()
    254             # Check equivalence with Python version

    255             self.assertEqual(k, len(bin(x).lstrip('-0b')))
    256             # Behaviour as specified in the docs

    257             if x != 0:
    258                 self.assertTrue(2**(k-1) <= abs(x) < 2**k)
    259             else:
    260                 self.assertEqual(k, 0)
    261             # Alternative definition: x.bit_length() == 1 + floor(log_2(x))

    262             if x != 0:
    263                 # When x is an exact power of 2, numeric errors can

    264                 # cause floor(log(x)/log(2)) to be one too small; for

    265                 # small x this can be fixed by adding a small quantity

    266                 # to the quotient before taking the floor.

    267                 self.assertEqual(k, 1 + math.floor(
    268                         math.log(abs(x))/math.log(2) + tiny))
    269 
    270         self.assertEqual((0).bit_length(), 0)
    271         self.assertEqual((1).bit_length(), 1)
    272         self.assertEqual((-1).bit_length(), 1)
    273         self.assertEqual((2).bit_length(), 2)
    274         self.assertEqual((-2).bit_length(), 2)
    275         for i in [2, 3, 15, 16, 17, 31, 32, 33, 63, 64]:
    276             a = 2**i
    277             self.assertEqual((a-1).bit_length(), i)
    278             self.assertEqual((1-a).bit_length(), i)
    279             self.assertEqual((a).bit_length(), i+1)
    280             self.assertEqual((-a).bit_length(), i+1)
    281             self.assertEqual((a+1).bit_length(), i+1)
    282             self.assertEqual((-a-1).bit_length(), i+1)
    283 
    284     @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
    285                          "test requires IEEE 754 doubles")
    286     def test_float_conversion(self):
    287         # values exactly representable as floats

    288         exact_values = [-2, -1, 0, 1, 2, 2**52, 2**53-1, 2**53, 2**53+2,
    289                          2**53+4, 2**54-4, 2**54-2, 2**63, -2**63, 2**64,
    290                          -2**64, 10**20, 10**21, 10**22]
    291         for value in exact_values:
    292             self.assertEqual(int(float(int(value))), value)
    293 
    294         # test round-half-to-even

    295         self.assertEqual(int(float(2**53+1)), 2**53)
    296         self.assertEqual(int(float(2**53+2)), 2**53+2)
    297         self.assertEqual(int(float(2**53+3)), 2**53+4)
    298         self.assertEqual(int(float(2**53+5)), 2**53+4)
    299         self.assertEqual(int(float(2**53+6)), 2**53+6)
    300         self.assertEqual(int(float(2**53+7)), 2**53+8)
    301 
    302         self.assertEqual(int(float(-2**53-1)), -2**53)
    303         self.assertEqual(int(float(-2**53-2)), -2**53-2)
    304         self.assertEqual(int(float(-2**53-3)), -2**53-4)
    305         self.assertEqual(int(float(-2**53-5)), -2**53-4)
    306         self.assertEqual(int(float(-2**53-6)), -2**53-6)
    307         self.assertEqual(int(float(-2**53-7)), -2**53-8)
    308 
    309         self.assertEqual(int(float(2**54-2)), 2**54-2)
    310         self.assertEqual(int(float(2**54-1)), 2**54)
    311         self.assertEqual(int(float(2**54+2)), 2**54)
    312         self.assertEqual(int(float(2**54+3)), 2**54+4)
    313         self.assertEqual(int(float(2**54+5)), 2**54+4)
    314         self.assertEqual(int(float(2**54+6)), 2**54+8)
    315         self.assertEqual(int(float(2**54+10)), 2**54+8)
    316         self.assertEqual(int(float(2**54+11)), 2**54+12)
    317 
    318     def test_intconversion(self):
    319         # Test __int__()

    320         class ClassicMissingMethods:
    321             pass
    322         self.assertRaises(AttributeError, int, ClassicMissingMethods())
    323 
    324         class MissingMethods(object):
    325             pass
    326         self.assertRaises(TypeError, int, MissingMethods())
    327 
    328         class Foo0:
    329             def __int__(self):
    330                 return 42
    331 
    332         class Foo1(object):
    333             def __int__(self):
    334                 return 42
    335 
    336         class Foo2(int):
    337             def __int__(self):
    338                 return 42
    339 
    340         class Foo3(int):
    341             def __int__(self):
    342                 return self
    343 
    344         class Foo4(int):
    345             def __int__(self):
    346                 return 42L
    347 
    348         class Foo5(int):
    349             def __int__(self):
    350                 return 42.
    351 
    352         self.assertEqual(int(Foo0()), 42)
    353         self.assertEqual(int(Foo1()), 42)
    354         self.assertEqual(int(Foo2()), 42)
    355         self.assertEqual(int(Foo3()), 0)
    356         self.assertEqual(int(Foo4()), 42L)
    357         self.assertRaises(TypeError, int, Foo5())
    358 
    359         class Classic:
    360             pass
    361         for base in (object, Classic):
    362             class IntOverridesTrunc(base):
    363                 def __int__(self):
    364                     return 42
    365                 def __trunc__(self):
    366                     return -12
    367             self.assertEqual(int(IntOverridesTrunc()), 42)
    368 
    369             class JustTrunc(base):
    370                 def __trunc__(self):
    371                     return 42
    372             self.assertEqual(int(JustTrunc()), 42)
    373 
    374             for trunc_result_base in (object, Classic):
    375                 class Integral(trunc_result_base):
    376                     def __int__(self):
    377                         return 42
    378 
    379                 class TruncReturnsNonInt(base):
    380                     def __trunc__(self):
    381                         return Integral()
    382                 self.assertEqual(int(TruncReturnsNonInt()), 42)
    383 
    384                 class NonIntegral(trunc_result_base):
    385                     def __trunc__(self):
    386                         # Check that we avoid infinite recursion.

    387                         return NonIntegral()
    388 
    389                 class TruncReturnsNonIntegral(base):
    390                     def __trunc__(self):
    391                         return NonIntegral()
    392                 try:
    393                     int(TruncReturnsNonIntegral())
    394                 except TypeError as e:
    395                     self.assertEqual(str(e),
    396                                       "__trunc__ returned non-Integral"
    397                                       " (type NonIntegral)")
    398                 else:
    399                     self.fail("Failed to raise TypeError with %s" %
    400                               ((base, trunc_result_base),))
    401 
    402 def test_main():
    403     run_unittest(IntTestCases)
    404 
    405 if __name__ == "__main__":
    406     test_main()
    407