Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython2 / 1a707981c8b57e5ca7c5b8aa38d3e5e6ca235dbf / . / Lib / test / test_int.py
blob: ce18ad2bdeab2059dd79b0214113a3caeee81d7f [file] [log] [blame]
Benjamin Peterson979395b2008-05-03 21:35:18 +0000[diff] [blame]1import sys
2
3import unittest
4from test.test_support import run_unittest, have_unicode
Mark Dickinson1a707982008-12-17 16:14:37 +0000[diff] [blame^]5import math
Benjamin Peterson979395b2008-05-03 21:35:18 +0000[diff] [blame]6
7L = [
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]
26if 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
47class 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.assert_(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.assert_(isinstance(x, long))
86 x = int(-1e100)
87 self.assert_(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.assert_(isinstance(x, long))
106
107 if have_unicode:
108 x = int(unichr(0x661) * 600)
109 self.assert_(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
Mark Dickinson1a707982008-12-17 16:14:37 +0000[diff] [blame^]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.assert_(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
Benjamin Peterson979395b2008-05-03 21:35:18 +0000[diff] [blame]278 def test_intconversion(self):
279 # Test __int__()
280 class ClassicMissingMethods:
281 pass
282 self.assertRaises(AttributeError, int, ClassicMissingMethods())
283
284 class MissingMethods(object):
285 pass
286 self.assertRaises(TypeError, int, MissingMethods())
287
288 class Foo0:
289 def __int__(self):
290 return 42
291
292 class Foo1(object):
293 def __int__(self):
294 return 42
295
296 class Foo2(int):
297 def __int__(self):
298 return 42
299
300 class Foo3(int):
301 def __int__(self):
302 return self
303
304 class Foo4(int):
305 def __int__(self):
306 return 42L
307
308 class Foo5(int):
309 def __int__(self):
310 return 42.
311
312 self.assertEqual(int(Foo0()), 42)
313 self.assertEqual(int(Foo1()), 42)
314 self.assertEqual(int(Foo2()), 42)
315 self.assertEqual(int(Foo3()), 0)
316 self.assertEqual(int(Foo4()), 42L)
317 self.assertRaises(TypeError, int, Foo5())
318
319 class Classic:
320 pass
321 for base in (object, Classic):
322 class IntOverridesTrunc(base):
323 def __int__(self):
324 return 42
325 def __trunc__(self):
326 return -12
327 self.assertEqual(int(IntOverridesTrunc()), 42)
328
329 class JustTrunc(base):
330 def __trunc__(self):
331 return 42
332 self.assertEqual(int(JustTrunc()), 42)
333
334 for trunc_result_base in (object, Classic):
335 class Integral(trunc_result_base):
336 def __int__(self):
337 return 42
338
339 class TruncReturnsNonInt(base):
340 def __trunc__(self):
341 return Integral()
342 self.assertEqual(int(TruncReturnsNonInt()), 42)
343
344 class NonIntegral(trunc_result_base):
345 def __trunc__(self):
346 # Check that we avoid infinite recursion.
347 return NonIntegral()
348
349 class TruncReturnsNonIntegral(base):
350 def __trunc__(self):
351 return NonIntegral()
352 try:
353 int(TruncReturnsNonIntegral())
354 except TypeError as e:
355 self.assertEquals(str(e),
356 "__trunc__ returned non-Integral"
357 " (type NonIntegral)")
358 else:
359 self.fail("Failed to raise TypeError with %s" %
360 ((base, trunc_result_base),))
361
362def test_main():
363 run_unittest(IntTestCases)
364
365if __name__ == "__main__":
366 test_main()