1 import unittest
2 from test import support
3
4 import sys
5
6 import random
7 import math
8 import array
9
10 # SHIFT should match the value in longintrepr.h for best testing.
11 SHIFT = sys.int_info.bits_per_digit
12 BASE = 2 ** SHIFT
13 MASK = BASE - 1
14 KARATSUBA_CUTOFF = 70 # from longobject.c
15
16 # Max number of base BASE digits to use in test cases. Doubling
17 # this will more than double the runtime.
18 MAXDIGITS = 15
19
20 # build some special values
21 special = [0, 1, 2, BASE, BASE >> 1, 0x5555555555555555, 0xaaaaaaaaaaaaaaaa]
22 # some solid strings of one bits
23 p2 = 4 # 0 and 1 already added
24 for i in range(2*SHIFT):
25 special.append(p2 - 1)
26 p2 = p2 << 1
27 del p2
28 # add complements & negations
29 special += [~x for x in special] + [-x for x in special]
30
31 DBL_MAX = sys.float_info.max
32 DBL_MAX_EXP = sys.float_info.max_exp
33 DBL_MIN_EXP = sys.float_info.min_exp
34 DBL_MANT_DIG = sys.float_info.mant_dig
35 DBL_MIN_OVERFLOW = 2**DBL_MAX_EXP - 2**(DBL_MAX_EXP - DBL_MANT_DIG - 1)
36
37
38 # Pure Python version of correctly-rounded integer-to-float conversion.
39 def int_to_float(n):
40 """
41 Correctly-rounded integer-to-float conversion.
42
43 """
44 # Constants, depending only on the floating-point format in use.
45 # We use an extra 2 bits of precision for rounding purposes.
46 PRECISION = sys.float_info.mant_dig + 2
47 SHIFT_MAX = sys.float_info.max_exp - PRECISION
48 Q_MAX = 1 << PRECISION
49 ROUND_HALF_TO_EVEN_CORRECTION = [0, -1, -2, 1, 0, -1, 2, 1]
50
51 # Reduce to the case where n is positive.
52 if n == 0:
53 return 0.0
54 elif n < 0:
55 return -int_to_float(-n)
56
57 # Convert n to a 'floating-point' number q * 2**shift, where q is an
58 # integer with 'PRECISION' significant bits. When shifting n to create q,
59 # the least significant bit of q is treated as 'sticky'. That is, the
60 # least significant bit of q is set if either the corresponding bit of n
61 # was already set, or any one of the bits of n lost in the shift was set.
62 shift = n.bit_length() - PRECISION
63 q = n << -shift if shift < 0 else (n >> shift) | bool(n & ~(-1 << shift))
64
65 # Round half to even (actually rounds to the nearest multiple of 4,
66 # rounding ties to a multiple of 8).
67 q += ROUND_HALF_TO_EVEN_CORRECTION[q & 7]
68
69 # Detect overflow.
70 if shift + (q == Q_MAX) > SHIFT_MAX:
71 raise OverflowError("integer too large to convert to float")
72
73 # Checks: q is exactly representable, and q**2**shift doesn't overflow.
74 assert q % 4 == 0 and q // 4 <= 2**(sys.float_info.mant_dig)
75 assert q * 2**shift <= sys.float_info.max
76
77 # Some circularity here, since float(q) is doing an int-to-float
78 # conversion. But here q is of bounded size, and is exactly representable
79 # as a float. In a low-level C-like language, this operation would be a
80 # simple cast (e.g., from unsigned long long to double).
81 return math.ldexp(float(q), shift)
82
83
84 # pure Python version of correctly-rounded true division
85 def truediv(a, b):
86 """Correctly-rounded true division for integers."""
87 negative = a^b < 0
88 a, b = abs(a), abs(b)
89
90 # exceptions: division by zero, overflow
91 if not b:
92 raise ZeroDivisionError("division by zero")
93 if a >= DBL_MIN_OVERFLOW * b:
94 raise OverflowError("int/int too large to represent as a float")
95
96 # find integer d satisfying 2**(d - 1) <= a/b < 2**d
97 d = a.bit_length() - b.bit_length()
98 if d >= 0 and a >= 2**d * b or d < 0 and a * 2**-d >= b:
99 d += 1
100
101 # compute 2**-exp * a / b for suitable exp
102 exp = max(d, DBL_MIN_EXP) - DBL_MANT_DIG
103 a, b = a << max(-exp, 0), b << max(exp, 0)
104 q, r = divmod(a, b)
105
106 # round-half-to-even: fractional part is r/b, which is > 0.5 iff
107 # 2*r > b, and == 0.5 iff 2*r == b.
108 if 2*r > b or 2*r == b and q % 2 == 1:
109 q += 1
110
111 result = math.ldexp(q, exp)
112 return -result if negative else result
113
114
115 class ESC[4;38;5;81mLongTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
116
117 # Get quasi-random long consisting of ndigits digits (in base BASE).
118 # quasi == the most-significant digit will not be 0, and the number
119 # is constructed to contain long strings of 0 and 1 bits. These are
120 # more likely than random bits to provoke digit-boundary errors.
121 # The sign of the number is also random.
122
123 def getran(self, ndigits):
124 self.assertGreater(ndigits, 0)
125 nbits_hi = ndigits * SHIFT
126 nbits_lo = nbits_hi - SHIFT + 1
127 answer = 0
128 nbits = 0
129 r = int(random.random() * (SHIFT * 2)) | 1 # force 1 bits to start
130 while nbits < nbits_lo:
131 bits = (r >> 1) + 1
132 bits = min(bits, nbits_hi - nbits)
133 self.assertTrue(1 <= bits <= SHIFT)
134 nbits = nbits + bits
135 answer = answer << bits
136 if r & 1:
137 answer = answer | ((1 << bits) - 1)
138 r = int(random.random() * (SHIFT * 2))
139 self.assertTrue(nbits_lo <= nbits <= nbits_hi)
140 if random.random() < 0.5:
141 answer = -answer
142 return answer
143
144 # Get random long consisting of ndigits random digits (relative to base
145 # BASE). The sign bit is also random.
146
147 def getran2(ndigits):
148 answer = 0
149 for i in range(ndigits):
150 answer = (answer << SHIFT) | random.randint(0, MASK)
151 if random.random() < 0.5:
152 answer = -answer
153 return answer
154
155 def check_division(self, x, y):
156 eq = self.assertEqual
157 with self.subTest(x=x, y=y):
158 q, r = divmod(x, y)
159 q2, r2 = x//y, x%y
160 pab, pba = x*y, y*x
161 eq(pab, pba, "multiplication does not commute")
162 eq(q, q2, "divmod returns different quotient than /")
163 eq(r, r2, "divmod returns different mod than %")
164 eq(x, q*y + r, "x != q*y + r after divmod")
165 if y > 0:
166 self.assertTrue(0 <= r < y, "bad mod from divmod")
167 else:
168 self.assertTrue(y < r <= 0, "bad mod from divmod")
169
170 def test_division(self):
171 digits = list(range(1, MAXDIGITS+1)) + list(range(KARATSUBA_CUTOFF,
172 KARATSUBA_CUTOFF + 14))
173 digits.append(KARATSUBA_CUTOFF * 3)
174 for lenx in digits:
175 x = self.getran(lenx)
176 for leny in digits:
177 y = self.getran(leny) or 1
178 self.check_division(x, y)
179
180 # specific numbers chosen to exercise corner cases of the
181 # current long division implementation
182
183 # 30-bit cases involving a quotient digit estimate of BASE+1
184 self.check_division(1231948412290879395966702881,
185 1147341367131428698)
186 self.check_division(815427756481275430342312021515587883,
187 707270836069027745)
188 self.check_division(627976073697012820849443363563599041,
189 643588798496057020)
190 self.check_division(1115141373653752303710932756325578065,
191 1038556335171453937726882627)
192 # 30-bit cases that require the post-subtraction correction step
193 self.check_division(922498905405436751940989320930368494,
194 949985870686786135626943396)
195 self.check_division(768235853328091167204009652174031844,
196 1091555541180371554426545266)
197
198 # 15-bit cases involving a quotient digit estimate of BASE+1
199 self.check_division(20172188947443, 615611397)
200 self.check_division(1020908530270155025, 950795710)
201 self.check_division(128589565723112408, 736393718)
202 self.check_division(609919780285761575, 18613274546784)
203 # 15-bit cases that require the post-subtraction correction step
204 self.check_division(710031681576388032, 26769404391308)
205 self.check_division(1933622614268221, 30212853348836)
206
207
208
209 def test_karatsuba(self):
210 digits = list(range(1, 5)) + list(range(KARATSUBA_CUTOFF,
211 KARATSUBA_CUTOFF + 10))
212 digits.extend([KARATSUBA_CUTOFF * 10, KARATSUBA_CUTOFF * 100])
213
214 bits = [digit * SHIFT for digit in digits]
215
216 # Test products of long strings of 1 bits -- (2**x-1)*(2**y-1) ==
217 # 2**(x+y) - 2**x - 2**y + 1, so the proper result is easy to check.
218 for abits in bits:
219 a = (1 << abits) - 1
220 for bbits in bits:
221 if bbits < abits:
222 continue
223 with self.subTest(abits=abits, bbits=bbits):
224 b = (1 << bbits) - 1
225 x = a * b
226 y = ((1 << (abits + bbits)) -
227 (1 << abits) -
228 (1 << bbits) +
229 1)
230 self.assertEqual(x, y)
231
232 def check_bitop_identities_1(self, x):
233 eq = self.assertEqual
234 with self.subTest(x=x):
235 eq(x & 0, 0)
236 eq(x | 0, x)
237 eq(x ^ 0, x)
238 eq(x & -1, x)
239 eq(x | -1, -1)
240 eq(x ^ -1, ~x)
241 eq(x, ~~x)
242 eq(x & x, x)
243 eq(x | x, x)
244 eq(x ^ x, 0)
245 eq(x & ~x, 0)
246 eq(x | ~x, -1)
247 eq(x ^ ~x, -1)
248 eq(-x, 1 + ~x)
249 eq(-x, ~(x-1))
250 for n in range(2*SHIFT):
251 p2 = 2 ** n
252 with self.subTest(x=x, n=n, p2=p2):
253 eq(x << n >> n, x)
254 eq(x // p2, x >> n)
255 eq(x * p2, x << n)
256 eq(x & -p2, x >> n << n)
257 eq(x & -p2, x & ~(p2 - 1))
258
259 def check_bitop_identities_2(self, x, y):
260 eq = self.assertEqual
261 with self.subTest(x=x, y=y):
262 eq(x & y, y & x)
263 eq(x | y, y | x)
264 eq(x ^ y, y ^ x)
265 eq(x ^ y ^ x, y)
266 eq(x & y, ~(~x | ~y))
267 eq(x | y, ~(~x & ~y))
268 eq(x ^ y, (x | y) & ~(x & y))
269 eq(x ^ y, (x & ~y) | (~x & y))
270 eq(x ^ y, (x | y) & (~x | ~y))
271
272 def check_bitop_identities_3(self, x, y, z):
273 eq = self.assertEqual
274 with self.subTest(x=x, y=y, z=z):
275 eq((x & y) & z, x & (y & z))
276 eq((x | y) | z, x | (y | z))
277 eq((x ^ y) ^ z, x ^ (y ^ z))
278 eq(x & (y | z), (x & y) | (x & z))
279 eq(x | (y & z), (x | y) & (x | z))
280
281 def test_bitop_identities(self):
282 for x in special:
283 self.check_bitop_identities_1(x)
284 digits = range(1, MAXDIGITS+1)
285 for lenx in digits:
286 x = self.getran(lenx)
287 self.check_bitop_identities_1(x)
288 for leny in digits:
289 y = self.getran(leny)
290 self.check_bitop_identities_2(x, y)
291 self.check_bitop_identities_3(x, y, self.getran((lenx + leny)//2))
292
293 def slow_format(self, x, base):
294 digits = []
295 sign = 0
296 if x < 0:
297 sign, x = 1, -x
298 while x:
299 x, r = divmod(x, base)
300 digits.append(int(r))
301 digits.reverse()
302 digits = digits or [0]
303 return '-'[:sign] + \
304 {2: '0b', 8: '0o', 10: '', 16: '0x'}[base] + \
305 "".join("0123456789abcdef"[i] for i in digits)
306
307 def check_format_1(self, x):
308 for base, mapper in (2, bin), (8, oct), (10, str), (10, repr), (16, hex):
309 got = mapper(x)
310 with self.subTest(x=x, mapper=mapper.__name__):
311 expected = self.slow_format(x, base)
312 self.assertEqual(got, expected)
313 with self.subTest(got=got):
314 self.assertEqual(int(got, 0), x)
315
316 def test_format(self):
317 for x in special:
318 self.check_format_1(x)
319 for i in range(10):
320 for lenx in range(1, MAXDIGITS+1):
321 x = self.getran(lenx)
322 self.check_format_1(x)
323
324 def test_long(self):
325 # Check conversions from string
326 LL = [
327 ('1' + '0'*20, 10**20),
328 ('1' + '0'*100, 10**100)
329 ]
330 for s, v in LL:
331 for sign in "", "+", "-":
332 for prefix in "", " ", "\t", " \t\t ":
333 ss = prefix + sign + s
334 vv = v
335 if sign == "-" and v is not ValueError:
336 vv = -v
337 try:
338 self.assertEqual(int(ss), vv)
339 except ValueError:
340 pass
341
342 # trailing L should no longer be accepted...
343 self.assertRaises(ValueError, int, '123L')
344 self.assertRaises(ValueError, int, '123l')
345 self.assertRaises(ValueError, int, '0L')
346 self.assertRaises(ValueError, int, '-37L')
347 self.assertRaises(ValueError, int, '0x32L', 16)
348 self.assertRaises(ValueError, int, '1L', 21)
349 # ... but it's just a normal digit if base >= 22
350 self.assertEqual(int('1L', 22), 43)
351
352 # tests with base 0
353 self.assertEqual(int('000', 0), 0)
354 self.assertEqual(int('0o123', 0), 83)
355 self.assertEqual(int('0x123', 0), 291)
356 self.assertEqual(int('0b100', 0), 4)
357 self.assertEqual(int(' 0O123 ', 0), 83)
358 self.assertEqual(int(' 0X123 ', 0), 291)
359 self.assertEqual(int(' 0B100 ', 0), 4)
360 self.assertEqual(int('0', 0), 0)
361 self.assertEqual(int('+0', 0), 0)
362 self.assertEqual(int('-0', 0), 0)
363 self.assertEqual(int('00', 0), 0)
364 self.assertRaises(ValueError, int, '08', 0)
365 self.assertRaises(ValueError, int, '-012395', 0)
366
367 # invalid bases
368 invalid_bases = [-909,
369 2**31-1, 2**31, -2**31, -2**31-1,
370 2**63-1, 2**63, -2**63, -2**63-1,
371 2**100, -2**100,
372 ]
373 for base in invalid_bases:
374 self.assertRaises(ValueError, int, '42', base)
375
376 # Invalid unicode string
377 # See bpo-34087
378 self.assertRaises(ValueError, int, '\u3053\u3093\u306b\u3061\u306f')
379
380
381 def test_conversion(self):
382
383 class ESC[4;38;5;81mJustLong:
384 # test that __long__ no longer used in 3.x
385 def __long__(self):
386 return 42
387 self.assertRaises(TypeError, int, JustLong())
388
389 class ESC[4;38;5;81mLongTrunc:
390 # __long__ should be ignored in 3.x
391 def __long__(self):
392 return 42
393 def __trunc__(self):
394 return 1729
395 with self.assertWarns(DeprecationWarning):
396 self.assertEqual(int(LongTrunc()), 1729)
397
398 def check_float_conversion(self, n):
399 # Check that int -> float conversion behaviour matches
400 # that of the pure Python version above.
401 try:
402 actual = float(n)
403 except OverflowError:
404 actual = 'overflow'
405
406 try:
407 expected = int_to_float(n)
408 except OverflowError:
409 expected = 'overflow'
410
411 msg = ("Error in conversion of integer {} to float. "
412 "Got {}, expected {}.".format(n, actual, expected))
413 self.assertEqual(actual, expected, msg)
414
415 @support.requires_IEEE_754
416 def test_float_conversion(self):
417
418 exact_values = [0, 1, 2,
419 2**53-3,
420 2**53-2,
421 2**53-1,
422 2**53,
423 2**53+2,
424 2**54-4,
425 2**54-2,
426 2**54,
427 2**54+4]
428 for x in exact_values:
429 self.assertEqual(float(x), x)
430 self.assertEqual(float(-x), -x)
431
432 # test round-half-even
433 for x, y in [(1, 0), (2, 2), (3, 4), (4, 4), (5, 4), (6, 6), (7, 8)]:
434 for p in range(15):
435 self.assertEqual(int(float(2**p*(2**53+x))), 2**p*(2**53+y))
436
437 for x, y in [(0, 0), (1, 0), (2, 0), (3, 4), (4, 4), (5, 4), (6, 8),
438 (7, 8), (8, 8), (9, 8), (10, 8), (11, 12), (12, 12),
439 (13, 12), (14, 16), (15, 16)]:
440 for p in range(15):
441 self.assertEqual(int(float(2**p*(2**54+x))), 2**p*(2**54+y))
442
443 # behaviour near extremes of floating-point range
444 int_dbl_max = int(DBL_MAX)
445 top_power = 2**DBL_MAX_EXP
446 halfway = (int_dbl_max + top_power)//2
447 self.assertEqual(float(int_dbl_max), DBL_MAX)
448 self.assertEqual(float(int_dbl_max+1), DBL_MAX)
449 self.assertEqual(float(halfway-1), DBL_MAX)
450 self.assertRaises(OverflowError, float, halfway)
451 self.assertEqual(float(1-halfway), -DBL_MAX)
452 self.assertRaises(OverflowError, float, -halfway)
453 self.assertRaises(OverflowError, float, top_power-1)
454 self.assertRaises(OverflowError, float, top_power)
455 self.assertRaises(OverflowError, float, top_power+1)
456 self.assertRaises(OverflowError, float, 2*top_power-1)
457 self.assertRaises(OverflowError, float, 2*top_power)
458 self.assertRaises(OverflowError, float, top_power*top_power)
459
460 for p in range(100):
461 x = 2**p * (2**53 + 1) + 1
462 y = 2**p * (2**53 + 2)
463 self.assertEqual(int(float(x)), y)
464
465 x = 2**p * (2**53 + 1)
466 y = 2**p * 2**53
467 self.assertEqual(int(float(x)), y)
468
469 # Compare builtin float conversion with pure Python int_to_float
470 # function above.
471 test_values = [
472 int_dbl_max-1, int_dbl_max, int_dbl_max+1,
473 halfway-1, halfway, halfway + 1,
474 top_power-1, top_power, top_power+1,
475 2*top_power-1, 2*top_power, top_power*top_power,
476 ]
477 test_values.extend(exact_values)
478 for p in range(-4, 8):
479 for x in range(-128, 128):
480 test_values.append(2**(p+53) + x)
481 for value in test_values:
482 self.check_float_conversion(value)
483 self.check_float_conversion(-value)
484
485 def test_float_overflow(self):
486 for x in -2.0, -1.0, 0.0, 1.0, 2.0:
487 self.assertEqual(float(int(x)), x)
488
489 shuge = '12345' * 120
490 huge = 1 << 30000
491 mhuge = -huge
492 namespace = {'huge': huge, 'mhuge': mhuge, 'shuge': shuge, 'math': math}
493 for test in ["float(huge)", "float(mhuge)",
494 "complex(huge)", "complex(mhuge)",
495 "complex(huge, 1)", "complex(mhuge, 1)",
496 "complex(1, huge)", "complex(1, mhuge)",
497 "1. + huge", "huge + 1.", "1. + mhuge", "mhuge + 1.",
498 "1. - huge", "huge - 1.", "1. - mhuge", "mhuge - 1.",
499 "1. * huge", "huge * 1.", "1. * mhuge", "mhuge * 1.",
500 "1. // huge", "huge // 1.", "1. // mhuge", "mhuge // 1.",
501 "1. / huge", "huge / 1.", "1. / mhuge", "mhuge / 1.",
502 "1. ** huge", "huge ** 1.", "1. ** mhuge", "mhuge ** 1.",
503 "math.sin(huge)", "math.sin(mhuge)",
504 "math.sqrt(huge)", "math.sqrt(mhuge)", # should do better
505 # math.floor() of an int returns an int now
506 ##"math.floor(huge)", "math.floor(mhuge)",
507 ]:
508
509 self.assertRaises(OverflowError, eval, test, namespace)
510
511 # XXX Perhaps float(shuge) can raise OverflowError on some box?
512 # The comparison should not.
513 self.assertNotEqual(float(shuge), int(shuge),
514 "float(shuge) should not equal int(shuge)")
515
516 def test_logs(self):
517 LOG10E = math.log10(math.e)
518
519 for exp in list(range(10)) + [100, 1000, 10000]:
520 value = 10 ** exp
521 log10 = math.log10(value)
522 self.assertAlmostEqual(log10, exp)
523
524 # log10(value) == exp, so log(value) == log10(value)/log10(e) ==
525 # exp/LOG10E
526 expected = exp / LOG10E
527 log = math.log(value)
528 self.assertAlmostEqual(log, expected)
529
530 for bad in -(1 << 10000), -2, 0:
531 self.assertRaises(ValueError, math.log, bad)
532 self.assertRaises(ValueError, math.log10, bad)
533
534 def test_mixed_compares(self):
535 eq = self.assertEqual
536
537 # We're mostly concerned with that mixing floats and ints does the
538 # right stuff, even when ints are too large to fit in a float.
539 # The safest way to check the results is to use an entirely different
540 # method, which we do here via a skeletal rational class (which
541 # represents all Python ints and floats exactly).
542 class ESC[4;38;5;81mRat:
543 def __init__(self, value):
544 if isinstance(value, int):
545 self.n = value
546 self.d = 1
547 elif isinstance(value, float):
548 # Convert to exact rational equivalent.
549 f, e = math.frexp(abs(value))
550 assert f == 0 or 0.5 <= f < 1.0
551 # |value| = f * 2**e exactly
552
553 # Suck up CHUNK bits at a time; 28 is enough so that we suck
554 # up all bits in 2 iterations for all known binary double-
555 # precision formats, and small enough to fit in an int.
556 CHUNK = 28
557 top = 0
558 # invariant: |value| = (top + f) * 2**e exactly
559 while f:
560 f = math.ldexp(f, CHUNK)
561 digit = int(f)
562 assert digit >> CHUNK == 0
563 top = (top << CHUNK) | digit
564 f -= digit
565 assert 0.0 <= f < 1.0
566 e -= CHUNK
567
568 # Now |value| = top * 2**e exactly.
569 if e >= 0:
570 n = top << e
571 d = 1
572 else:
573 n = top
574 d = 1 << -e
575 if value < 0:
576 n = -n
577 self.n = n
578 self.d = d
579 assert float(n) / float(d) == value
580 else:
581 raise TypeError("can't deal with %r" % value)
582
583 def _cmp__(self, other):
584 if not isinstance(other, Rat):
585 other = Rat(other)
586 x, y = self.n * other.d, self.d * other.n
587 return (x > y) - (x < y)
588 def __eq__(self, other):
589 return self._cmp__(other) == 0
590 def __ge__(self, other):
591 return self._cmp__(other) >= 0
592 def __gt__(self, other):
593 return self._cmp__(other) > 0
594 def __le__(self, other):
595 return self._cmp__(other) <= 0
596 def __lt__(self, other):
597 return self._cmp__(other) < 0
598
599 cases = [0, 0.001, 0.99, 1.0, 1.5, 1e20, 1e200]
600 # 2**48 is an important boundary in the internals. 2**53 is an
601 # important boundary for IEEE double precision.
602 for t in 2.0**48, 2.0**50, 2.0**53:
603 cases.extend([t - 1.0, t - 0.3, t, t + 0.3, t + 1.0,
604 int(t-1), int(t), int(t+1)])
605 cases.extend([0, 1, 2, sys.maxsize, float(sys.maxsize)])
606 # 1 << 20000 should exceed all double formats. int(1e200) is to
607 # check that we get equality with 1e200 above.
608 t = int(1e200)
609 cases.extend([0, 1, 2, 1 << 20000, t-1, t, t+1])
610 cases.extend([-x for x in cases])
611 for x in cases:
612 Rx = Rat(x)
613 for y in cases:
614 Ry = Rat(y)
615 Rcmp = (Rx > Ry) - (Rx < Ry)
616 with self.subTest(x=x, y=y, Rcmp=Rcmp):
617 xycmp = (x > y) - (x < y)
618 eq(Rcmp, xycmp)
619 eq(x == y, Rcmp == 0)
620 eq(x != y, Rcmp != 0)
621 eq(x < y, Rcmp < 0)
622 eq(x <= y, Rcmp <= 0)
623 eq(x > y, Rcmp > 0)
624 eq(x >= y, Rcmp >= 0)
625
626 def test__format__(self):
627 self.assertEqual(format(123456789, 'd'), '123456789')
628 self.assertEqual(format(123456789, 'd'), '123456789')
629 self.assertEqual(format(123456789, ','), '123,456,789')
630 self.assertEqual(format(123456789, '_'), '123_456_789')
631
632 # sign and aligning are interdependent
633 self.assertEqual(format(1, "-"), '1')
634 self.assertEqual(format(-1, "-"), '-1')
635 self.assertEqual(format(1, "-3"), ' 1')
636 self.assertEqual(format(-1, "-3"), ' -1')
637 self.assertEqual(format(1, "+3"), ' +1')
638 self.assertEqual(format(-1, "+3"), ' -1')
639 self.assertEqual(format(1, " 3"), ' 1')
640 self.assertEqual(format(-1, " 3"), ' -1')
641 self.assertEqual(format(1, " "), ' 1')
642 self.assertEqual(format(-1, " "), '-1')
643
644 # hex
645 self.assertEqual(format(3, "x"), "3")
646 self.assertEqual(format(3, "X"), "3")
647 self.assertEqual(format(1234, "x"), "4d2")
648 self.assertEqual(format(-1234, "x"), "-4d2")
649 self.assertEqual(format(1234, "8x"), " 4d2")
650 self.assertEqual(format(-1234, "8x"), " -4d2")
651 self.assertEqual(format(1234, "x"), "4d2")
652 self.assertEqual(format(-1234, "x"), "-4d2")
653 self.assertEqual(format(-3, "x"), "-3")
654 self.assertEqual(format(-3, "X"), "-3")
655 self.assertEqual(format(int('be', 16), "x"), "be")
656 self.assertEqual(format(int('be', 16), "X"), "BE")
657 self.assertEqual(format(-int('be', 16), "x"), "-be")
658 self.assertEqual(format(-int('be', 16), "X"), "-BE")
659 self.assertRaises(ValueError, format, 1234567890, ',x')
660 self.assertEqual(format(1234567890, '_x'), '4996_02d2')
661 self.assertEqual(format(1234567890, '_X'), '4996_02D2')
662
663 # octal
664 self.assertEqual(format(3, "o"), "3")
665 self.assertEqual(format(-3, "o"), "-3")
666 self.assertEqual(format(1234, "o"), "2322")
667 self.assertEqual(format(-1234, "o"), "-2322")
668 self.assertEqual(format(1234, "-o"), "2322")
669 self.assertEqual(format(-1234, "-o"), "-2322")
670 self.assertEqual(format(1234, " o"), " 2322")
671 self.assertEqual(format(-1234, " o"), "-2322")
672 self.assertEqual(format(1234, "+o"), "+2322")
673 self.assertEqual(format(-1234, "+o"), "-2322")
674 self.assertRaises(ValueError, format, 1234567890, ',o')
675 self.assertEqual(format(1234567890, '_o'), '111_4540_1322')
676
677 # binary
678 self.assertEqual(format(3, "b"), "11")
679 self.assertEqual(format(-3, "b"), "-11")
680 self.assertEqual(format(1234, "b"), "10011010010")
681 self.assertEqual(format(-1234, "b"), "-10011010010")
682 self.assertEqual(format(1234, "-b"), "10011010010")
683 self.assertEqual(format(-1234, "-b"), "-10011010010")
684 self.assertEqual(format(1234, " b"), " 10011010010")
685 self.assertEqual(format(-1234, " b"), "-10011010010")
686 self.assertEqual(format(1234, "+b"), "+10011010010")
687 self.assertEqual(format(-1234, "+b"), "-10011010010")
688 self.assertRaises(ValueError, format, 1234567890, ',b')
689 self.assertEqual(format(12345, '_b'), '11_0000_0011_1001')
690
691 # make sure these are errors
692 self.assertRaises(ValueError, format, 3, "1.3") # precision disallowed
693 self.assertRaises(ValueError, format, 3, "_c") # underscore,
694 self.assertRaises(ValueError, format, 3, ",c") # comma, and
695 self.assertRaises(ValueError, format, 3, "+c") # sign not allowed
696 # with 'c'
697
698 self.assertRaisesRegex(ValueError, 'Cannot specify both', format, 3, '_,')
699 self.assertRaisesRegex(ValueError, 'Cannot specify both', format, 3, ',_')
700 self.assertRaisesRegex(ValueError, 'Cannot specify both', format, 3, '_,d')
701 self.assertRaisesRegex(ValueError, 'Cannot specify both', format, 3, ',_d')
702
703 self.assertRaisesRegex(ValueError, "Cannot specify ',' with 's'", format, 3, ',s')
704 self.assertRaisesRegex(ValueError, "Cannot specify '_' with 's'", format, 3, '_s')
705
706 # ensure that only int and float type specifiers work
707 for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
708 [chr(x) for x in range(ord('A'), ord('Z')+1)]):
709 if not format_spec in 'bcdoxXeEfFgGn%':
710 self.assertRaises(ValueError, format, 0, format_spec)
711 self.assertRaises(ValueError, format, 1, format_spec)
712 self.assertRaises(ValueError, format, -1, format_spec)
713 self.assertRaises(ValueError, format, 2**100, format_spec)
714 self.assertRaises(ValueError, format, -(2**100), format_spec)
715
716 # ensure that float type specifiers work; format converts
717 # the int to a float
718 for format_spec in 'eEfFgG%':
719 for value in [0, 1, -1, 100, -100, 1234567890, -1234567890]:
720 self.assertEqual(format(value, format_spec),
721 format(float(value), format_spec))
722
723 def test_nan_inf(self):
724 self.assertRaises(OverflowError, int, float('inf'))
725 self.assertRaises(OverflowError, int, float('-inf'))
726 self.assertRaises(ValueError, int, float('nan'))
727
728 def test_mod_division(self):
729 with self.assertRaises(ZeroDivisionError):
730 _ = 1 % 0
731
732 self.assertEqual(13 % 10, 3)
733 self.assertEqual(-13 % 10, 7)
734 self.assertEqual(13 % -10, -7)
735 self.assertEqual(-13 % -10, -3)
736
737 self.assertEqual(12 % 4, 0)
738 self.assertEqual(-12 % 4, 0)
739 self.assertEqual(12 % -4, 0)
740 self.assertEqual(-12 % -4, 0)
741
742 def test_true_division(self):
743 huge = 1 << 40000
744 mhuge = -huge
745 self.assertEqual(huge / huge, 1.0)
746 self.assertEqual(mhuge / mhuge, 1.0)
747 self.assertEqual(huge / mhuge, -1.0)
748 self.assertEqual(mhuge / huge, -1.0)
749 self.assertEqual(1 / huge, 0.0)
750 self.assertEqual(1 / huge, 0.0)
751 self.assertEqual(1 / mhuge, 0.0)
752 self.assertEqual(1 / mhuge, 0.0)
753 self.assertEqual((666 * huge + (huge >> 1)) / huge, 666.5)
754 self.assertEqual((666 * mhuge + (mhuge >> 1)) / mhuge, 666.5)
755 self.assertEqual((666 * huge + (huge >> 1)) / mhuge, -666.5)
756 self.assertEqual((666 * mhuge + (mhuge >> 1)) / huge, -666.5)
757 self.assertEqual(huge / (huge << 1), 0.5)
758 self.assertEqual((1000000 * huge) / huge, 1000000)
759
760 namespace = {'huge': huge, 'mhuge': mhuge}
761
762 for overflow in ["float(huge)", "float(mhuge)",
763 "huge / 1", "huge / 2", "huge / -1", "huge / -2",
764 "mhuge / 100", "mhuge / 200"]:
765 self.assertRaises(OverflowError, eval, overflow, namespace)
766
767 for underflow in ["1 / huge", "2 / huge", "-1 / huge", "-2 / huge",
768 "100 / mhuge", "200 / mhuge"]:
769 result = eval(underflow, namespace)
770 self.assertEqual(result, 0.0,
771 "expected underflow to 0 from %r" % underflow)
772
773 for zero in ["huge / 0", "mhuge / 0"]:
774 self.assertRaises(ZeroDivisionError, eval, zero, namespace)
775
776 def test_floordiv(self):
777 with self.assertRaises(ZeroDivisionError):
778 _ = 1 // 0
779
780 self.assertEqual(2 // 3, 0)
781 self.assertEqual(2 // -3, -1)
782 self.assertEqual(-2 // 3, -1)
783 self.assertEqual(-2 // -3, 0)
784
785 self.assertEqual(-11 // -3, 3)
786 self.assertEqual(-11 // 3, -4)
787 self.assertEqual(11 // -3, -4)
788 self.assertEqual(11 // 3, 3)
789
790 self.assertEqual(-12 // -3, 4)
791 self.assertEqual(-12 // 3, -4)
792 self.assertEqual(12 // -3, -4)
793 self.assertEqual(12 // 3, 4)
794
795 def check_truediv(self, a, b, skip_small=True):
796 """Verify that the result of a/b is correctly rounded, by
797 comparing it with a pure Python implementation of correctly
798 rounded division. b should be nonzero."""
799
800 # skip check for small a and b: in this case, the current
801 # implementation converts the arguments to float directly and
802 # then applies a float division. This can give doubly-rounded
803 # results on x87-using machines (particularly 32-bit Linux).
804 if skip_small and max(abs(a), abs(b)) < 2**DBL_MANT_DIG:
805 return
806
807 try:
808 # use repr so that we can distinguish between -0.0 and 0.0
809 expected = repr(truediv(a, b))
810 except OverflowError:
811 expected = 'overflow'
812 except ZeroDivisionError:
813 expected = 'zerodivision'
814
815 try:
816 got = repr(a / b)
817 except OverflowError:
818 got = 'overflow'
819 except ZeroDivisionError:
820 got = 'zerodivision'
821
822 self.assertEqual(expected, got, "Incorrectly rounded division {}/{}: "
823 "expected {}, got {}".format(a, b, expected, got))
824
825 @support.requires_IEEE_754
826 def test_correctly_rounded_true_division(self):
827 # more stringent tests than those above, checking that the
828 # result of true division of ints is always correctly rounded.
829 # This test should probably be considered CPython-specific.
830
831 # Exercise all the code paths not involving Gb-sized ints.
832 # ... divisions involving zero
833 self.check_truediv(123, 0)
834 self.check_truediv(-456, 0)
835 self.check_truediv(0, 3)
836 self.check_truediv(0, -3)
837 self.check_truediv(0, 0)
838 # ... overflow or underflow by large margin
839 self.check_truediv(671 * 12345 * 2**DBL_MAX_EXP, 12345)
840 self.check_truediv(12345, 345678 * 2**(DBL_MANT_DIG - DBL_MIN_EXP))
841 # ... a much larger or smaller than b
842 self.check_truediv(12345*2**100, 98765)
843 self.check_truediv(12345*2**30, 98765*7**81)
844 # ... a / b near a boundary: one of 1, 2**DBL_MANT_DIG, 2**DBL_MIN_EXP,
845 # 2**DBL_MAX_EXP, 2**(DBL_MIN_EXP-DBL_MANT_DIG)
846 bases = (0, DBL_MANT_DIG, DBL_MIN_EXP,
847 DBL_MAX_EXP, DBL_MIN_EXP - DBL_MANT_DIG)
848 for base in bases:
849 for exp in range(base - 15, base + 15):
850 self.check_truediv(75312*2**max(exp, 0), 69187*2**max(-exp, 0))
851 self.check_truediv(69187*2**max(exp, 0), 75312*2**max(-exp, 0))
852
853 # overflow corner case
854 for m in [1, 2, 7, 17, 12345, 7**100,
855 -1, -2, -5, -23, -67891, -41**50]:
856 for n in range(-10, 10):
857 self.check_truediv(m*DBL_MIN_OVERFLOW + n, m)
858 self.check_truediv(m*DBL_MIN_OVERFLOW + n, -m)
859
860 # check detection of inexactness in shifting stage
861 for n in range(250):
862 # (2**DBL_MANT_DIG+1)/(2**DBL_MANT_DIG) lies halfway
863 # between two representable floats, and would usually be
864 # rounded down under round-half-to-even. The tiniest of
865 # additions to the numerator should cause it to be rounded
866 # up instead.
867 self.check_truediv((2**DBL_MANT_DIG + 1)*12345*2**200 + 2**n,
868 2**DBL_MANT_DIG*12345)
869
870 # 1/2731 is one of the smallest division cases that's subject
871 # to double rounding on IEEE 754 machines working internally with
872 # 64-bit precision. On such machines, the next check would fail,
873 # were it not explicitly skipped in check_truediv.
874 self.check_truediv(1, 2731)
875
876 # a particularly bad case for the old algorithm: gives an
877 # error of close to 3.5 ulps.
878 self.check_truediv(295147931372582273023, 295147932265116303360)
879 for i in range(1000):
880 self.check_truediv(10**(i+1), 10**i)
881 self.check_truediv(10**i, 10**(i+1))
882
883 # test round-half-to-even behaviour, normal result
884 for m in [1, 2, 4, 7, 8, 16, 17, 32, 12345, 7**100,
885 -1, -2, -5, -23, -67891, -41**50]:
886 for n in range(-10, 10):
887 self.check_truediv(2**DBL_MANT_DIG*m + n, m)
888
889 # test round-half-to-even, subnormal result
890 for n in range(-20, 20):
891 self.check_truediv(n, 2**1076)
892
893 # largeish random divisions: a/b where |a| <= |b| <=
894 # 2*|a|; |ans| is between 0.5 and 1.0, so error should
895 # always be bounded by 2**-54 with equality possible only
896 # if the least significant bit of q=ans*2**53 is zero.
897 for M in [10**10, 10**100, 10**1000]:
898 for i in range(1000):
899 a = random.randrange(1, M)
900 b = random.randrange(a, 2*a+1)
901 self.check_truediv(a, b)
902 self.check_truediv(-a, b)
903 self.check_truediv(a, -b)
904 self.check_truediv(-a, -b)
905
906 # and some (genuinely) random tests
907 for _ in range(10000):
908 a_bits = random.randrange(1000)
909 b_bits = random.randrange(1, 1000)
910 x = random.randrange(2**a_bits)
911 y = random.randrange(1, 2**b_bits)
912 self.check_truediv(x, y)
913 self.check_truediv(x, -y)
914 self.check_truediv(-x, y)
915 self.check_truediv(-x, -y)
916
917 def test_negative_shift_count(self):
918 with self.assertRaises(ValueError):
919 42 << -3
920 with self.assertRaises(ValueError):
921 42 << -(1 << 1000)
922 with self.assertRaises(ValueError):
923 42 >> -3
924 with self.assertRaises(ValueError):
925 42 >> -(1 << 1000)
926
927 def test_lshift_of_zero(self):
928 self.assertEqual(0 << 0, 0)
929 self.assertEqual(0 << 10, 0)
930 with self.assertRaises(ValueError):
931 0 << -1
932 self.assertEqual(0 << (1 << 1000), 0)
933 with self.assertRaises(ValueError):
934 0 << -(1 << 1000)
935
936 @support.cpython_only
937 def test_huge_lshift_of_zero(self):
938 # Shouldn't try to allocate memory for a huge shift. See issue #27870.
939 # Other implementations may have a different boundary for overflow,
940 # or not raise at all.
941 self.assertEqual(0 << sys.maxsize, 0)
942 self.assertEqual(0 << (sys.maxsize + 1), 0)
943
944 @support.cpython_only
945 @support.bigmemtest(sys.maxsize + 1000, memuse=2/15 * 2, dry_run=False)
946 def test_huge_lshift(self, size):
947 self.assertEqual(1 << (sys.maxsize + 1000), 1 << 1000 << sys.maxsize)
948
949 def test_huge_rshift(self):
950 huge_shift = 1 << 1000
951 self.assertEqual(42 >> huge_shift, 0)
952 self.assertEqual((-42) >> huge_shift, -1)
953 self.assertEqual(1123 >> huge_shift, 0)
954 self.assertEqual((-1123) >> huge_shift, -1)
955 self.assertEqual(2**128 >> huge_shift, 0)
956 self.assertEqual(-2**128 >> huge_shift, -1)
957
958 @support.cpython_only
959 @support.bigmemtest(sys.maxsize + 500, memuse=2/15, dry_run=False)
960 def test_huge_rshift_of_huge(self, size):
961 huge = ((1 << 500) + 11) << sys.maxsize
962 self.assertEqual(huge >> (sys.maxsize + 1), (1 << 499) + 5)
963 self.assertEqual(huge >> (sys.maxsize + 1000), 0)
964
965 def test_small_rshift(self):
966 self.assertEqual(42 >> 1, 21)
967 self.assertEqual((-42) >> 1, -21)
968 self.assertEqual(43 >> 1, 21)
969 self.assertEqual((-43) >> 1, -22)
970
971 self.assertEqual(1122 >> 1, 561)
972 self.assertEqual((-1122) >> 1, -561)
973 self.assertEqual(1123 >> 1, 561)
974 self.assertEqual((-1123) >> 1, -562)
975
976 self.assertEqual(2**128 >> 1, 2**127)
977 self.assertEqual(-2**128 >> 1, -2**127)
978 self.assertEqual((2**128 + 1) >> 1, 2**127)
979 self.assertEqual(-(2**128 + 1) >> 1, -2**127 - 1)
980
981 def test_medium_rshift(self):
982 self.assertEqual(42 >> 9, 0)
983 self.assertEqual((-42) >> 9, -1)
984 self.assertEqual(1122 >> 9, 2)
985 self.assertEqual((-1122) >> 9, -3)
986 self.assertEqual(2**128 >> 9, 2**119)
987 self.assertEqual(-2**128 >> 9, -2**119)
988 # Exercise corner case of the current algorithm, where the result of
989 # shifting a two-limb int by the limb size still has two limbs.
990 self.assertEqual((1 - BASE*BASE) >> SHIFT, -BASE)
991 self.assertEqual((BASE - 1 - BASE*BASE) >> SHIFT, -BASE)
992
993 def test_big_rshift(self):
994 self.assertEqual(42 >> 32, 0)
995 self.assertEqual((-42) >> 32, -1)
996 self.assertEqual(1122 >> 32, 0)
997 self.assertEqual((-1122) >> 32, -1)
998 self.assertEqual(2**128 >> 32, 2**96)
999 self.assertEqual(-2**128 >> 32, -2**96)
1000
1001 def test_small_lshift(self):
1002 self.assertEqual(42 << 1, 84)
1003 self.assertEqual((-42) << 1, -84)
1004 self.assertEqual(561 << 1, 1122)
1005 self.assertEqual((-561) << 1, -1122)
1006 self.assertEqual(2**127 << 1, 2**128)
1007 self.assertEqual(-2**127 << 1, -2**128)
1008
1009 def test_medium_lshift(self):
1010 self.assertEqual(42 << 9, 21504)
1011 self.assertEqual((-42) << 9, -21504)
1012 self.assertEqual(1122 << 9, 574464)
1013 self.assertEqual((-1122) << 9, -574464)
1014
1015 def test_big_lshift(self):
1016 self.assertEqual(42 << 32, 42 * 2**32)
1017 self.assertEqual((-42) << 32, -42 * 2**32)
1018 self.assertEqual(1122 << 32, 1122 * 2**32)
1019 self.assertEqual((-1122) << 32, -1122 * 2**32)
1020 self.assertEqual(2**128 << 32, 2**160)
1021 self.assertEqual(-2**128 << 32, -2**160)
1022
1023 @support.cpython_only
1024 def test_small_ints_in_huge_calculation(self):
1025 a = 2 ** 100
1026 b = -a + 1
1027 c = a + 1
1028 self.assertIs(a + b, 1)
1029 self.assertIs(c - a, 1)
1030
1031 @support.cpython_only
1032 def test_pow_uses_cached_small_ints(self):
1033 self.assertIs(pow(10, 3, 998), 2)
1034 self.assertIs(10 ** 3 % 998, 2)
1035 a, p, m = 10, 3, 998
1036 self.assertIs(a ** p % m, 2)
1037
1038 self.assertIs(pow(2, 31, 2 ** 31 - 1), 1)
1039 self.assertIs(2 ** 31 % (2 ** 31 - 1), 1)
1040 a, p, m = 2, 31, 2 ** 31 - 1
1041 self.assertIs(a ** p % m, 1)
1042
1043 self.assertIs(pow(2, 100, 2**100 - 3), 3)
1044 self.assertIs(2 ** 100 % (2 ** 100 - 3), 3)
1045 a, p, m = 2, 100, 2**100 - 3
1046 self.assertIs(a ** p % m, 3)
1047
1048 @support.cpython_only
1049 def test_divmod_uses_cached_small_ints(self):
1050 big = 10 ** 100
1051
1052 self.assertIs((big + 1) % big, 1)
1053 self.assertIs((big + 1) // big, 1)
1054 self.assertIs(big // (big // 2), 2)
1055 self.assertIs(big // (big // -4), -4)
1056
1057 q, r = divmod(2 * big + 3, big)
1058 self.assertIs(q, 2)
1059 self.assertIs(r, 3)
1060
1061 q, r = divmod(-4 * big + 100, big)
1062 self.assertIs(q, -4)
1063 self.assertIs(r, 100)
1064
1065 q, r = divmod(3 * (-big) - 1, -big)
1066 self.assertIs(q, 3)
1067 self.assertIs(r, -1)
1068
1069 q, r = divmod(3 * big - 1, -big)
1070 self.assertIs(q, -3)
1071 self.assertIs(r, -1)
1072
1073 def test_small_ints(self):
1074 for i in range(-5, 257):
1075 self.assertIs(i, i + 0)
1076 self.assertIs(i, i * 1)
1077 self.assertIs(i, i - 0)
1078 self.assertIs(i, i // 1)
1079 self.assertIs(i, i & -1)
1080 self.assertIs(i, i | 0)
1081 self.assertIs(i, i ^ 0)
1082 self.assertIs(i, ~~i)
1083 self.assertIs(i, i**1)
1084 self.assertIs(i, int(str(i)))
1085 self.assertIs(i, i<<2>>2, str(i))
1086 # corner cases
1087 i = 1 << 70
1088 self.assertIs(i - i, 0)
1089 self.assertIs(0 * i, 0)
1090
1091 def test_bit_length(self):
1092 tiny = 1e-10
1093 for x in range(-65000, 65000):
1094 k = x.bit_length()
1095 # Check equivalence with Python version
1096 self.assertEqual(k, len(bin(x).lstrip('-0b')))
1097 # Behaviour as specified in the docs
1098 if x != 0:
1099 self.assertTrue(2**(k-1) <= abs(x) < 2**k)
1100 else:
1101 self.assertEqual(k, 0)
1102 # Alternative definition: x.bit_length() == 1 + floor(log_2(x))
1103 if x != 0:
1104 # When x is an exact power of 2, numeric errors can
1105 # cause floor(log(x)/log(2)) to be one too small; for
1106 # small x this can be fixed by adding a small quantity
1107 # to the quotient before taking the floor.
1108 self.assertEqual(k, 1 + math.floor(
1109 math.log(abs(x))/math.log(2) + tiny))
1110
1111 self.assertEqual((0).bit_length(), 0)
1112 self.assertEqual((1).bit_length(), 1)
1113 self.assertEqual((-1).bit_length(), 1)
1114 self.assertEqual((2).bit_length(), 2)
1115 self.assertEqual((-2).bit_length(), 2)
1116 for i in [2, 3, 15, 16, 17, 31, 32, 33, 63, 64, 234]:
1117 a = 2**i
1118 self.assertEqual((a-1).bit_length(), i)
1119 self.assertEqual((1-a).bit_length(), i)
1120 self.assertEqual((a).bit_length(), i+1)
1121 self.assertEqual((-a).bit_length(), i+1)
1122 self.assertEqual((a+1).bit_length(), i+1)
1123 self.assertEqual((-a-1).bit_length(), i+1)
1124
1125 def test_bit_count(self):
1126 for a in range(-1000, 1000):
1127 self.assertEqual(a.bit_count(), bin(a).count("1"))
1128
1129 for exp in [10, 17, 63, 64, 65, 1009, 70234, 1234567]:
1130 a = 2**exp
1131 self.assertEqual(a.bit_count(), 1)
1132 self.assertEqual((a - 1).bit_count(), exp)
1133 self.assertEqual((a ^ 63).bit_count(), 7)
1134 self.assertEqual(((a - 1) ^ 510).bit_count(), exp - 8)
1135
1136 def test_round(self):
1137 # check round-half-even algorithm. For round to nearest ten;
1138 # rounding map is invariant under adding multiples of 20
1139 test_dict = {0:0, 1:0, 2:0, 3:0, 4:0, 5:0,
1140 6:10, 7:10, 8:10, 9:10, 10:10, 11:10, 12:10, 13:10, 14:10,
1141 15:20, 16:20, 17:20, 18:20, 19:20}
1142 for offset in range(-520, 520, 20):
1143 for k, v in test_dict.items():
1144 got = round(k+offset, -1)
1145 expected = v+offset
1146 self.assertEqual(got, expected)
1147 self.assertIs(type(got), int)
1148
1149 # larger second argument
1150 self.assertEqual(round(-150, -2), -200)
1151 self.assertEqual(round(-149, -2), -100)
1152 self.assertEqual(round(-51, -2), -100)
1153 self.assertEqual(round(-50, -2), 0)
1154 self.assertEqual(round(-49, -2), 0)
1155 self.assertEqual(round(-1, -2), 0)
1156 self.assertEqual(round(0, -2), 0)
1157 self.assertEqual(round(1, -2), 0)
1158 self.assertEqual(round(49, -2), 0)
1159 self.assertEqual(round(50, -2), 0)
1160 self.assertEqual(round(51, -2), 100)
1161 self.assertEqual(round(149, -2), 100)
1162 self.assertEqual(round(150, -2), 200)
1163 self.assertEqual(round(250, -2), 200)
1164 self.assertEqual(round(251, -2), 300)
1165 self.assertEqual(round(172500, -3), 172000)
1166 self.assertEqual(round(173500, -3), 174000)
1167 self.assertEqual(round(31415926535, -1), 31415926540)
1168 self.assertEqual(round(31415926535, -2), 31415926500)
1169 self.assertEqual(round(31415926535, -3), 31415927000)
1170 self.assertEqual(round(31415926535, -4), 31415930000)
1171 self.assertEqual(round(31415926535, -5), 31415900000)
1172 self.assertEqual(round(31415926535, -6), 31416000000)
1173 self.assertEqual(round(31415926535, -7), 31420000000)
1174 self.assertEqual(round(31415926535, -8), 31400000000)
1175 self.assertEqual(round(31415926535, -9), 31000000000)
1176 self.assertEqual(round(31415926535, -10), 30000000000)
1177 self.assertEqual(round(31415926535, -11), 0)
1178 self.assertEqual(round(31415926535, -12), 0)
1179 self.assertEqual(round(31415926535, -999), 0)
1180
1181 # should get correct results even for huge inputs
1182 for k in range(10, 100):
1183 got = round(10**k + 324678, -3)
1184 expect = 10**k + 325000
1185 self.assertEqual(got, expect)
1186 self.assertIs(type(got), int)
1187
1188 # nonnegative second argument: round(x, n) should just return x
1189 for n in range(5):
1190 for i in range(100):
1191 x = random.randrange(-10000, 10000)
1192 got = round(x, n)
1193 self.assertEqual(got, x)
1194 self.assertIs(type(got), int)
1195 for huge_n in 2**31-1, 2**31, 2**63-1, 2**63, 2**100, 10**100:
1196 self.assertEqual(round(8979323, huge_n), 8979323)
1197
1198 # omitted second argument
1199 for i in range(100):
1200 x = random.randrange(-10000, 10000)
1201 got = round(x)
1202 self.assertEqual(got, x)
1203 self.assertIs(type(got), int)
1204
1205 # bad second argument
1206 bad_exponents = ('brian', 2.0, 0j)
1207 for e in bad_exponents:
1208 self.assertRaises(TypeError, round, 3, e)
1209
1210 def test_to_bytes(self):
1211 def check(tests, byteorder, signed=False):
1212 def equivalent_python(n, length, byteorder, signed=False):
1213 if byteorder == 'little':
1214 order = range(length)
1215 elif byteorder == 'big':
1216 order = reversed(range(length))
1217 return bytes((n >> i*8) & 0xff for i in order)
1218
1219 for test, expected in tests.items():
1220 try:
1221 self.assertEqual(
1222 test.to_bytes(len(expected), byteorder, signed=signed),
1223 expected)
1224 except Exception as err:
1225 raise AssertionError(
1226 "failed to convert {} with byteorder={} and signed={}"
1227 .format(test, byteorder, signed)) from err
1228
1229 # Test for all default arguments.
1230 if len(expected) == 1 and byteorder == 'big' and not signed:
1231 try:
1232 self.assertEqual(test.to_bytes(), expected)
1233 except Exception as err:
1234 raise AssertionError(
1235 "failed to convert {} with default arguments"
1236 .format(test)) from err
1237
1238 try:
1239 self.assertEqual(
1240 equivalent_python(
1241 test, len(expected), byteorder, signed=signed),
1242 expected
1243 )
1244 except Exception as err:
1245 raise AssertionError(
1246 "Code equivalent from docs is not equivalent for "
1247 "conversion of {0} with byteorder byteorder={1} and "
1248 "signed={2}".format(test, byteorder, signed)) from err
1249
1250 # Convert integers to signed big-endian byte arrays.
1251 tests1 = {
1252 0: b'\x00',
1253 1: b'\x01',
1254 -1: b'\xff',
1255 -127: b'\x81',
1256 -128: b'\x80',
1257 -129: b'\xff\x7f',
1258 127: b'\x7f',
1259 129: b'\x00\x81',
1260 -255: b'\xff\x01',
1261 -256: b'\xff\x00',
1262 255: b'\x00\xff',
1263 256: b'\x01\x00',
1264 32767: b'\x7f\xff',
1265 -32768: b'\xff\x80\x00',
1266 65535: b'\x00\xff\xff',
1267 -65536: b'\xff\x00\x00',
1268 -8388608: b'\x80\x00\x00'
1269 }
1270 check(tests1, 'big', signed=True)
1271
1272 # Convert integers to signed little-endian byte arrays.
1273 tests2 = {
1274 0: b'\x00',
1275 1: b'\x01',
1276 -1: b'\xff',
1277 -127: b'\x81',
1278 -128: b'\x80',
1279 -129: b'\x7f\xff',
1280 127: b'\x7f',
1281 129: b'\x81\x00',
1282 -255: b'\x01\xff',
1283 -256: b'\x00\xff',
1284 255: b'\xff\x00',
1285 256: b'\x00\x01',
1286 32767: b'\xff\x7f',
1287 -32768: b'\x00\x80',
1288 65535: b'\xff\xff\x00',
1289 -65536: b'\x00\x00\xff',
1290 -8388608: b'\x00\x00\x80'
1291 }
1292 check(tests2, 'little', signed=True)
1293
1294 # Convert integers to unsigned big-endian byte arrays.
1295 tests3 = {
1296 0: b'\x00',
1297 1: b'\x01',
1298 127: b'\x7f',
1299 128: b'\x80',
1300 255: b'\xff',
1301 256: b'\x01\x00',
1302 32767: b'\x7f\xff',
1303 32768: b'\x80\x00',
1304 65535: b'\xff\xff',
1305 65536: b'\x01\x00\x00'
1306 }
1307 check(tests3, 'big', signed=False)
1308
1309 # Convert integers to unsigned little-endian byte arrays.
1310 tests4 = {
1311 0: b'\x00',
1312 1: b'\x01',
1313 127: b'\x7f',
1314 128: b'\x80',
1315 255: b'\xff',
1316 256: b'\x00\x01',
1317 32767: b'\xff\x7f',
1318 32768: b'\x00\x80',
1319 65535: b'\xff\xff',
1320 65536: b'\x00\x00\x01'
1321 }
1322 check(tests4, 'little', signed=False)
1323
1324 self.assertRaises(OverflowError, (256).to_bytes, 1, 'big', signed=False)
1325 self.assertRaises(OverflowError, (256).to_bytes, 1, 'big', signed=True)
1326 self.assertRaises(OverflowError, (256).to_bytes, 1, 'little', signed=False)
1327 self.assertRaises(OverflowError, (256).to_bytes, 1, 'little', signed=True)
1328 self.assertRaises(OverflowError, (-1).to_bytes, 2, 'big', signed=False)
1329 self.assertRaises(OverflowError, (-1).to_bytes, 2, 'little', signed=False)
1330 self.assertEqual((0).to_bytes(0, 'big'), b'')
1331 self.assertEqual((1).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x01')
1332 self.assertEqual((0).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x00')
1333 self.assertEqual((-1).to_bytes(5, 'big', signed=True),
1334 b'\xff\xff\xff\xff\xff')
1335 self.assertRaises(OverflowError, (1).to_bytes, 0, 'big')
1336
1337 # gh-98783
1338 class ESC[4;38;5;81mSubStr(ESC[4;38;5;149mstr):
1339 pass
1340 self.assertEqual((0).to_bytes(1, SubStr('big')), b'\x00')
1341 self.assertEqual((0).to_bytes(0, SubStr('little')), b'')
1342
1343 def test_from_bytes(self):
1344 def check(tests, byteorder, signed=False):
1345 def equivalent_python(byte_array, byteorder, signed=False):
1346 if byteorder == 'little':
1347 little_ordered = list(byte_array)
1348 elif byteorder == 'big':
1349 little_ordered = list(reversed(byte_array))
1350
1351 n = sum(b << i*8 for i, b in enumerate(little_ordered))
1352 if signed and little_ordered and (little_ordered[-1] & 0x80):
1353 n -= 1 << 8*len(little_ordered)
1354
1355 return n
1356
1357 for test, expected in tests.items():
1358 try:
1359 self.assertEqual(
1360 int.from_bytes(test, byteorder, signed=signed),
1361 expected)
1362 except Exception as err:
1363 raise AssertionError(
1364 "failed to convert {} with byteorder={!r} and signed={}"
1365 .format(test, byteorder, signed)) from err
1366
1367 # Test for all default arguments.
1368 if byteorder == 'big' and not signed:
1369 try:
1370 self.assertEqual(
1371 int.from_bytes(test),
1372 expected)
1373 except Exception as err:
1374 raise AssertionError(
1375 "failed to convert {} with default arguments"
1376 .format(test)) from err
1377
1378 try:
1379 self.assertEqual(
1380 equivalent_python(test, byteorder, signed=signed),
1381 expected
1382 )
1383 except Exception as err:
1384 raise AssertionError(
1385 "Code equivalent from docs is not equivalent for "
1386 "conversion of {0} with byteorder={1!r} and signed={2}"
1387 .format(test, byteorder, signed)) from err
1388
1389 # Convert signed big-endian byte arrays to integers.
1390 tests1 = {
1391 b'': 0,
1392 b'\x00': 0,
1393 b'\x00\x00': 0,
1394 b'\x01': 1,
1395 b'\x00\x01': 1,
1396 b'\xff': -1,
1397 b'\xff\xff': -1,
1398 b'\x81': -127,
1399 b'\x80': -128,
1400 b'\xff\x7f': -129,
1401 b'\x7f': 127,
1402 b'\x00\x81': 129,
1403 b'\xff\x01': -255,
1404 b'\xff\x00': -256,
1405 b'\x00\xff': 255,
1406 b'\x01\x00': 256,
1407 b'\x7f\xff': 32767,
1408 b'\x80\x00': -32768,
1409 b'\x00\xff\xff': 65535,
1410 b'\xff\x00\x00': -65536,
1411 b'\x80\x00\x00': -8388608
1412 }
1413 check(tests1, 'big', signed=True)
1414
1415 # Convert signed little-endian byte arrays to integers.
1416 tests2 = {
1417 b'': 0,
1418 b'\x00': 0,
1419 b'\x00\x00': 0,
1420 b'\x01': 1,
1421 b'\x00\x01': 256,
1422 b'\xff': -1,
1423 b'\xff\xff': -1,
1424 b'\x81': -127,
1425 b'\x80': -128,
1426 b'\x7f\xff': -129,
1427 b'\x7f': 127,
1428 b'\x81\x00': 129,
1429 b'\x01\xff': -255,
1430 b'\x00\xff': -256,
1431 b'\xff\x00': 255,
1432 b'\x00\x01': 256,
1433 b'\xff\x7f': 32767,
1434 b'\x00\x80': -32768,
1435 b'\xff\xff\x00': 65535,
1436 b'\x00\x00\xff': -65536,
1437 b'\x00\x00\x80': -8388608
1438 }
1439 check(tests2, 'little', signed=True)
1440
1441 # Convert unsigned big-endian byte arrays to integers.
1442 tests3 = {
1443 b'': 0,
1444 b'\x00': 0,
1445 b'\x01': 1,
1446 b'\x7f': 127,
1447 b'\x80': 128,
1448 b'\xff': 255,
1449 b'\x01\x00': 256,
1450 b'\x7f\xff': 32767,
1451 b'\x80\x00': 32768,
1452 b'\xff\xff': 65535,
1453 b'\x01\x00\x00': 65536,
1454 }
1455 check(tests3, 'big', signed=False)
1456
1457 # Convert integers to unsigned little-endian byte arrays.
1458 tests4 = {
1459 b'': 0,
1460 b'\x00': 0,
1461 b'\x01': 1,
1462 b'\x7f': 127,
1463 b'\x80': 128,
1464 b'\xff': 255,
1465 b'\x00\x01': 256,
1466 b'\xff\x7f': 32767,
1467 b'\x00\x80': 32768,
1468 b'\xff\xff': 65535,
1469 b'\x00\x00\x01': 65536,
1470 }
1471 check(tests4, 'little', signed=False)
1472
1473 class ESC[4;38;5;81mmyint(ESC[4;38;5;149mint):
1474 pass
1475
1476 self.assertIs(type(myint.from_bytes(b'\x00', 'big')), myint)
1477 self.assertEqual(myint.from_bytes(b'\x01', 'big'), 1)
1478 self.assertIs(
1479 type(myint.from_bytes(b'\x00', 'big', signed=False)), myint)
1480 self.assertEqual(myint.from_bytes(b'\x01', 'big', signed=False), 1)
1481 self.assertIs(type(myint.from_bytes(b'\x00', 'little')), myint)
1482 self.assertEqual(myint.from_bytes(b'\x01', 'little'), 1)
1483 self.assertIs(type(myint.from_bytes(
1484 b'\x00', 'little', signed=False)), myint)
1485 self.assertEqual(myint.from_bytes(b'\x01', 'little', signed=False), 1)
1486 self.assertEqual(
1487 int.from_bytes([255, 0, 0], 'big', signed=True), -65536)
1488 self.assertEqual(
1489 int.from_bytes((255, 0, 0), 'big', signed=True), -65536)
1490 self.assertEqual(int.from_bytes(
1491 bytearray(b'\xff\x00\x00'), 'big', signed=True), -65536)
1492 self.assertEqual(int.from_bytes(
1493 bytearray(b'\xff\x00\x00'), 'big', signed=True), -65536)
1494 self.assertEqual(int.from_bytes(
1495 array.array('B', b'\xff\x00\x00'), 'big', signed=True), -65536)
1496 self.assertEqual(int.from_bytes(
1497 memoryview(b'\xff\x00\x00'), 'big', signed=True), -65536)
1498 self.assertRaises(ValueError, int.from_bytes, [256], 'big')
1499 self.assertRaises(ValueError, int.from_bytes, [0], 'big\x00')
1500 self.assertRaises(ValueError, int.from_bytes, [0], 'little\x00')
1501 self.assertRaises(TypeError, int.from_bytes, "", 'big')
1502 self.assertRaises(TypeError, int.from_bytes, "\x00", 'big')
1503 self.assertRaises(TypeError, int.from_bytes, 0, 'big')
1504 self.assertRaises(TypeError, int.from_bytes, 0, 'big', True)
1505 self.assertRaises(TypeError, myint.from_bytes, "", 'big')
1506 self.assertRaises(TypeError, myint.from_bytes, "\x00", 'big')
1507 self.assertRaises(TypeError, myint.from_bytes, 0, 'big')
1508 self.assertRaises(TypeError, int.from_bytes, 0, 'big', True)
1509
1510 class ESC[4;38;5;81mmyint2(ESC[4;38;5;149mint):
1511 def __new__(cls, value):
1512 return int.__new__(cls, value + 1)
1513
1514 i = myint2.from_bytes(b'\x01', 'big')
1515 self.assertIs(type(i), myint2)
1516 self.assertEqual(i, 2)
1517
1518 class ESC[4;38;5;81mmyint3(ESC[4;38;5;149mint):
1519 def __init__(self, value):
1520 self.foo = 'bar'
1521
1522 i = myint3.from_bytes(b'\x01', 'big')
1523 self.assertIs(type(i), myint3)
1524 self.assertEqual(i, 1)
1525 self.assertEqual(getattr(i, 'foo', 'none'), 'bar')
1526
1527 class ESC[4;38;5;81mValidBytes:
1528 def __bytes__(self):
1529 return b'\x01'
1530 class ESC[4;38;5;81mInvalidBytes:
1531 def __bytes__(self):
1532 return 'abc'
1533 class ESC[4;38;5;81mMissingBytes: ...
1534 class ESC[4;38;5;81mRaisingBytes:
1535 def __bytes__(self):
1536 1 / 0
1537
1538 self.assertEqual(int.from_bytes(ValidBytes()), 1)
1539 self.assertRaises(TypeError, int.from_bytes, InvalidBytes())
1540 self.assertRaises(TypeError, int.from_bytes, MissingBytes())
1541 self.assertRaises(ZeroDivisionError, int.from_bytes, RaisingBytes())
1542
1543 # gh-98783
1544 class ESC[4;38;5;81mSubStr(ESC[4;38;5;149mstr):
1545 pass
1546 self.assertEqual(int.from_bytes(b'', SubStr('big')), 0)
1547 self.assertEqual(int.from_bytes(b'\x00', SubStr('little')), 0)
1548
1549 @support.cpython_only
1550 def test_from_bytes_small(self):
1551 # bpo-46361
1552 for i in range(-5, 257):
1553 b = i.to_bytes(2, signed=True)
1554 self.assertIs(int.from_bytes(b, signed=True), i)
1555
1556 def test_access_to_nonexistent_digit_0(self):
1557 # http://bugs.python.org/issue14630: A bug in _PyLong_Copy meant that
1558 # ob_digit[0] was being incorrectly accessed for instances of a
1559 # subclass of int, with value 0.
1560 class ESC[4;38;5;81mInteger(ESC[4;38;5;149mint):
1561 def __new__(cls, value=0):
1562 self = int.__new__(cls, value)
1563 self.foo = 'foo'
1564 return self
1565
1566 integers = [Integer(0) for i in range(1000)]
1567 for n in map(int, integers):
1568 self.assertEqual(n, 0)
1569
1570 def test_shift_bool(self):
1571 # Issue #21422: ensure that bool << int and bool >> int return int
1572 for value in (True, False):
1573 for shift in (0, 2):
1574 self.assertEqual(type(value << shift), int)
1575 self.assertEqual(type(value >> shift), int)
1576
1577 def test_as_integer_ratio(self):
1578 class ESC[4;38;5;81mmyint(ESC[4;38;5;149mint):
1579 pass
1580 tests = [10, 0, -10, 1, sys.maxsize + 1, True, False, myint(42)]
1581 for value in tests:
1582 numerator, denominator = value.as_integer_ratio()
1583 self.assertEqual((numerator, denominator), (int(value), 1))
1584 self.assertEqual(type(numerator), int)
1585 self.assertEqual(type(denominator), int)
1586
1587 def test_square(self):
1588 # Multiplication makes a special case of multiplying an int with
1589 # itself, using a special, faster algorithm. This test is mostly
1590 # to ensure that no asserts in the implementation trigger, in
1591 # cases with a maximal amount of carries.
1592 for bitlen in range(1, 400):
1593 n = (1 << bitlen) - 1 # solid string of 1 bits
1594 with self.subTest(bitlen=bitlen, n=n):
1595 # (2**i - 1)**2 = 2**(2*i) - 2*2**i + 1
1596 self.assertEqual(n**2,
1597 (1 << (2 * bitlen)) - (1 << (bitlen + 1)) + 1)
1598
1599 if __name__ == "__main__":
1600 unittest.main()