1import unittest 2from test import support 3 4import sys 5 6import random 7import math 8import array 9 10# SHIFT should match the value in longintrepr.h for best testing. 11SHIFT = sys.int_info.bits_per_digit 12BASE = 2 ** SHIFT 13MASK = BASE - 1 14KARATSUBA_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. 18MAXDIGITS = 15 19 20# build some special values 21special = [0, 1, 2, BASE, BASE >> 1, 0x5555555555555555, 0xaaaaaaaaaaaaaaaa] 22# some solid strings of one bits 23p2 = 4 # 0 and 1 already added 24for i in range(2*SHIFT): 25 special.append(p2 - 1) 26 p2 = p2 << 1 27del p2 28# add complements & negations 29special += [~x for x in special] + [-x for x in special] 30 31DBL_MAX = sys.float_info.max 32DBL_MAX_EXP = sys.float_info.max_exp 33DBL_MIN_EXP = sys.float_info.min_exp 34DBL_MANT_DIG = sys.float_info.mant_dig 35DBL_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. 39def 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 85def 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 115class LongTest(unittest.TestCase): 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 JustLong: 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 LongTrunc: 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 Rat: 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 SubStr(str): 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 myint(int): 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 myint2(int): 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 myint3(int): 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 ValidBytes: 1528 def __bytes__(self): 1529 return b'\x01' 1530 class InvalidBytes: 1531 def __bytes__(self): 1532 return 'abc' 1533 class MissingBytes: ... 1534 class RaisingBytes: 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 SubStr(str): 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 Integer(int): 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 myint(int): 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 1599if __name__ == "__main__": 1600 unittest.main() 1601