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