]> git.proxmox.com Git - mirror_edk2.git/blob - AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_long.py
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
AppPkg/Applications/Python: Add Python 2.7.2 sources since the release of Python...
[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_long.py
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 self.assertEqual(long("0b10", 2), 2L)
324 self.assertEqual(long("0o10", 8), 8L)
325 self.assertEqual(long("0x10", 16), 16L)
326 if test_support.have_unicode:
327 self.assertEqual(long(unicode("-3")), -3L)
328 # Different base:
329 self.assertEqual(long("10",16), 16L)
330 if test_support.have_unicode:
331 self.assertEqual(long(unicode("10"),16), 16L)
332 # Check conversions from string (same test set as for int(), and then some)
333 LL = [
334 ('1' + '0'*20, 10L**20),
335 ('1' + '0'*100, 10L**100)
336 ]
337 L2 = L[:]
338 if test_support.have_unicode:
339 L2 += [
340 (unicode('1') + unicode('0')*20, 10L**20),
341 (unicode('1') + unicode('0')*100, 10L**100),
342 ]
343 for s, v in L2 + LL:
344 for sign in "", "+", "-":
345 for prefix in "", " ", "\t", " \t\t ":
346 ss = prefix + sign + s
347 vv = v
348 if sign == "-" and v is not ValueError:
349 vv = -v
350 try:
351 self.assertEqual(long(ss), long(vv))
352 except v:
353 pass
354
355 self.assertRaises(ValueError, long, '123\0')
356 self.assertRaises(ValueError, long, '53', 40)
357 self.assertRaises(TypeError, long, 1, 12)
358
359 # tests with base 0
360 self.assertEqual(long(' 0123 ', 0), 83)
361 self.assertEqual(long(' 0123 ', 0), 83)
362 self.assertEqual(long('000', 0), 0)
363 self.assertEqual(long('0o123', 0), 83)
364 self.assertEqual(long('0x123', 0), 291)
365 self.assertEqual(long('0b100', 0), 4)
366 self.assertEqual(long(' 0O123 ', 0), 83)
367 self.assertEqual(long(' 0X123 ', 0), 291)
368 self.assertEqual(long(' 0B100 ', 0), 4)
369 self.assertEqual(long('0', 0), 0)
370 self.assertEqual(long('+0', 0), 0)
371 self.assertEqual(long('-0', 0), 0)
372 self.assertEqual(long('00', 0), 0)
373 self.assertRaises(ValueError, long, '08', 0)
374 self.assertRaises(ValueError, long, '-012395', 0)
375
376 # SF patch #1638879: embedded NULs were not detected with
377 # explicit base
378 self.assertRaises(ValueError, long, '123\0', 10)
379 self.assertRaises(ValueError, long, '123\x00 245', 20)
380
381 self.assertEqual(long('100000000000000000000000000000000', 2),
382 4294967296)
383 self.assertEqual(long('102002022201221111211', 3), 4294967296)
384 self.assertEqual(long('10000000000000000', 4), 4294967296)
385 self.assertEqual(long('32244002423141', 5), 4294967296)
386 self.assertEqual(long('1550104015504', 6), 4294967296)
387 self.assertEqual(long('211301422354', 7), 4294967296)
388 self.assertEqual(long('40000000000', 8), 4294967296)
389 self.assertEqual(long('12068657454', 9), 4294967296)
390 self.assertEqual(long('4294967296', 10), 4294967296)
391 self.assertEqual(long('1904440554', 11), 4294967296)
392 self.assertEqual(long('9ba461594', 12), 4294967296)
393 self.assertEqual(long('535a79889', 13), 4294967296)
394 self.assertEqual(long('2ca5b7464', 14), 4294967296)
395 self.assertEqual(long('1a20dcd81', 15), 4294967296)
396 self.assertEqual(long('100000000', 16), 4294967296)
397 self.assertEqual(long('a7ffda91', 17), 4294967296)
398 self.assertEqual(long('704he7g4', 18), 4294967296)
399 self.assertEqual(long('4f5aff66', 19), 4294967296)
400 self.assertEqual(long('3723ai4g', 20), 4294967296)
401 self.assertEqual(long('281d55i4', 21), 4294967296)
402 self.assertEqual(long('1fj8b184', 22), 4294967296)
403 self.assertEqual(long('1606k7ic', 23), 4294967296)
404 self.assertEqual(long('mb994ag', 24), 4294967296)
405 self.assertEqual(long('hek2mgl', 25), 4294967296)
406 self.assertEqual(long('dnchbnm', 26), 4294967296)
407 self.assertEqual(long('b28jpdm', 27), 4294967296)
408 self.assertEqual(long('8pfgih4', 28), 4294967296)
409 self.assertEqual(long('76beigg', 29), 4294967296)
410 self.assertEqual(long('5qmcpqg', 30), 4294967296)
411 self.assertEqual(long('4q0jto4', 31), 4294967296)
412 self.assertEqual(long('4000000', 32), 4294967296)
413 self.assertEqual(long('3aokq94', 33), 4294967296)
414 self.assertEqual(long('2qhxjli', 34), 4294967296)
415 self.assertEqual(long('2br45qb', 35), 4294967296)
416 self.assertEqual(long('1z141z4', 36), 4294967296)
417
418 self.assertEqual(long('100000000000000000000000000000001', 2),
419 4294967297)
420 self.assertEqual(long('102002022201221111212', 3), 4294967297)
421 self.assertEqual(long('10000000000000001', 4), 4294967297)
422 self.assertEqual(long('32244002423142', 5), 4294967297)
423 self.assertEqual(long('1550104015505', 6), 4294967297)
424 self.assertEqual(long('211301422355', 7), 4294967297)
425 self.assertEqual(long('40000000001', 8), 4294967297)
426 self.assertEqual(long('12068657455', 9), 4294967297)
427 self.assertEqual(long('4294967297', 10), 4294967297)
428 self.assertEqual(long('1904440555', 11), 4294967297)
429 self.assertEqual(long('9ba461595', 12), 4294967297)
430 self.assertEqual(long('535a7988a', 13), 4294967297)
431 self.assertEqual(long('2ca5b7465', 14), 4294967297)
432 self.assertEqual(long('1a20dcd82', 15), 4294967297)
433 self.assertEqual(long('100000001', 16), 4294967297)
434 self.assertEqual(long('a7ffda92', 17), 4294967297)
435 self.assertEqual(long('704he7g5', 18), 4294967297)
436 self.assertEqual(long('4f5aff67', 19), 4294967297)
437 self.assertEqual(long('3723ai4h', 20), 4294967297)
438 self.assertEqual(long('281d55i5', 21), 4294967297)
439 self.assertEqual(long('1fj8b185', 22), 4294967297)
440 self.assertEqual(long('1606k7id', 23), 4294967297)
441 self.assertEqual(long('mb994ah', 24), 4294967297)
442 self.assertEqual(long('hek2mgm', 25), 4294967297)
443 self.assertEqual(long('dnchbnn', 26), 4294967297)
444 self.assertEqual(long('b28jpdn', 27), 4294967297)
445 self.assertEqual(long('8pfgih5', 28), 4294967297)
446 self.assertEqual(long('76beigh', 29), 4294967297)
447 self.assertEqual(long('5qmcpqh', 30), 4294967297)
448 self.assertEqual(long('4q0jto5', 31), 4294967297)
449 self.assertEqual(long('4000001', 32), 4294967297)
450 self.assertEqual(long('3aokq95', 33), 4294967297)
451 self.assertEqual(long('2qhxjlj', 34), 4294967297)
452 self.assertEqual(long('2br45qc', 35), 4294967297)
453 self.assertEqual(long('1z141z5', 36), 4294967297)
454
455
456 def test_conversion(self):
457 # Test __long__()
458 class ClassicMissingMethods:
459 pass
460 self.assertRaises(AttributeError, long, ClassicMissingMethods())
461
462 class MissingMethods(object):
463 pass
464 self.assertRaises(TypeError, long, MissingMethods())
465
466 class Foo0:
467 def __long__(self):
468 return 42L
469
470 class Foo1(object):
471 def __long__(self):
472 return 42L
473
474 class Foo2(long):
475 def __long__(self):
476 return 42L
477
478 class Foo3(long):
479 def __long__(self):
480 return self
481
482 class Foo4(long):
483 def __long__(self):
484 return 42
485
486 class Foo5(long):
487 def __long__(self):
488 return 42.
489
490 self.assertEqual(long(Foo0()), 42L)
491 self.assertEqual(long(Foo1()), 42L)
492 self.assertEqual(long(Foo2()), 42L)
493 self.assertEqual(long(Foo3()), 0)
494 self.assertEqual(long(Foo4()), 42)
495 self.assertRaises(TypeError, long, Foo5())
496
497 class Classic:
498 pass
499 for base in (object, Classic):
500 class LongOverridesTrunc(base):
501 def __long__(self):
502 return 42
503 def __trunc__(self):
504 return -12
505 self.assertEqual(long(LongOverridesTrunc()), 42)
506
507 class JustTrunc(base):
508 def __trunc__(self):
509 return 42
510 self.assertEqual(long(JustTrunc()), 42)
511
512 for trunc_result_base in (object, Classic):
513 class Integral(trunc_result_base):
514 def __int__(self):
515 return 42
516
517 class TruncReturnsNonLong(base):
518 def __trunc__(self):
519 return Integral()
520 self.assertEqual(long(TruncReturnsNonLong()), 42)
521
522 class NonIntegral(trunc_result_base):
523 def __trunc__(self):
524 # Check that we avoid infinite recursion.
525 return NonIntegral()
526
527 class TruncReturnsNonIntegral(base):
528 def __trunc__(self):
529 return NonIntegral()
530 try:
531 long(TruncReturnsNonIntegral())
532 except TypeError as e:
533 self.assertEqual(str(e),
534 "__trunc__ returned non-Integral"
535 " (type NonIntegral)")
536 else:
537 self.fail("Failed to raise TypeError with %s" %
538 ((base, trunc_result_base),))
539
540 def test_misc(self):
541
542 # check the extremes in int<->long conversion
543 hugepos = sys.maxint
544 hugeneg = -hugepos - 1
545 hugepos_aslong = long(hugepos)
546 hugeneg_aslong = long(hugeneg)
547 self.assertEqual(hugepos, hugepos_aslong, "long(sys.maxint) != sys.maxint")
548 self.assertEqual(hugeneg, hugeneg_aslong,
549 "long(-sys.maxint-1) != -sys.maxint-1")
550
551 # long -> int should not fail for hugepos_aslong or hugeneg_aslong
552 x = int(hugepos_aslong)
553 try:
554 self.assertEqual(x, hugepos,
555 "converting sys.maxint to long and back to int fails")
556 except OverflowError:
557 self.fail("int(long(sys.maxint)) overflowed!")
558 if not isinstance(x, int):
559 self.fail("int(long(sys.maxint)) should have returned int")
560 x = int(hugeneg_aslong)
561 try:
562 self.assertEqual(x, hugeneg,
563 "converting -sys.maxint-1 to long and back to int fails")
564 except OverflowError:
565 self.fail("int(long(-sys.maxint-1)) overflowed!")
566 if not isinstance(x, int):
567 self.fail("int(long(-sys.maxint-1)) should have returned int")
568 # but long -> int should overflow for hugepos+1 and hugeneg-1
569 x = hugepos_aslong + 1
570 try:
571 y = int(x)
572 except OverflowError:
573 self.fail("int(long(sys.maxint) + 1) mustn't overflow")
574 self.assertIsInstance(y, long,
575 "int(long(sys.maxint) + 1) should have returned long")
576
577 x = hugeneg_aslong - 1
578 try:
579 y = int(x)
580 except OverflowError:
581 self.fail("int(long(-sys.maxint-1) - 1) mustn't overflow")
582 self.assertIsInstance(y, long,
583 "int(long(-sys.maxint-1) - 1) should have returned long")
584
585 class long2(long):
586 pass
587 x = long2(1L<<100)
588 y = int(x)
589 self.assertTrue(type(y) is long,
590 "overflowing int conversion must return long not long subtype")
591
592 # long -> Py_ssize_t conversion
593 class X(object):
594 def __getslice__(self, i, j):
595 return i, j
596
597 with test_support.check_py3k_warnings():
598 self.assertEqual(X()[-5L:7L], (-5, 7))
599 # use the clamping effect to test the smallest and largest longs
600 # that fit a Py_ssize_t
601 slicemin, slicemax = X()[-2L**100:2L**100]
602 self.assertEqual(X()[slicemin:slicemax], (slicemin, slicemax))
603
604 def test_issue9869(self):
605 # Issue 9869: Interpreter crash when initializing an instance
606 # of a long subclass from an object whose __long__ method returns
607 # a plain int.
608 class BadLong(object):
609 def __long__(self):
610 return 1000000
611
612 class MyLong(long):
613 pass
614
615 x = MyLong(BadLong())
616 self.assertIsInstance(x, long)
617 self.assertEqual(x, 1000000)
618
619
620 # ----------------------------------- tests of auto int->long conversion
621
622 def test_auto_overflow(self):
623 special = [0, 1, 2, 3, sys.maxint-1, sys.maxint, sys.maxint+1]
624 sqrt = int(math.sqrt(sys.maxint))
625 special.extend([sqrt-1, sqrt, sqrt+1])
626 special.extend([-i for i in special])
627
628 def checkit(*args):
629 # Heavy use of nested scopes here!
630 self.assertEqual(got, expected,
631 Frm("for %r expected %r got %r", args, expected, got))
632
633 for x in special:
634 longx = long(x)
635
636 expected = -longx
637 got = -x
638 checkit('-', x)
639
640 for y in special:
641 longy = long(y)
642
643 expected = longx + longy
644 got = x + y
645 checkit(x, '+', y)
646
647 expected = longx - longy
648 got = x - y
649 checkit(x, '-', y)
650
651 expected = longx * longy
652 got = x * y
653 checkit(x, '*', y)
654
655 if y:
656 with test_support.check_py3k_warnings():
657 expected = longx / longy
658 got = x / y
659 checkit(x, '/', y)
660
661 expected = longx // longy
662 got = x // y
663 checkit(x, '//', y)
664
665 expected = divmod(longx, longy)
666 got = divmod(longx, longy)
667 checkit(x, 'divmod', y)
668
669 if abs(y) < 5 and not (x == 0 and y < 0):
670 expected = longx ** longy
671 got = x ** y
672 checkit(x, '**', y)
673
674 for z in special:
675 if z != 0 :
676 if y >= 0:
677 expected = pow(longx, longy, long(z))
678 got = pow(x, y, z)
679 checkit('pow', x, y, '%', z)
680 else:
681 self.assertRaises(TypeError, pow,longx, longy, long(z))
682
683 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
684 "test requires IEEE 754 doubles")
685 def test_float_conversion(self):
686 import sys
687 DBL_MAX = sys.float_info.max
688 DBL_MAX_EXP = sys.float_info.max_exp
689 DBL_MANT_DIG = sys.float_info.mant_dig
690
691 exact_values = [0L, 1L, 2L,
692 long(2**53-3),
693 long(2**53-2),
694 long(2**53-1),
695 long(2**53),
696 long(2**53+2),
697 long(2**54-4),
698 long(2**54-2),
699 long(2**54),
700 long(2**54+4)]
701 for x in exact_values:
702 self.assertEqual(long(float(x)), x)
703 self.assertEqual(long(float(-x)), -x)
704
705 # test round-half-even
706 for x, y in [(1, 0), (2, 2), (3, 4), (4, 4), (5, 4), (6, 6), (7, 8)]:
707 for p in xrange(15):
708 self.assertEqual(long(float(2L**p*(2**53+x))), 2L**p*(2**53+y))
709
710 for x, y in [(0, 0), (1, 0), (2, 0), (3, 4), (4, 4), (5, 4), (6, 8),
711 (7, 8), (8, 8), (9, 8), (10, 8), (11, 12), (12, 12),
712 (13, 12), (14, 16), (15, 16)]:
713 for p in xrange(15):
714 self.assertEqual(long(float(2L**p*(2**54+x))), 2L**p*(2**54+y))
715
716 # behaviour near extremes of floating-point range
717 long_dbl_max = long(DBL_MAX)
718 top_power = 2**DBL_MAX_EXP
719 halfway = (long_dbl_max + top_power)//2
720 self.assertEqual(float(long_dbl_max), DBL_MAX)
721 self.assertEqual(float(long_dbl_max+1), DBL_MAX)
722 self.assertEqual(float(halfway-1), DBL_MAX)
723 self.assertRaises(OverflowError, float, halfway)
724 self.assertEqual(float(1-halfway), -DBL_MAX)
725 self.assertRaises(OverflowError, float, -halfway)
726 self.assertRaises(OverflowError, float, top_power-1)
727 self.assertRaises(OverflowError, float, top_power)
728 self.assertRaises(OverflowError, float, top_power+1)
729 self.assertRaises(OverflowError, float, 2*top_power-1)
730 self.assertRaises(OverflowError, float, 2*top_power)
731 self.assertRaises(OverflowError, float, top_power*top_power)
732
733 for p in xrange(100):
734 x = long(2**p * (2**53 + 1) + 1)
735 y = long(2**p * (2**53+ 2))
736 self.assertEqual(long(float(x)), y)
737
738 x = long(2**p * (2**53 + 1))
739 y = long(2**p * 2**53)
740 self.assertEqual(long(float(x)), y)
741
742 def test_float_overflow(self):
743 for x in -2.0, -1.0, 0.0, 1.0, 2.0:
744 self.assertEqual(float(long(x)), x)
745
746 shuge = '12345' * 120
747 huge = 1L << 30000
748 mhuge = -huge
749 namespace = {'huge': huge, 'mhuge': mhuge, 'shuge': shuge, 'math': math}
750 for test in ["float(huge)", "float(mhuge)",
751 "complex(huge)", "complex(mhuge)",
752 "complex(huge, 1)", "complex(mhuge, 1)",
753 "complex(1, huge)", "complex(1, mhuge)",
754 "1. + huge", "huge + 1.", "1. + mhuge", "mhuge + 1.",
755 "1. - huge", "huge - 1.", "1. - mhuge", "mhuge - 1.",
756 "1. * huge", "huge * 1.", "1. * mhuge", "mhuge * 1.",
757 "1. // huge", "huge // 1.", "1. // mhuge", "mhuge // 1.",
758 "1. / huge", "huge / 1.", "1. / mhuge", "mhuge / 1.",
759 "1. ** huge", "huge ** 1.", "1. ** mhuge", "mhuge ** 1.",
760 "math.sin(huge)", "math.sin(mhuge)",
761 "math.sqrt(huge)", "math.sqrt(mhuge)", # should do better
762 "math.floor(huge)", "math.floor(mhuge)"]:
763
764 self.assertRaises(OverflowError, eval, test, namespace)
765
766 # XXX Perhaps float(shuge) can raise OverflowError on some box?
767 # The comparison should not.
768 self.assertNotEqual(float(shuge), int(shuge),
769 "float(shuge) should not equal int(shuge)")
770
771 def test_logs(self):
772 LOG10E = math.log10(math.e)
773
774 for exp in range(10) + [100, 1000, 10000]:
775 value = 10 ** exp
776 log10 = math.log10(value)
777 self.assertAlmostEqual(log10, exp)
778
779 # log10(value) == exp, so log(value) == log10(value)/log10(e) ==
780 # exp/LOG10E
781 expected = exp / LOG10E
782 log = math.log(value)
783 self.assertAlmostEqual(log, expected)
784
785 for bad in -(1L << 10000), -2L, 0L:
786 self.assertRaises(ValueError, math.log, bad)
787 self.assertRaises(ValueError, math.log10, bad)
788
789 def test_mixed_compares(self):
790 eq = self.assertEqual
791
792 # We're mostly concerned with that mixing floats and longs does the
793 # right stuff, even when longs are too large to fit in a float.
794 # The safest way to check the results is to use an entirely different
795 # method, which we do here via a skeletal rational class (which
796 # represents all Python ints, longs and floats exactly).
797 class Rat:
798 def __init__(self, value):
799 if isinstance(value, (int, long)):
800 self.n = value
801 self.d = 1
802 elif isinstance(value, float):
803 # Convert to exact rational equivalent.
804 f, e = math.frexp(abs(value))
805 assert f == 0 or 0.5 <= f < 1.0
806 # |value| = f * 2**e exactly
807
808 # Suck up CHUNK bits at a time; 28 is enough so that we suck
809 # up all bits in 2 iterations for all known binary double-
810 # precision formats, and small enough to fit in an int.
811 CHUNK = 28
812 top = 0
813 # invariant: |value| = (top + f) * 2**e exactly
814 while f:
815 f = math.ldexp(f, CHUNK)
816 digit = int(f)
817 assert digit >> CHUNK == 0
818 top = (top << CHUNK) | digit
819 f -= digit
820 assert 0.0 <= f < 1.0
821 e -= CHUNK
822
823 # Now |value| = top * 2**e exactly.
824 if e >= 0:
825 n = top << e
826 d = 1
827 else:
828 n = top
829 d = 1 << -e
830 if value < 0:
831 n = -n
832 self.n = n
833 self.d = d
834 assert float(n) / float(d) == value
835 else:
836 raise TypeError("can't deal with %r" % value)
837
838 def __cmp__(self, other):
839 if not isinstance(other, Rat):
840 other = Rat(other)
841 return cmp(self.n * other.d, self.d * other.n)
842
843 cases = [0, 0.001, 0.99, 1.0, 1.5, 1e20, 1e200]
844 # 2**48 is an important boundary in the internals. 2**53 is an
845 # important boundary for IEEE double precision.
846 for t in 2.0**48, 2.0**50, 2.0**53:
847 cases.extend([t - 1.0, t - 0.3, t, t + 0.3, t + 1.0,
848 long(t-1), long(t), long(t+1)])
849 cases.extend([0, 1, 2, sys.maxint, float(sys.maxint)])
850 # 1L<<20000 should exceed all double formats. long(1e200) is to
851 # check that we get equality with 1e200 above.
852 t = long(1e200)
853 cases.extend([0L, 1L, 2L, 1L << 20000, t-1, t, t+1])
854 cases.extend([-x for x in cases])
855 for x in cases:
856 Rx = Rat(x)
857 for y in cases:
858 Ry = Rat(y)
859 Rcmp = cmp(Rx, Ry)
860 xycmp = cmp(x, y)
861 eq(Rcmp, xycmp, Frm("%r %r %d %d", x, y, Rcmp, xycmp))
862 eq(x == y, Rcmp == 0, Frm("%r == %r %d", x, y, Rcmp))
863 eq(x != y, Rcmp != 0, Frm("%r != %r %d", x, y, Rcmp))
864 eq(x < y, Rcmp < 0, Frm("%r < %r %d", x, y, Rcmp))
865 eq(x <= y, Rcmp <= 0, Frm("%r <= %r %d", x, y, Rcmp))
866 eq(x > y, Rcmp > 0, Frm("%r > %r %d", x, y, Rcmp))
867 eq(x >= y, Rcmp >= 0, Frm("%r >= %r %d", x, y, Rcmp))
868
869 def test_nan_inf(self):
870 self.assertRaises(OverflowError, long, float('inf'))
871 self.assertRaises(OverflowError, long, float('-inf'))
872 self.assertRaises(ValueError, long, float('nan'))
873
874 def test_bit_length(self):
875 tiny = 1e-10
876 for x in xrange(-65000, 65000):
877 x = long(x)
878 k = x.bit_length()
879 # Check equivalence with Python version
880 self.assertEqual(k, len(bin(x).lstrip('-0b')))
881 # Behaviour as specified in the docs
882 if x != 0:
883 self.assertTrue(2**(k-1) <= abs(x) < 2**k)
884 else:
885 self.assertEqual(k, 0)
886 # Alternative definition: x.bit_length() == 1 + floor(log_2(x))
887 if x != 0:
888 # When x is an exact power of 2, numeric errors can
889 # cause floor(log(x)/log(2)) to be one too small; for
890 # small x this can be fixed by adding a small quantity
891 # to the quotient before taking the floor.
892 self.assertEqual(k, 1 + math.floor(
893 math.log(abs(x))/math.log(2) + tiny))
894
895 self.assertEqual((0L).bit_length(), 0)
896 self.assertEqual((1L).bit_length(), 1)
897 self.assertEqual((-1L).bit_length(), 1)
898 self.assertEqual((2L).bit_length(), 2)
899 self.assertEqual((-2L).bit_length(), 2)
900 for i in [2, 3, 15, 16, 17, 31, 32, 33, 63, 64, 234]:
901 a = 2L**i
902 self.assertEqual((a-1).bit_length(), i)
903 self.assertEqual((1-a).bit_length(), i)
904 self.assertEqual((a).bit_length(), i+1)
905 self.assertEqual((-a).bit_length(), i+1)
906 self.assertEqual((a+1).bit_length(), i+1)
907 self.assertEqual((-a-1).bit_length(), i+1)
908
909
910 def test_main():
911 test_support.run_unittest(LongTest)
912
913 if __name__ == "__main__":
914 test_main()
EFI Development Kit II mirror for PVE