?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Change a variable type to avoid signed overflow; replace repeated '19999' constant...
[python.git] / Lib / test / test_long.py
blob1943518e8a7861ea0cc8348d025043f7e4c61ec5
1 import unittest
2 from test import test_support
3 import sys
4
5 import random
6 import math
7
8 # Used for lazy formatting of failure messages
9 class Frm(object):
10 def __init__(self, format, *args):
11 self.format = format
12 self.args = args
13
14 def __str__(self):
15 return self.format % self.args
16
17 # SHIFT should match the value in longintrepr.h for best testing.
18 SHIFT = sys.long_info.bits_per_digit
19 BASE = 2 ** SHIFT
20 MASK = BASE - 1
21 KARATSUBA_CUTOFF = 70 # from longobject.c
22
23 # Max number of base BASE digits to use in test cases. Doubling
24 # this will more than double the runtime.
25 MAXDIGITS = 15
26
27 # build some special values
28 special = map(long, [0, 1, 2, BASE, BASE >> 1])
29 special.append(0x5555555555555555L)
30 special.append(0xaaaaaaaaaaaaaaaaL)
31 # some solid strings of one bits
32 p2 = 4L # 0 and 1 already added
33 for i in range(2*SHIFT):
34 special.append(p2 - 1)
35 p2 = p2 << 1
36 del p2
37 # add complements & negations
38 special = special + map(lambda x: ~x, special) + \
39 map(lambda x: -x, special)
40
41 L = [
42 ('0', 0),
43 ('1', 1),
44 ('9', 9),
45 ('10', 10),
46 ('99', 99),
47 ('100', 100),
48 ('314', 314),
49 (' 314', 314),
50 ('314 ', 314),
51 (' \t\t 314 \t\t ', 314),
52 (repr(sys.maxint), sys.maxint),
53 (' 1x', ValueError),
54 (' 1 ', 1),
55 (' 1\02 ', ValueError),
56 ('', ValueError),
57 (' ', ValueError),
58 (' \t\t ', ValueError)
59 ]
60 if test_support.have_unicode:
61 L += [
62 (unicode('0'), 0),
63 (unicode('1'), 1),
64 (unicode('9'), 9),
65 (unicode('10'), 10),
66 (unicode('99'), 99),
67 (unicode('100'), 100),
68 (unicode('314'), 314),
69 (unicode(' 314'), 314),
70 (unicode('\u0663\u0661\u0664 ','raw-unicode-escape'), 314),
71 (unicode(' \t\t 314 \t\t '), 314),
72 (unicode(' 1x'), ValueError),
73 (unicode(' 1 '), 1),
74 (unicode(' 1\02 '), ValueError),
75 (unicode(''), ValueError),
76 (unicode(' '), ValueError),
77 (unicode(' \t\t '), ValueError),
78 (unichr(0x200), ValueError),
79 ]
80
81
82 class LongTest(unittest.TestCase):
83
84 # Get quasi-random long consisting of ndigits digits (in base BASE).
85 # quasi == the most-significant digit will not be 0, and the number
86 # is constructed to contain long strings of 0 and 1 bits. These are
87 # more likely than random bits to provoke digit-boundary errors.
88 # The sign of the number is also random.
89
90 def getran(self, ndigits):
91 self.assertTrue(ndigits > 0)
92 nbits_hi = ndigits * SHIFT
93 nbits_lo = nbits_hi - SHIFT + 1
94 answer = 0L
95 nbits = 0
96 r = int(random.random() * (SHIFT * 2)) | 1 # force 1 bits to start
97 while nbits < nbits_lo:
98 bits = (r >> 1) + 1
99 bits = min(bits, nbits_hi - nbits)
100 self.assertTrue(1 <= bits <= SHIFT)
101 nbits = nbits + bits
102 answer = answer << bits
103 if r & 1:
104 answer = answer | ((1 << bits) - 1)
105 r = int(random.random() * (SHIFT * 2))
106 self.assertTrue(nbits_lo <= nbits <= nbits_hi)
107 if random.random() < 0.5:
108 answer = -answer
109 return answer
110
111 # Get random long consisting of ndigits random digits (relative to base
112 # BASE). The sign bit is also random.
113
114 def getran2(ndigits):
115 answer = 0L
116 for i in xrange(ndigits):
117 answer = (answer << SHIFT) | random.randint(0, MASK)
118 if random.random() < 0.5:
119 answer = -answer
120 return answer
121
122 def check_division(self, x, y):
123 eq = self.assertEqual
124 q, r = divmod(x, y)
125 q2, r2 = x//y, x%y
126 pab, pba = x*y, y*x
127 eq(pab, pba, Frm("multiplication does not commute for %r and %r", x, y))
128 eq(q, q2, Frm("divmod returns different quotient than / for %r and %r", x, y))
129 eq(r, r2, Frm("divmod returns different mod than %% for %r and %r", x, y))
130 eq(x, q*y + r, Frm("x != q*y + r after divmod on x=%r, y=%r", x, y))
131 if y > 0:
132 self.assertTrue(0 <= r < y, Frm("bad mod from divmod on %r and %r", x, y))
133 else:
134 self.assertTrue(y < r <= 0, Frm("bad mod from divmod on %r and %r", x, y))
135
136 def test_division(self):
137 digits = range(1, MAXDIGITS+1) + range(KARATSUBA_CUTOFF,
138 KARATSUBA_CUTOFF + 14)
139 digits.append(KARATSUBA_CUTOFF * 3)
140 for lenx in digits:
141 x = self.getran(lenx)
142 for leny in digits:
143 y = self.getran(leny) or 1L
144 self.check_division(x, y)
145
146 # specific numbers chosen to exercise corner cases of the
147 # current long division implementation
148
149 # 30-bit cases involving a quotient digit estimate of BASE+1
150 self.check_division(1231948412290879395966702881L,
151 1147341367131428698L)
152 self.check_division(815427756481275430342312021515587883L,
153 707270836069027745L)
154 self.check_division(627976073697012820849443363563599041L,
155 643588798496057020L)
156 self.check_division(1115141373653752303710932756325578065L,
157 1038556335171453937726882627L)
158 # 30-bit cases that require the post-subtraction correction step
159 self.check_division(922498905405436751940989320930368494L,
160 949985870686786135626943396L)
161 self.check_division(768235853328091167204009652174031844L,
162 1091555541180371554426545266L)
163
164 # 15-bit cases involving a quotient digit estimate of BASE+1
165 self.check_division(20172188947443L, 615611397L)
166 self.check_division(1020908530270155025L, 950795710L)
167 self.check_division(128589565723112408L, 736393718L)
168 self.check_division(609919780285761575L, 18613274546784L)
169 # 15-bit cases that require the post-subtraction correction step
170 self.check_division(710031681576388032L, 26769404391308L)
171 self.check_division(1933622614268221L, 30212853348836L)
172
173
174
175 def test_karatsuba(self):
176 digits = range(1, 5) + range(KARATSUBA_CUTOFF, KARATSUBA_CUTOFF + 10)
177 digits.extend([KARATSUBA_CUTOFF * 10, KARATSUBA_CUTOFF * 100])
178
179 bits = [digit * SHIFT for digit in digits]
180
181 # Test products of long strings of 1 bits -- (2**x-1)*(2**y-1) ==
182 # 2**(x+y) - 2**x - 2**y + 1, so the proper result is easy to check.
183 for abits in bits:
184 a = (1L << abits) - 1
185 for bbits in bits:
186 if bbits < abits:
187 continue
188 b = (1L << bbits) - 1
189 x = a * b
190 y = ((1L << (abits + bbits)) -
191 (1L << abits) -
192 (1L << bbits) +
193 1)
194 self.assertEqual(x, y,
195 Frm("bad result for a*b: a=%r, b=%r, x=%r, y=%r", a, b, x, y))
196
197 def check_bitop_identities_1(self, x):
198 eq = self.assertEqual
199 eq(x & 0, 0, Frm("x & 0 != 0 for x=%r", x))
200 eq(x | 0, x, Frm("x | 0 != x for x=%r", x))
201 eq(x ^ 0, x, Frm("x ^ 0 != x for x=%r", x))
202 eq(x & -1, x, Frm("x & -1 != x for x=%r", x))
203 eq(x | -1, -1, Frm("x | -1 != -1 for x=%r", x))
204 eq(x ^ -1, ~x, Frm("x ^ -1 != ~x for x=%r", x))
205 eq(x, ~~x, Frm("x != ~~x for x=%r", x))
206 eq(x & x, x, Frm("x & x != x for x=%r", x))
207 eq(x | x, x, Frm("x | x != x for x=%r", x))
208 eq(x ^ x, 0, Frm("x ^ x != 0 for x=%r", x))
209 eq(x & ~x, 0, Frm("x & ~x != 0 for x=%r", x))
210 eq(x | ~x, -1, Frm("x | ~x != -1 for x=%r", x))
211 eq(x ^ ~x, -1, Frm("x ^ ~x != -1 for x=%r", x))
212 eq(-x, 1 + ~x, Frm("not -x == 1 + ~x for x=%r", x))
213 eq(-x, ~(x-1), Frm("not -x == ~(x-1) forx =%r", x))
214 for n in xrange(2*SHIFT):
215 p2 = 2L ** n
216 eq(x << n >> n, x,
217 Frm("x << n >> n != x for x=%r, n=%r", (x, n)))
218 eq(x // p2, x >> n,
219 Frm("x // p2 != x >> n for x=%r n=%r p2=%r", (x, n, p2)))
220 eq(x * p2, x << n,
221 Frm("x * p2 != x << n for x=%r n=%r p2=%r", (x, n, p2)))
222 eq(x & -p2, x >> n << n,
223 Frm("not x & -p2 == x >> n << n for x=%r n=%r p2=%r", (x, n, p2)))
224 eq(x & -p2, x & ~(p2 - 1),
225 Frm("not x & -p2 == x & ~(p2 - 1) for x=%r n=%r p2=%r", (x, n, p2)))
226
227 def check_bitop_identities_2(self, x, y):
228 eq = self.assertEqual
229 eq(x & y, y & x, Frm("x & y != y & x for x=%r, y=%r", (x, y)))
230 eq(x | y, y | x, Frm("x | y != y | x for x=%r, y=%r", (x, y)))
231 eq(x ^ y, y ^ x, Frm("x ^ y != y ^ x for x=%r, y=%r", (x, y)))
232 eq(x ^ y ^ x, y, Frm("x ^ y ^ x != y for x=%r, y=%r", (x, y)))
233 eq(x & y, ~(~x | ~y), Frm("x & y != ~(~x | ~y) for x=%r, y=%r", (x, y)))
234 eq(x | y, ~(~x & ~y), Frm("x | y != ~(~x & ~y) for x=%r, y=%r", (x, y)))
235 eq(x ^ y, (x | y) & ~(x & y),
236 Frm("x ^ y != (x | y) & ~(x & y) for x=%r, y=%r", (x, y)))
237 eq(x ^ y, (x & ~y) | (~x & y),
238 Frm("x ^ y == (x & ~y) | (~x & y) for x=%r, y=%r", (x, y)))
239 eq(x ^ y, (x | y) & (~x | ~y),
240 Frm("x ^ y == (x | y) & (~x | ~y) for x=%r, y=%r", (x, y)))
241
242 def check_bitop_identities_3(self, x, y, z):
243 eq = self.assertEqual
244 eq((x & y) & z, x & (y & z),
245 Frm("(x & y) & z != x & (y & z) for x=%r, y=%r, z=%r", (x, y, z)))
246 eq((x | y) | z, x | (y | z),
247 Frm("(x | y) | z != x | (y | z) for x=%r, y=%r, z=%r", (x, y, z)))
248 eq((x ^ y) ^ z, x ^ (y ^ z),
249 Frm("(x ^ y) ^ z != x ^ (y ^ z) for x=%r, y=%r, z=%r", (x, y, z)))
250 eq(x & (y | z), (x & y) | (x & z),
251 Frm("x & (y | z) != (x & y) | (x & z) for x=%r, y=%r, z=%r", (x, y, z)))
252 eq(x | (y & z), (x | y) & (x | z),
253 Frm("x | (y & z) != (x | y) & (x | z) for x=%r, y=%r, z=%r", (x, y, z)))
254
255 def test_bitop_identities(self):
256 for x in special:
257 self.check_bitop_identities_1(x)
258 digits = xrange(1, MAXDIGITS+1)
259 for lenx in digits:
260 x = self.getran(lenx)
261 self.check_bitop_identities_1(x)
262 for leny in digits:
263 y = self.getran(leny)
264 self.check_bitop_identities_2(x, y)
265 self.check_bitop_identities_3(x, y, self.getran((lenx + leny)//2))
266
267 def slow_format(self, x, base):
268 if (x, base) == (0, 8):
269 # this is an oddball!
270 return "0L"
271 digits = []
272 sign = 0
273 if x < 0:
274 sign, x = 1, -x
275 while x:
276 x, r = divmod(x, base)
277 digits.append(int(r))
278 digits.reverse()
279 digits = digits or [0]
280 return '-'[:sign] + \
281 {8: '0', 10: '', 16: '0x'}[base] + \
282 "".join(map(lambda i: "0123456789abcdef"[i], digits)) + "L"
283
284 def check_format_1(self, x):
285 for base, mapper in (8, oct), (10, repr), (16, hex):
286 got = mapper(x)
287 expected = self.slow_format(x, base)
288 msg = Frm("%s returned %r but expected %r for %r",
289 mapper.__name__, got, expected, x)
290 self.assertEqual(got, expected, msg)
291 self.assertEqual(long(got, 0), x, Frm('long("%s", 0) != %r', got, x))
292 # str() has to be checked a little differently since there's no
293 # trailing "L"
294 got = str(x)
295 expected = self.slow_format(x, 10)[:-1]
296 msg = Frm("%s returned %r but expected %r for %r",
297 mapper.__name__, got, expected, x)
298 self.assertEqual(got, expected, msg)
299
300 def test_format(self):
301 for x in special:
302 self.check_format_1(x)
303 for i in xrange(10):
304 for lenx in xrange(1, MAXDIGITS+1):
305 x = self.getran(lenx)
306 self.check_format_1(x)
307
308 def test_long(self):
309 self.assertEqual(long(314), 314L)
310 self.assertEqual(long(3.14), 3L)
311 self.assertEqual(long(314L), 314L)
312 # Check that long() of basic types actually returns a long
313 self.assertEqual(type(long(314)), long)
314 self.assertEqual(type(long(3.14)), long)
315 self.assertEqual(type(long(314L)), long)
316 # Check that conversion from float truncates towards zero
317 self.assertEqual(long(-3.14), -3L)
318 self.assertEqual(long(3.9), 3L)
319 self.assertEqual(long(-3.9), -3L)
320 self.assertEqual(long(3.5), 3L)
321 self.assertEqual(long(-3.5), -3L)
322 self.assertEqual(long("-3"), -3L)
323 if test_support.have_unicode:
324 self.assertEqual(long(unicode("-3")), -3L)
325 # Different base:
326 self.assertEqual(long("10",16), 16L)
327 if test_support.have_unicode:
328 self.assertEqual(long(unicode("10"),16), 16L)
329 # Check conversions from string (same test set as for int(), and then some)
330 LL = [
331 ('1' + '0'*20, 10L**20),
332 ('1' + '0'*100, 10L**100)
333 ]
334 L2 = L[:]
335 if test_support.have_unicode:
336 L2 += [
337 (unicode('1') + unicode('0')*20, 10L**20),
338 (unicode('1') + unicode('0')*100, 10L**100),
339 ]
340 for s, v in L2 + LL:
341 for sign in "", "+", "-":
342 for prefix in "", " ", "\t", " \t\t ":
343 ss = prefix + sign + s
344 vv = v
345 if sign == "-" and v is not ValueError:
346 vv = -v
347 try:
348 self.assertEqual(long(ss), long(vv))
349 except v:
350 pass
351
352 self.assertRaises(ValueError, long, '123\0')
353 self.assertRaises(ValueError, long, '53', 40)
354 self.assertRaises(TypeError, long, 1, 12)
355
356 # SF patch #1638879: embedded NULs were not detected with
357 # explicit base
358 self.assertRaises(ValueError, long, '123\0', 10)
359 self.assertRaises(ValueError, long, '123\x00 245', 20)
360
361 self.assertEqual(long('100000000000000000000000000000000', 2),
362 4294967296)
363 self.assertEqual(long('102002022201221111211', 3), 4294967296)
364 self.assertEqual(long('10000000000000000', 4), 4294967296)
365 self.assertEqual(long('32244002423141', 5), 4294967296)
366 self.assertEqual(long('1550104015504', 6), 4294967296)
367 self.assertEqual(long('211301422354', 7), 4294967296)
368 self.assertEqual(long('40000000000', 8), 4294967296)
369 self.assertEqual(long('12068657454', 9), 4294967296)
370 self.assertEqual(long('4294967296', 10), 4294967296)
371 self.assertEqual(long('1904440554', 11), 4294967296)
372 self.assertEqual(long('9ba461594', 12), 4294967296)
373 self.assertEqual(long('535a79889', 13), 4294967296)
374 self.assertEqual(long('2ca5b7464', 14), 4294967296)
375 self.assertEqual(long('1a20dcd81', 15), 4294967296)
376 self.assertEqual(long('100000000', 16), 4294967296)
377 self.assertEqual(long('a7ffda91', 17), 4294967296)
378 self.assertEqual(long('704he7g4', 18), 4294967296)
379 self.assertEqual(long('4f5aff66', 19), 4294967296)
380 self.assertEqual(long('3723ai4g', 20), 4294967296)
381 self.assertEqual(long('281d55i4', 21), 4294967296)
382 self.assertEqual(long('1fj8b184', 22), 4294967296)
383 self.assertEqual(long('1606k7ic', 23), 4294967296)
384 self.assertEqual(long('mb994ag', 24), 4294967296)
385 self.assertEqual(long('hek2mgl', 25), 4294967296)
386 self.assertEqual(long('dnchbnm', 26), 4294967296)
387 self.assertEqual(long('b28jpdm', 27), 4294967296)
388 self.assertEqual(long('8pfgih4', 28), 4294967296)
389 self.assertEqual(long('76beigg', 29), 4294967296)
390 self.assertEqual(long('5qmcpqg', 30), 4294967296)
391 self.assertEqual(long('4q0jto4', 31), 4294967296)
392 self.assertEqual(long('4000000', 32), 4294967296)
393 self.assertEqual(long('3aokq94', 33), 4294967296)
394 self.assertEqual(long('2qhxjli', 34), 4294967296)
395 self.assertEqual(long('2br45qb', 35), 4294967296)
396 self.assertEqual(long('1z141z4', 36), 4294967296)
397
398 self.assertEqual(long('100000000000000000000000000000001', 2),
399 4294967297)
400 self.assertEqual(long('102002022201221111212', 3), 4294967297)
401 self.assertEqual(long('10000000000000001', 4), 4294967297)
402 self.assertEqual(long('32244002423142', 5), 4294967297)
403 self.assertEqual(long('1550104015505', 6), 4294967297)
404 self.assertEqual(long('211301422355', 7), 4294967297)
405 self.assertEqual(long('40000000001', 8), 4294967297)
406 self.assertEqual(long('12068657455', 9), 4294967297)
407 self.assertEqual(long('4294967297', 10), 4294967297)
408 self.assertEqual(long('1904440555', 11), 4294967297)
409 self.assertEqual(long('9ba461595', 12), 4294967297)
410 self.assertEqual(long('535a7988a', 13), 4294967297)
411 self.assertEqual(long('2ca5b7465', 14), 4294967297)
412 self.assertEqual(long('1a20dcd82', 15), 4294967297)
413 self.assertEqual(long('100000001', 16), 4294967297)
414 self.assertEqual(long('a7ffda92', 17), 4294967297)
415 self.assertEqual(long('704he7g5', 18), 4294967297)
416 self.assertEqual(long('4f5aff67', 19), 4294967297)
417 self.assertEqual(long('3723ai4h', 20), 4294967297)
418 self.assertEqual(long('281d55i5', 21), 4294967297)
419 self.assertEqual(long('1fj8b185', 22), 4294967297)
420 self.assertEqual(long('1606k7id', 23), 4294967297)
421 self.assertEqual(long('mb994ah', 24), 4294967297)
422 self.assertEqual(long('hek2mgm', 25), 4294967297)
423 self.assertEqual(long('dnchbnn', 26), 4294967297)
424 self.assertEqual(long('b28jpdn', 27), 4294967297)
425 self.assertEqual(long('8pfgih5', 28), 4294967297)
426 self.assertEqual(long('76beigh', 29), 4294967297)
427 self.assertEqual(long('5qmcpqh', 30), 4294967297)
428 self.assertEqual(long('4q0jto5', 31), 4294967297)
429 self.assertEqual(long('4000001', 32), 4294967297)
430 self.assertEqual(long('3aokq95', 33), 4294967297)
431 self.assertEqual(long('2qhxjlj', 34), 4294967297)
432 self.assertEqual(long('2br45qc', 35), 4294967297)
433 self.assertEqual(long('1z141z5', 36), 4294967297)
434
435
436 def test_conversion(self):
437 # Test __long__()
438 class ClassicMissingMethods:
439 pass
440 self.assertRaises(AttributeError, long, ClassicMissingMethods())
441
442 class MissingMethods(object):
443 pass
444 self.assertRaises(TypeError, long, MissingMethods())
445
446 class Foo0:
447 def __long__(self):
448 return 42L
449
450 class Foo1(object):
451 def __long__(self):
452 return 42L
453
454 class Foo2(long):
455 def __long__(self):
456 return 42L
457
458 class Foo3(long):
459 def __long__(self):
460 return self
461
462 class Foo4(long):
463 def __long__(self):
464 return 42
465
466 class Foo5(long):
467 def __long__(self):
468 return 42.
469
470 self.assertEqual(long(Foo0()), 42L)
471 self.assertEqual(long(Foo1()), 42L)
472 self.assertEqual(long(Foo2()), 42L)
473 self.assertEqual(long(Foo3()), 0)
474 self.assertEqual(long(Foo4()), 42)
475 self.assertRaises(TypeError, long, Foo5())
476
477 class Classic:
478 pass
479 for base in (object, Classic):
480 class LongOverridesTrunc(base):
481 def __long__(self):
482 return 42
483 def __trunc__(self):
484 return -12
485 self.assertEqual(long(LongOverridesTrunc()), 42)
486
487 class JustTrunc(base):
488 def __trunc__(self):
489 return 42
490 self.assertEqual(long(JustTrunc()), 42)
491
492 for trunc_result_base in (object, Classic):
493 class Integral(trunc_result_base):
494 def __int__(self):
495 return 42
496
497 class TruncReturnsNonLong(base):
498 def __trunc__(self):
499 return Integral()
500 self.assertEqual(long(TruncReturnsNonLong()), 42)
501
502 class NonIntegral(trunc_result_base):
503 def __trunc__(self):
504 # Check that we avoid infinite recursion.
505 return NonIntegral()
506
507 class TruncReturnsNonIntegral(base):
508 def __trunc__(self):
509 return NonIntegral()
510 try:
511 long(TruncReturnsNonIntegral())
512 except TypeError as e:
513 self.assertEquals(str(e),
514 "__trunc__ returned non-Integral"
515 " (type NonIntegral)")
516 else:
517 self.fail("Failed to raise TypeError with %s" %
518 ((base, trunc_result_base),))
519
520 def test_misc(self):
521
522 # check the extremes in int<->long conversion
523 hugepos = sys.maxint
524 hugeneg = -hugepos - 1
525 hugepos_aslong = long(hugepos)
526 hugeneg_aslong = long(hugeneg)
527 self.assertEqual(hugepos, hugepos_aslong, "long(sys.maxint) != sys.maxint")
528 self.assertEqual(hugeneg, hugeneg_aslong,
529 "long(-sys.maxint-1) != -sys.maxint-1")
530
531 # long -> int should not fail for hugepos_aslong or hugeneg_aslong
532 x = int(hugepos_aslong)
533 try:
534 self.assertEqual(x, hugepos,
535 "converting sys.maxint to long and back to int fails")
536 except OverflowError:
537 self.fail("int(long(sys.maxint)) overflowed!")
538 if not isinstance(x, int):
539 raise TestFailed("int(long(sys.maxint)) should have returned int")
540 x = int(hugeneg_aslong)
541 try:
542 self.assertEqual(x, hugeneg,
543 "converting -sys.maxint-1 to long and back to int fails")
544 except OverflowError:
545 self.fail("int(long(-sys.maxint-1)) overflowed!")
546 if not isinstance(x, int):
547 raise TestFailed("int(long(-sys.maxint-1)) should have "
548 "returned int")
549 # but long -> int should overflow for hugepos+1 and hugeneg-1
550 x = hugepos_aslong + 1
551 try:
552 y = int(x)
553 except OverflowError:
554 self.fail("int(long(sys.maxint) + 1) mustn't overflow")
555 self.assertTrue(isinstance(y, long),
556 "int(long(sys.maxint) + 1) should have returned long")
557
558 x = hugeneg_aslong - 1
559 try:
560 y = int(x)
561 except OverflowError:
562 self.fail("int(long(-sys.maxint-1) - 1) mustn't overflow")
563 self.assertTrue(isinstance(y, long),
564 "int(long(-sys.maxint-1) - 1) should have returned long")
565
566 class long2(long):
567 pass
568 x = long2(1L<<100)
569 y = int(x)
570 self.assertTrue(type(y) is long,
571 "overflowing int conversion must return long not long subtype")
572
573 # long -> Py_ssize_t conversion
574 class X(object):
575 def __getslice__(self, i, j):
576 return i, j
577
578 self.assertEqual(X()[-5L:7L], (-5, 7))
579 # use the clamping effect to test the smallest and largest longs
580 # that fit a Py_ssize_t
581 slicemin, slicemax = X()[-2L**100:2L**100]
582 self.assertEqual(X()[slicemin:slicemax], (slicemin, slicemax))
583
584 # ----------------------------------- tests of auto int->long conversion
585
586 def test_auto_overflow(self):
587 import math, sys
588
589 special = [0, 1, 2, 3, sys.maxint-1, sys.maxint, sys.maxint+1]
590 sqrt = int(math.sqrt(sys.maxint))
591 special.extend([sqrt-1, sqrt, sqrt+1])
592 special.extend([-i for i in special])
593
594 def checkit(*args):
595 # Heavy use of nested scopes here!
596 self.assertEqual(got, expected,
597 Frm("for %r expected %r got %r", args, expected, got))
598
599 for x in special:
600 longx = long(x)
601
602 expected = -longx
603 got = -x
604 checkit('-', x)
605
606 for y in special:
607 longy = long(y)
608
609 expected = longx + longy
610 got = x + y
611 checkit(x, '+', y)
612
613 expected = longx - longy
614 got = x - y
615 checkit(x, '-', y)
616
617 expected = longx * longy
618 got = x * y
619 checkit(x, '*', y)
620
621 if y:
622 expected = longx / longy
623 got = x / y
624 checkit(x, '/', y)
625
626 expected = longx // longy
627 got = x // y
628 checkit(x, '//', y)
629
630 expected = divmod(longx, longy)
631 got = divmod(longx, longy)
632 checkit(x, 'divmod', y)
633
634 if abs(y) < 5 and not (x == 0 and y < 0):
635 expected = longx ** longy
636 got = x ** y
637 checkit(x, '**', y)
638
639 for z in special:
640 if z != 0 :
641 if y >= 0:
642 expected = pow(longx, longy, long(z))
643 got = pow(x, y, z)
644 checkit('pow', x, y, '%', z)
645 else:
646 self.assertRaises(TypeError, pow,longx, longy, long(z))
647
648 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
649 "test requires IEEE 754 doubles")
650 def test_float_conversion(self):
651 import sys
652 DBL_MAX = sys.float_info.max
653 DBL_MAX_EXP = sys.float_info.max_exp
654 DBL_MANT_DIG = sys.float_info.mant_dig
655
656 exact_values = [0L, 1L, 2L,
657 long(2**53-3),
658 long(2**53-2),
659 long(2**53-1),
660 long(2**53),
661 long(2**53+2),
662 long(2**54-4),
663 long(2**54-2),
664 long(2**54),
665 long(2**54+4)]
666 for x in exact_values:
667 self.assertEqual(long(float(x)), x)
668 self.assertEqual(long(float(-x)), -x)
669
670 # test round-half-even
671 for x, y in [(1, 0), (2, 2), (3, 4), (4, 4), (5, 4), (6, 6), (7, 8)]:
672 for p in xrange(15):
673 self.assertEqual(long(float(2L**p*(2**53+x))), 2L**p*(2**53+y))
674
675 for x, y in [(0, 0), (1, 0), (2, 0), (3, 4), (4, 4), (5, 4), (6, 8),
676 (7, 8), (8, 8), (9, 8), (10, 8), (11, 12), (12, 12),
677 (13, 12), (14, 16), (15, 16)]:
678 for p in xrange(15):
679 self.assertEqual(long(float(2L**p*(2**54+x))), 2L**p*(2**54+y))
680
681 # behaviour near extremes of floating-point range
682 long_dbl_max = long(DBL_MAX)
683 top_power = 2**DBL_MAX_EXP
684 halfway = (long_dbl_max + top_power)//2
685 self.assertEqual(float(long_dbl_max), DBL_MAX)
686 self.assertEqual(float(long_dbl_max+1), DBL_MAX)
687 self.assertEqual(float(halfway-1), DBL_MAX)
688 self.assertRaises(OverflowError, float, halfway)
689 self.assertEqual(float(1-halfway), -DBL_MAX)
690 self.assertRaises(OverflowError, float, -halfway)
691 self.assertRaises(OverflowError, float, top_power-1)
692 self.assertRaises(OverflowError, float, top_power)
693 self.assertRaises(OverflowError, float, top_power+1)
694 self.assertRaises(OverflowError, float, 2*top_power-1)
695 self.assertRaises(OverflowError, float, 2*top_power)
696 self.assertRaises(OverflowError, float, top_power*top_power)
697
698 for p in xrange(100):
699 x = long(2**p * (2**53 + 1) + 1)
700 y = long(2**p * (2**53+ 2))
701 self.assertEqual(long(float(x)), y)
702
703 x = long(2**p * (2**53 + 1))
704 y = long(2**p * 2**53)
705 self.assertEqual(long(float(x)), y)
706
707 def test_float_overflow(self):
708 import math
709
710 for x in -2.0, -1.0, 0.0, 1.0, 2.0:
711 self.assertEqual(float(long(x)), x)
712
713 shuge = '12345' * 120
714 huge = 1L << 30000
715 mhuge = -huge
716 namespace = {'huge': huge, 'mhuge': mhuge, 'shuge': shuge, 'math': math}
717 for test in ["float(huge)", "float(mhuge)",
718 "complex(huge)", "complex(mhuge)",
719 "complex(huge, 1)", "complex(mhuge, 1)",
720 "complex(1, huge)", "complex(1, mhuge)",
721 "1. + huge", "huge + 1.", "1. + mhuge", "mhuge + 1.",
722 "1. - huge", "huge - 1.", "1. - mhuge", "mhuge - 1.",
723 "1. * huge", "huge * 1.", "1. * mhuge", "mhuge * 1.",
724 "1. // huge", "huge // 1.", "1. // mhuge", "mhuge // 1.",
725 "1. / huge", "huge / 1.", "1. / mhuge", "mhuge / 1.",
726 "1. ** huge", "huge ** 1.", "1. ** mhuge", "mhuge ** 1.",
727 "math.sin(huge)", "math.sin(mhuge)",
728 "math.sqrt(huge)", "math.sqrt(mhuge)", # should do better
729 "math.floor(huge)", "math.floor(mhuge)"]:
730
731 self.assertRaises(OverflowError, eval, test, namespace)
732
733 # XXX Perhaps float(shuge) can raise OverflowError on some box?
734 # The comparison should not.
735 self.assertNotEqual(float(shuge), int(shuge),
736 "float(shuge) should not equal int(shuge)")
737
738 def test_logs(self):
739 import math
740
741 LOG10E = math.log10(math.e)
742
743 for exp in range(10) + [100, 1000, 10000]:
744 value = 10 ** exp
745 log10 = math.log10(value)
746 self.assertAlmostEqual(log10, exp)
747
748 # log10(value) == exp, so log(value) == log10(value)/log10(e) ==
749 # exp/LOG10E
750 expected = exp / LOG10E
751 log = math.log(value)
752 self.assertAlmostEqual(log, expected)
753
754 for bad in -(1L << 10000), -2L, 0L:
755 self.assertRaises(ValueError, math.log, bad)
756 self.assertRaises(ValueError, math.log10, bad)
757
758 def test_mixed_compares(self):
759 eq = self.assertEqual
760 import math
761
762 # We're mostly concerned with that mixing floats and longs does the
763 # right stuff, even when longs are too large to fit in a float.
764 # The safest way to check the results is to use an entirely different
765 # method, which we do here via a skeletal rational class (which
766 # represents all Python ints, longs and floats exactly).
767 class Rat:
768 def __init__(self, value):
769 if isinstance(value, (int, long)):
770 self.n = value
771 self.d = 1
772 elif isinstance(value, float):
773 # Convert to exact rational equivalent.
774 f, e = math.frexp(abs(value))
775 assert f == 0 or 0.5 <= f < 1.0
776 # |value| = f * 2**e exactly
777
778 # Suck up CHUNK bits at a time; 28 is enough so that we suck
779 # up all bits in 2 iterations for all known binary double-
780 # precision formats, and small enough to fit in an int.
781 CHUNK = 28
782 top = 0
783 # invariant: |value| = (top + f) * 2**e exactly
784 while f:
785 f = math.ldexp(f, CHUNK)
786 digit = int(f)
787 assert digit >> CHUNK == 0
788 top = (top << CHUNK) | digit
789 f -= digit
790 assert 0.0 <= f < 1.0
791 e -= CHUNK
792
793 # Now |value| = top * 2**e exactly.
794 if e >= 0:
795 n = top << e
796 d = 1
797 else:
798 n = top
799 d = 1 << -e
800 if value < 0:
801 n = -n
802 self.n = n
803 self.d = d
804 assert float(n) / float(d) == value
805 else:
806 raise TypeError("can't deal with %r" % val)
807
808 def __cmp__(self, other):
809 if not isinstance(other, Rat):
810 other = Rat(other)
811 return cmp(self.n * other.d, self.d * other.n)
812
813 cases = [0, 0.001, 0.99, 1.0, 1.5, 1e20, 1e200]
814 # 2**48 is an important boundary in the internals. 2**53 is an
815 # important boundary for IEEE double precision.
816 for t in 2.0**48, 2.0**50, 2.0**53:
817 cases.extend([t - 1.0, t - 0.3, t, t + 0.3, t + 1.0,
818 long(t-1), long(t), long(t+1)])
819 cases.extend([0, 1, 2, sys.maxint, float(sys.maxint)])
820 # 1L<<20000 should exceed all double formats. long(1e200) is to
821 # check that we get equality with 1e200 above.
822 t = long(1e200)
823 cases.extend([0L, 1L, 2L, 1L << 20000, t-1, t, t+1])
824 cases.extend([-x for x in cases])
825 for x in cases:
826 Rx = Rat(x)
827 for y in cases:
828 Ry = Rat(y)
829 Rcmp = cmp(Rx, Ry)
830 xycmp = cmp(x, y)
831 eq(Rcmp, xycmp, Frm("%r %r %d %d", x, y, Rcmp, xycmp))
832 eq(x == y, Rcmp == 0, Frm("%r == %r %d", x, y, Rcmp))
833 eq(x != y, Rcmp != 0, Frm("%r != %r %d", x, y, Rcmp))
834 eq(x < y, Rcmp < 0, Frm("%r < %r %d", x, y, Rcmp))
835 eq(x <= y, Rcmp <= 0, Frm("%r <= %r %d", x, y, Rcmp))
836 eq(x > y, Rcmp > 0, Frm("%r > %r %d", x, y, Rcmp))
837 eq(x >= y, Rcmp >= 0, Frm("%r >= %r %d", x, y, Rcmp))
838
839 def test_nan_inf(self):
840 self.assertRaises(OverflowError, long, float('inf'))
841 self.assertRaises(OverflowError, long, float('-inf'))
842 self.assertRaises(ValueError, long, float('nan'))
843
844 def test_bit_length(self):
845 tiny = 1e-10
846 for x in xrange(-65000, 65000):
847 x = long(x)
848 k = x.bit_length()
849 # Check equivalence with Python version
850 self.assertEqual(k, len(bin(x).lstrip('-0b')))
851 # Behaviour as specified in the docs
852 if x != 0:
853 self.assertTrue(2**(k-1) <= abs(x) < 2**k)
854 else:
855 self.assertEqual(k, 0)
856 # Alternative definition: x.bit_length() == 1 + floor(log_2(x))
857 if x != 0:
858 # When x is an exact power of 2, numeric errors can
859 # cause floor(log(x)/log(2)) to be one too small; for
860 # small x this can be fixed by adding a small quantity
861 # to the quotient before taking the floor.
862 self.assertEqual(k, 1 + math.floor(
863 math.log(abs(x))/math.log(2) + tiny))
864
865 self.assertEqual((0L).bit_length(), 0)
866 self.assertEqual((1L).bit_length(), 1)
867 self.assertEqual((-1L).bit_length(), 1)
868 self.assertEqual((2L).bit_length(), 2)
869 self.assertEqual((-2L).bit_length(), 2)
870 for i in [2, 3, 15, 16, 17, 31, 32, 33, 63, 64, 234]:
871 a = 2L**i
872 self.assertEqual((a-1).bit_length(), i)
873 self.assertEqual((1-a).bit_length(), i)
874 self.assertEqual((a).bit_length(), i+1)
875 self.assertEqual((-a).bit_length(), i+1)
876 self.assertEqual((a+1).bit_length(), i+1)
877 self.assertEqual((-a-1).bit_length(), i+1)
878
879
880 def test_main():
881 test_support.run_unittest(LongTest)
882
883 if __name__ == "__main__":
884 test_main()
python git mirror