cpython-lru_cache-weakref: Lib/test/test

annotate Lib/test/test_long.py @ 80272:ec00f8570c55

Merge typo fix.

author	Ezio Melotti <ezio.melotti@gmail.com>
date	Mon, 05 Nov 2012 22:23:16 +0200
parents	c7b0f711dc15
children	4d62a62ba44d 33bdd0a985b9

rev	line source
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	1 import unittest
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 46909 diff changeset	2 from test import support
66709 f2a4ade36a1e Issue #10624: Use support.requires_IEEE_754 in all appropriate tests. Eric Smith <eric@trueblade.com> parents: 66686 diff changeset	3
46664 031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	4 import sys
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	5
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	6 import random
50207 92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	7 import math
58223 f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	8 import array
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	9
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	10 # Used for lazy formatting of failure messages
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	11 class Frm(object):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	12 def __init__(self, format, *args):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	13 self.format = format
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	14 self.args = args
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	15
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	16 def __str__(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	17 return self.format % self.args
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	18
5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	19 # SHIFT should match the value in longintrepr.h for best testing.
52215 bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	20 SHIFT = sys.int_info.bits_per_digit
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	21 BASE = 2 ** SHIFT
5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	22 MASK = BASE - 1
33348 adc66d314c78 Changed Karatsuba cutoff to match current reality. Tim Peters <tim.peters@gmail.com> parents: 27638 diff changeset	23 KARATSUBA_CUTOFF = 70 # from longobject.c
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	24
5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	25 # Max number of base BASE digits to use in test cases. Doubling
24778 f1d18fcd56e6 Machines-- and Python --are a lot faster in relevant ways since this Tim Peters <tim.peters@gmail.com> parents: 24364 diff changeset	26 # this will more than double the runtime.
f1d18fcd56e6 Machines-- and Python --are a lot faster in relevant ways since this Tim Peters <tim.peters@gmail.com> parents: 24364 diff changeset	27 MAXDIGITS = 15
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	28
9209 d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	29 # build some special values
42142 a53e48be6df9 Merged revisions 56125-56153 via svnmerge from Guido van Rossum <guido@python.org> parents: 42084 diff changeset	30 special = [0, 1, 2, BASE, BASE >> 1, 0x5555555555555555, 0xaaaaaaaaaaaaaaaa]
9209 d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	31 # some solid strings of one bits
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	32 p2 = 4 # 0 and 1 already added
9209 d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	33 for i in range(2*SHIFT):
d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	34 special.append(p2 - 1)
d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	35 p2 = p2 << 1
d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	36 del p2
d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	37 # add complements & negations
42142 a53e48be6df9 Merged revisions 56125-56153 via svnmerge from Guido van Rossum <guido@python.org> parents: 42084 diff changeset	38 special += [~x for x in special] + [-x for x in special]
9209 d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	39
57942 aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	40 DBL_MAX = sys.float_info.max
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	41 DBL_MAX_EXP = sys.float_info.max_exp
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	42 DBL_MIN_EXP = sys.float_info.min_exp
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	43 DBL_MANT_DIG = sys.float_info.mant_dig
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	44 DBL_MIN_OVERFLOW = 2DBL_MAX_EXP - 2(DBL_MAX_EXP - DBL_MANT_DIG - 1)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	45
73074 117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	46
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	47 # Pure Python version of correctly-rounded integer-to-float conversion.
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	48 def int_to_float(n):
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	49 """
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	50 Correctly-rounded integer-to-float conversion.
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	51
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	52 """
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	53 # Constants, depending only on the floating-point format in use.
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	54 # We use an extra 2 bits of precision for rounding purposes.
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	55 PRECISION = sys.float_info.mant_dig + 2
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	56 SHIFT_MAX = sys.float_info.max_exp - PRECISION
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	57 Q_MAX = 1 << PRECISION
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	58 ROUND_HALF_TO_EVEN_CORRECTION = [0, -1, -2, 1, 0, -1, 2, 1]
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	59
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	60 # Reduce to the case where n is positive.
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	61 if n == 0:
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	62 return 0.0
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	63 elif n < 0:
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	64 return -int_to_float(-n)
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	65
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	66 # Convert n to a 'floating-point' number q * 2**shift, where q is an
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	67 # integer with 'PRECISION' significant bits. When shifting n to create q,
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	68 # the least significant bit of q is treated as 'sticky'. That is, the
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	69 # least significant bit of q is set if either the corresponding bit of n
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	70 # was already set, or any one of the bits of n lost in the shift was set.
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	71 shift = n.bit_length() - PRECISION
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	72 q = n << -shift if shift < 0 else (n >> shift) \| bool(n & ~(-1 << shift))
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	73
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	74 # Round half to even (actually rounds to the nearest multiple of 4,
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	75 # rounding ties to a multiple of 8).
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	76 q += ROUND_HALF_TO_EVEN_CORRECTION[q & 7]
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	77
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	78 # Detect overflow.
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	79 if shift + (q == Q_MAX) > SHIFT_MAX:
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	80 raise OverflowError("integer too large to convert to float")
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	81
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	82 # Checks: q is exactly representable, and q2shift doesn't overflow.
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	83 assert q % 4 == 0 and q // 4 <= 2**(sys.float_info.mant_dig)
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	84 assert q * 2**shift <= sys.float_info.max
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	85
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	86 # Some circularity here, since float(q) is doing an int-to-float
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	87 # conversion. But here q is of bounded size, and is exactly representable
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	88 # as a float. In a low-level C-like language, this operation would be a
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	89 # simple cast (e.g., from unsigned long long to double).
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	90 return math.ldexp(float(q), shift)
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	91
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	92
57942 aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	93 # pure Python version of correctly-rounded true division
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	94 def truediv(a, b):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	95 """Correctly-rounded true division for integers."""
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	96 negative = a^b < 0
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	97 a, b = abs(a), abs(b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	98
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	99 # exceptions: division by zero, overflow
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	100 if not b:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	101 raise ZeroDivisionError("division by zero")
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	102 if a >= DBL_MIN_OVERFLOW * b:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	103 raise OverflowError("int/int too large to represent as a float")
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	104
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	105 # find integer d satisfying 2(d - 1) <= a/b < 2d
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	106 d = a.bit_length() - b.bit_length()
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	107 if d >= 0 and a >= 2*d b or d < 0 and a * 2**-d >= b:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	108 d += 1
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	109
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	110 # compute 2*-exp a / b for suitable exp
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	111 exp = max(d, DBL_MIN_EXP) - DBL_MANT_DIG
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	112 a, b = a << max(-exp, 0), b << max(exp, 0)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	113 q, r = divmod(a, b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	114
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	115 # round-half-to-even: fractional part is r/b, which is > 0.5 iff
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	116 # 2r > b, and == 0.5 iff 2r == b.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	117 if 2r > b or 2r == b and q % 2 == 1:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	118 q += 1
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	119
57946 dd6726c978c6 Merged revisions 77066 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57942 diff changeset	120 result = math.ldexp(q, exp)
57942 aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	121 return -result if negative else result
46664 031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	122
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	123
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	124 class LongTest(unittest.TestCase):
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	125
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	126 # Get quasi-random long consisting of ndigits digits (in base BASE).
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	127 # quasi == the most-significant digit will not be 0, and the number
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	128 # is constructed to contain long strings of 0 and 1 bits. These are
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	129 # more likely than random bits to provoke digit-boundary errors.
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	130 # The sign of the number is also random.
9209 d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	131
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	132 def getran(self, ndigits):
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	133 self.assertTrue(ndigits > 0)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	134 nbits_hi = ndigits * SHIFT
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	135 nbits_lo = nbits_hi - SHIFT + 1
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	136 answer = 0
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	137 nbits = 0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	138 r = int(random.random() * (SHIFT * 2)) \| 1 # force 1 bits to start
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	139 while nbits < nbits_lo:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	140 bits = (r >> 1) + 1
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	141 bits = min(bits, nbits_hi - nbits)
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	142 self.assertTrue(1 <= bits <= SHIFT)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	143 nbits = nbits + bits
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	144 answer = answer << bits
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	145 if r & 1:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	146 answer = answer \| ((1 << bits) - 1)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	147 r = int(random.random() * (SHIFT * 2))
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	148 self.assertTrue(nbits_lo <= nbits <= nbits_hi)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	149 if random.random() < 0.5:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	150 answer = -answer
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	151 return answer
9209 d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	152
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	153 # Get random long consisting of ndigits random digits (relative to base
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	154 # BASE). The sign bit is also random.
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	155
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	156 def getran2(ndigits):
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	157 answer = 0
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	158 for i in range(ndigits):
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	159 answer = (answer << SHIFT) \| random.randint(0, MASK)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	160 if random.random() < 0.5:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	161 answer = -answer
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	162 return answer
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	163
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	164 def check_division(self, x, y):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	165 eq = self.assertEqual
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	166 q, r = divmod(x, y)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	167 q2, r2 = x//y, x%y
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	168 pab, pba = xy, yx
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	169 eq(pab, pba, Frm("multiplication does not commute for %r and %r", x, y))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	170 eq(q, q2, Frm("divmod returns different quotient than / for %r and %r", x, y))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	171 eq(r, r2, Frm("divmod returns different mod than %% for %r and %r", x, y))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	172 eq(x, qy + r, Frm("x != qy + r after divmod on x=%r, y=%r", x, y))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	173 if y > 0:
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	174 self.assertTrue(0 <= r < y, Frm("bad mod from divmod on %r and %r", x, y))
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	175 else:
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	176 self.assertTrue(y < r <= 0, Frm("bad mod from divmod on %r and %r", x, y))
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	177
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	178 def test_division(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	179 digits = list(range(1, MAXDIGITS+1)) + list(range(KARATSUBA_CUTOFF,
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	180 KARATSUBA_CUTOFF + 14))
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	181 digits.append(KARATSUBA_CUTOFF * 3)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	182 for lenx in digits:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	183 x = self.getran(lenx)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	184 for leny in digits:
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	185 y = self.getran(leny) or 1
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	186 self.check_division(x, y)
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	187
52215 bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	188 # specific numbers chosen to exercise corner cases of the
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	189 # current long division implementation
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	190
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	191 # 30-bit cases involving a quotient digit estimate of BASE+1
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	192 self.check_division(1231948412290879395966702881,
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	193 1147341367131428698)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	194 self.check_division(815427756481275430342312021515587883,
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	195 707270836069027745)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	196 self.check_division(627976073697012820849443363563599041,
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	197 643588798496057020)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	198 self.check_division(1115141373653752303710932756325578065,
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	199 1038556335171453937726882627)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	200 # 30-bit cases that require the post-subtraction correction step
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	201 self.check_division(922498905405436751940989320930368494,
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	202 949985870686786135626943396)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	203 self.check_division(768235853328091167204009652174031844,
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	204 1091555541180371554426545266)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	205
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	206 # 15-bit cases involving a quotient digit estimate of BASE+1
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	207 self.check_division(20172188947443, 615611397)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	208 self.check_division(1020908530270155025, 950795710)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	209 self.check_division(128589565723112408, 736393718)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	210 self.check_division(609919780285761575, 18613274546784)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	211 # 15-bit cases that require the post-subtraction correction step
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	212 self.check_division(710031681576388032, 26769404391308)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	213 self.check_division(1933622614268221, 30212853348836)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	214
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	215
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	216
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	217 def test_karatsuba(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	218 digits = list(range(1, 5)) + list(range(KARATSUBA_CUTOFF,
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	219 KARATSUBA_CUTOFF + 10))
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	220 digits.extend([KARATSUBA_CUTOFF * 10, KARATSUBA_CUTOFF * 100])
24794 1c63d3082656 Added a test specifically to tickle Karatsuba; it costs no appreciable Tim Peters <tim.peters@gmail.com> parents: 24779 diff changeset	221
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	222 bits = [digit * SHIFT for digit in digits]
24794 1c63d3082656 Added a test specifically to tickle Karatsuba; it costs no appreciable Tim Peters <tim.peters@gmail.com> parents: 24779 diff changeset	223
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	224 # Test products of long strings of 1 bits -- (2*x-1)(2**y-1) ==
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	225 # 2(x+y) - 2x - 2**y + 1, so the proper result is easy to check.
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	226 for abits in bits:
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	227 a = (1 << abits) - 1
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	228 for bbits in bits:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	229 if bbits < abits:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	230 continue
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	231 b = (1 << bbits) - 1
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	232 x = a * b
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	233 y = ((1 << (abits + bbits)) -
1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	234 (1 << abits) -
1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	235 (1 << bbits) +
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	236 1)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	237 self.assertEqual(x, y,
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	238 Frm("bad result for a*b: a=%r, b=%r, x=%r, y=%r", a, b, x, y))
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	239
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	240 def check_bitop_identities_1(self, x):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	241 eq = self.assertEqual
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	242 eq(x & 0, 0, Frm("x & 0 != 0 for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	243 eq(x \| 0, x, Frm("x \| 0 != x for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	244 eq(x ^ 0, x, Frm("x ^ 0 != x for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	245 eq(x & -1, x, Frm("x & -1 != x for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	246 eq(x \| -1, -1, Frm("x \| -1 != -1 for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	247 eq(x ^ -1, ~x, Frm("x ^ -1 != ~x for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	248 eq(x, ~~x, Frm("x != ~~x for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	249 eq(x & x, x, Frm("x & x != x for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	250 eq(x \| x, x, Frm("x \| x != x for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	251 eq(x ^ x, 0, Frm("x ^ x != 0 for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	252 eq(x & ~x, 0, Frm("x & ~x != 0 for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	253 eq(x \| ~x, -1, Frm("x \| ~x != -1 for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	254 eq(x ^ ~x, -1, Frm("x ^ ~x != -1 for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	255 eq(-x, 1 + ~x, Frm("not -x == 1 + ~x for x=%r", x))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	256 eq(-x, ~(x-1), Frm("not -x == ~(x-1) forx =%r", x))
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	257 for n in range(2*SHIFT):
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	258 p2 = 2 ** n
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	259 eq(x << n >> n, x,
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	260 Frm("x << n >> n != x for x=%r, n=%r", (x, n)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	261 eq(x // p2, x >> n,
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	262 Frm("x // p2 != x >> n for x=%r n=%r p2=%r", (x, n, p2)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	263 eq(x * p2, x << n,
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	264 Frm("x * p2 != x << n for x=%r n=%r p2=%r", (x, n, p2)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	265 eq(x & -p2, x >> n << n,
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	266 Frm("not x & -p2 == x >> n << n for x=%r n=%r p2=%r", (x, n, p2)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	267 eq(x & -p2, x & ~(p2 - 1),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	268 Frm("not x & -p2 == x & ~(p2 - 1) for x=%r n=%r p2=%r", (x, n, p2)))
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	269
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	270 def check_bitop_identities_2(self, x, y):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	271 eq = self.assertEqual
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	272 eq(x & y, y & x, Frm("x & y != y & x for x=%r, y=%r", (x, y)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	273 eq(x \| y, y \| x, Frm("x \| y != y \| x for x=%r, y=%r", (x, y)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	274 eq(x ^ y, y ^ x, Frm("x ^ y != y ^ x for x=%r, y=%r", (x, y)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	275 eq(x ^ y ^ x, y, Frm("x ^ y ^ x != y for x=%r, y=%r", (x, y)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	276 eq(x & y, ~(~x \| ~y), Frm("x & y != ~(~x \| ~y) for x=%r, y=%r", (x, y)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	277 eq(x \| y, ~(~x & ~y), Frm("x \| y != ~(~x & ~y) for x=%r, y=%r", (x, y)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	278 eq(x ^ y, (x \| y) & ~(x & y),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	279 Frm("x ^ y != (x \| y) & ~(x & y) for x=%r, y=%r", (x, y)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	280 eq(x ^ y, (x & ~y) \| (~x & y),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	281 Frm("x ^ y == (x & ~y) \| (~x & y) for x=%r, y=%r", (x, y)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	282 eq(x ^ y, (x \| y) & (~x \| ~y),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	283 Frm("x ^ y == (x \| y) & (~x \| ~y) for x=%r, y=%r", (x, y)))
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	284
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	285 def check_bitop_identities_3(self, x, y, z):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	286 eq = self.assertEqual
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	287 eq((x & y) & z, x & (y & z),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	288 Frm("(x & y) & z != x & (y & z) for x=%r, y=%r, z=%r", (x, y, z)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	289 eq((x \| y) \| z, x \| (y \| z),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	290 Frm("(x \| y) \| z != x \| (y \| z) for x=%r, y=%r, z=%r", (x, y, z)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	291 eq((x ^ y) ^ z, x ^ (y ^ z),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	292 Frm("(x ^ y) ^ z != x ^ (y ^ z) for x=%r, y=%r, z=%r", (x, y, z)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	293 eq(x & (y \| z), (x & y) \| (x & z),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	294 Frm("x & (y \| z) != (x & y) \| (x & z) for x=%r, y=%r, z=%r", (x, y, z)))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	295 eq(x \| (y & z), (x \| y) & (x \| z),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	296 Frm("x \| (y & z) != (x \| y) & (x \| z) for x=%r, y=%r, z=%r", (x, y, z)))
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	297
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	298 def test_bitop_identities(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	299 for x in special:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	300 self.check_bitop_identities_1(x)
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	301 digits = range(1, MAXDIGITS+1)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	302 for lenx in digits:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	303 x = self.getran(lenx)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	304 self.check_bitop_identities_1(x)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	305 for leny in digits:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	306 y = self.getran(leny)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	307 self.check_bitop_identities_2(x, y)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	308 self.check_bitop_identities_3(x, y, self.getran((lenx + leny)//2))
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	309
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	310 def slow_format(self, x, base):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	311 digits = []
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	312 sign = 0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	313 if x < 0:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	314 sign, x = 1, -x
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	315 while x:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	316 x, r = divmod(x, base)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	317 digits.append(int(r))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	318 digits.reverse()
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	319 digits = digits or [0]
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	320 return '-'[:sign] + \
42084 229c28cb9afb Merged revisions 55817-55961 via svnmerge from Guido van Rossum <guido@python.org> parents: 41642 diff changeset	321 {2: '0b', 8: '0o', 10: '', 16: '0x'}[base] + \
66686 8b02f7f9475b #1513299: cleanup some map() uses where a comprehension works better. Georg Brandl <georg@python.org> parents: 61940 diff changeset	322 "".join("0123456789abcdef"[i] for i in digits)
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	323
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	324 def check_format_1(self, x):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	325 for base, mapper in (8, oct), (10, repr), (16, hex):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	326 got = mapper(x)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	327 expected = self.slow_format(x, base)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	328 msg = Frm("%s returned %r but expected %r for %r",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	329 mapper.__name__, got, expected, x)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	330 self.assertEqual(got, expected, msg)
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	331 self.assertEqual(int(got, 0), x, Frm('int("%s", 0) != %r', got, x))
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	332 # str() has to be checked a little differently since there's no
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	333 # trailing "L"
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	334 got = str(x)
39574 2551eb5671a4 repr() of a long int no longer produces a trailing 'L'. Guido van Rossum <guido@python.org> parents: 35177 diff changeset	335 expected = self.slow_format(x, 10)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	336 msg = Frm("%s returned %r but expected %r for %r",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	337 mapper.__name__, got, expected, x)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	338 self.assertEqual(got, expected, msg)
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	339
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	340 def test_format(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	341 for x in special:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	342 self.check_format_1(x)
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	343 for i in range(10):
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	344 for lenx in range(1, MAXDIGITS+1):
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	345 x = self.getran(lenx)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	346 self.check_format_1(x)
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	347
46664 031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	348 def test_long(self):
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	349 # Check conversions from string
46664 031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	350 LL = [
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	351 ('1' + '0'20, 10*20),
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	352 ('1' + '0'100, 10*100)
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	353 ]
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	354 for s, v in LL:
46664 031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	355 for sign in "", "+", "-":
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	356 for prefix in "", " ", "\t", " \t\t ":
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	357 ss = prefix + sign + s
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	358 vv = v
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	359 if sign == "-" and v is not ValueError:
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	360 vv = -v
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	361 try:
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	362 self.assertEqual(int(ss), vv)
46664 031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	363 except ValueError:
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	364 pass
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	365
50945 32a22fa13b99 Issue 4842, patch 2/2: int('3L') should be invalid in Python 3.x. Mark Dickinson <dickinsm@gmail.com> parents: 50751 diff changeset	366 # trailing L should no longer be accepted...
32a22fa13b99 Issue 4842, patch 2/2: int('3L') should be invalid in Python 3.x. Mark Dickinson <dickinsm@gmail.com> parents: 50751 diff changeset	367 self.assertRaises(ValueError, int, '123L')
32a22fa13b99 Issue 4842, patch 2/2: int('3L') should be invalid in Python 3.x. Mark Dickinson <dickinsm@gmail.com> parents: 50751 diff changeset	368 self.assertRaises(ValueError, int, '123l')
32a22fa13b99 Issue 4842, patch 2/2: int('3L') should be invalid in Python 3.x. Mark Dickinson <dickinsm@gmail.com> parents: 50751 diff changeset	369 self.assertRaises(ValueError, int, '0L')
32a22fa13b99 Issue 4842, patch 2/2: int('3L') should be invalid in Python 3.x. Mark Dickinson <dickinsm@gmail.com> parents: 50751 diff changeset	370 self.assertRaises(ValueError, int, '-37L')
32a22fa13b99 Issue 4842, patch 2/2: int('3L') should be invalid in Python 3.x. Mark Dickinson <dickinsm@gmail.com> parents: 50751 diff changeset	371 self.assertRaises(ValueError, int, '0x32L', 16)
32a22fa13b99 Issue 4842, patch 2/2: int('3L') should be invalid in Python 3.x. Mark Dickinson <dickinsm@gmail.com> parents: 50751 diff changeset	372 self.assertRaises(ValueError, int, '1L', 21)
32a22fa13b99 Issue 4842, patch 2/2: int('3L') should be invalid in Python 3.x. Mark Dickinson <dickinsm@gmail.com> parents: 50751 diff changeset	373 # ... but it's just a normal digit if base >= 22
32a22fa13b99 Issue 4842, patch 2/2: int('3L') should be invalid in Python 3.x. Mark Dickinson <dickinsm@gmail.com> parents: 50751 diff changeset	374 self.assertEqual(int('1L', 22), 43)
32a22fa13b99 Issue 4842, patch 2/2: int('3L') should be invalid in Python 3.x. Mark Dickinson <dickinsm@gmail.com> parents: 50751 diff changeset	375
61937 8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	376 # tests with base 0
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	377 self.assertEqual(int('000', 0), 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	378 self.assertEqual(int('0o123', 0), 83)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	379 self.assertEqual(int('0x123', 0), 291)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	380 self.assertEqual(int('0b100', 0), 4)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	381 self.assertEqual(int(' 0O123 ', 0), 83)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	382 self.assertEqual(int(' 0X123 ', 0), 291)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	383 self.assertEqual(int(' 0B100 ', 0), 4)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	384 self.assertEqual(int('0', 0), 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	385 self.assertEqual(int('+0', 0), 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	386 self.assertEqual(int('-0', 0), 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	387 self.assertEqual(int('00', 0), 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	388 self.assertRaises(ValueError, int, '08', 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	389 self.assertRaises(ValueError, int, '-012395', 0)
46664 031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	390
61940 c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	391 # invalid bases
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	392 invalid_bases = [-909,
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	393 231-1, 231, -231, -231-1,
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	394 263-1, 263, -263, -263-1,
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	395 2100, -2100,
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	396 ]
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	397 for base in invalid_bases:
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	398 self.assertRaises(ValueError, int, '42', base)
46664 031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	399
031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	400
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	401 def test_conversion(self):
9209 d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	402
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	403 class JustLong:
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	404 # test that __long__ no longer used in 3.x
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	405 def __long__(self):
46664 031dfe455585 Merged revisions 62425-62429,62434-62436,62441,62444,62446-62448,62450-62455,62463,62465-62466,62469,62474,62476-62478,62480,62485,62492,62497-62498,62500,62507,62513-62514,62516,62521,62531,62535,62545-62546,62548-62551,62553-62559,62569,62574,62577,62593,62595,62604-62606,62608,62616,62626-62627,62636,62638,62644-62645,62647-62648,62651-62653,62656,62661,62663,62680,62686-62687,62696,62699-62703,62711 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45281 diff changeset	406 return 42
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	407 self.assertRaises(TypeError, int, JustLong())
19458 8f90e1f50c11 SF bug [#454456] int overflow code needs tests. Tim Peters <tim.peters@gmail.com> parents: 19452 diff changeset	408
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	409 class LongTrunc:
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	410 # __long__ should be ignored in 3.x
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	411 def __long__(self):
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	412 return 42
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	413 def __trunc__(self):
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	414 return 1729
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	415 self.assertEqual(int(LongTrunc()), 1729)
19459 50019cb784e0 Add a test for the new // operator too. Tim Peters <tim.peters@gmail.com> parents: 19458 diff changeset	416
73074 117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	417 def check_float_conversion(self, n):
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	418 # Check that int -> float conversion behaviour matches
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	419 # that of the pure Python version above.
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	420 try:
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	421 actual = float(n)
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	422 except OverflowError:
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	423 actual = 'overflow'
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	424
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	425 try:
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	426 expected = int_to_float(n)
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	427 except OverflowError:
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	428 expected = 'overflow'
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	429
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	430 msg = ("Error in conversion of integer {} to float. "
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	431 "Got {}, expected {}.".format(n, actual, expected))
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	432 self.assertEqual(actual, expected, msg)
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	433
66709 f2a4ade36a1e Issue #10624: Use support.requires_IEEE_754 in all appropriate tests. Eric Smith <eric@trueblade.com> parents: 66686 diff changeset	434 @support.requires_IEEE_754
53290 41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	435 def test_float_conversion(self):
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	436
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	437 exact_values = [0, 1, 2,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	438 2**53-3,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	439 2**53-2,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	440 2**53-1,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	441 2**53,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	442 2**53+2,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	443 2**54-4,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	444 2**54-2,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	445 2**54,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	446 2**54+4]
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	447 for x in exact_values:
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	448 self.assertEqual(float(x), x)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	449 self.assertEqual(float(-x), -x)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	450
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	451 # test round-half-even
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	452 for x, y in [(1, 0), (2, 2), (3, 4), (4, 4), (5, 4), (6, 6), (7, 8)]:
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	453 for p in range(15):
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	454 self.assertEqual(int(float(2*p(253+x))), 2p(2*53+y))
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	455
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	456 for x, y in [(0, 0), (1, 0), (2, 0), (3, 4), (4, 4), (5, 4), (6, 8),
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	457 (7, 8), (8, 8), (9, 8), (10, 8), (11, 12), (12, 12),
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	458 (13, 12), (14, 16), (15, 16)]:
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	459 for p in range(15):
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	460 self.assertEqual(int(float(2*p(254+x))), 2p(2*54+y))
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	461
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	462 # behaviour near extremes of floating-point range
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	463 int_dbl_max = int(DBL_MAX)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	464 top_power = 2**DBL_MAX_EXP
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	465 halfway = (int_dbl_max + top_power)//2
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	466 self.assertEqual(float(int_dbl_max), DBL_MAX)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	467 self.assertEqual(float(int_dbl_max+1), DBL_MAX)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	468 self.assertEqual(float(halfway-1), DBL_MAX)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	469 self.assertRaises(OverflowError, float, halfway)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	470 self.assertEqual(float(1-halfway), -DBL_MAX)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	471 self.assertRaises(OverflowError, float, -halfway)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	472 self.assertRaises(OverflowError, float, top_power-1)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	473 self.assertRaises(OverflowError, float, top_power)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	474 self.assertRaises(OverflowError, float, top_power+1)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	475 self.assertRaises(OverflowError, float, 2*top_power-1)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	476 self.assertRaises(OverflowError, float, 2*top_power)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	477 self.assertRaises(OverflowError, float, top_power*top_power)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	478
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	479 for p in range(100):
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	480 x = 2*p (2**53 + 1) + 1
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	481 y = 2*p (2**53 + 2)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	482 self.assertEqual(int(float(x)), y)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	483
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	484 x = 2*p (2**53 + 1)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	485 y = 2*p 2**53
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	486 self.assertEqual(int(float(x)), y)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	487
73074 117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	488 # Compare builtin float conversion with pure Python int_to_float
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	489 # function above.
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	490 test_values = [
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	491 int_dbl_max-1, int_dbl_max, int_dbl_max+1,
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	492 halfway-1, halfway, halfway + 1,
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	493 top_power-1, top_power, top_power+1,
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	494 2top_power-1, 2top_power, top_power*top_power,
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	495 ]
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	496 test_values.extend(exact_values)
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	497 for p in range(-4, 8):
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	498 for x in range(-128, 128):
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	499 test_values.append(2**(p+53) + x)
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	500 for value in test_values:
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	501 self.check_float_conversion(value)
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	502 self.check_float_conversion(-value)
117d51d3dd7d Issue #10925: Add equivalent pure Python code for the builtin int-to-float conversion to test_long. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	503
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	504 def test_float_overflow(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	505 for x in -2.0, -1.0, 0.0, 1.0, 2.0:
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	506 self.assertEqual(float(int(x)), x)
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	507
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	508 shuge = '12345' * 120
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	509 huge = 1 << 30000
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	510 mhuge = -huge
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	511 namespace = {'huge': huge, 'mhuge': mhuge, 'shuge': shuge, 'math': math}
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	512 for test in ["float(huge)", "float(mhuge)",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	513 "complex(huge)", "complex(mhuge)",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	514 "complex(huge, 1)", "complex(mhuge, 1)",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	515 "complex(1, huge)", "complex(1, mhuge)",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	516 "1. + huge", "huge + 1.", "1. + mhuge", "mhuge + 1.",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	517 "1. - huge", "huge - 1.", "1. - mhuge", "mhuge - 1.",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	518 "1. * huge", "huge * 1.", "1. * mhuge", "mhuge * 1.",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	519 "1. // huge", "huge // 1.", "1. // mhuge", "mhuge // 1.",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	520 "1. / huge", "huge / 1.", "1. / mhuge", "mhuge / 1.",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	521 "1. huge", "huge 1.", "1. mhuge", "mhuge 1.",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	522 "math.sin(huge)", "math.sin(mhuge)",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	523 "math.sqrt(huge)", "math.sqrt(mhuge)", # should do better
42762 83c8448c6de4 math.floor(<int>) now returns the argument, Guido van Rossum <guido@python.org> parents: 42142 diff changeset	524 # math.floor() of an int returns an int now
83c8448c6de4 math.floor(<int>) now returns the argument, Guido van Rossum <guido@python.org> parents: 42142 diff changeset	525 ##"math.floor(huge)", "math.floor(mhuge)",
83c8448c6de4 math.floor(<int>) now returns the argument, Guido van Rossum <guido@python.org> parents: 42142 diff changeset	526 ]:
19679 6958784b1cef Whitespace normalization. Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	527
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	528 self.assertRaises(OverflowError, eval, test, namespace)
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19698 diff changeset	529
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	530 # XXX Perhaps float(shuge) can raise OverflowError on some box?
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	531 # The comparison should not.
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	532 self.assertNotEqual(float(shuge), int(shuge),
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	533 "float(shuge) should not equal int(shuge)")
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19698 diff changeset	534
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	535 def test_logs(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	536 LOG10E = math.log10(math.e)
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19698 diff changeset	537
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	538 for exp in list(range(10)) + [100, 1000, 10000]:
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	539 value = 10 ** exp
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	540 log10 = math.log10(value)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	541 self.assertAlmostEqual(log10, exp)
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19698 diff changeset	542
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	543 # log10(value) == exp, so log(value) == log10(value)/log10(e) ==
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	544 # exp/LOG10E
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	545 expected = exp / LOG10E
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	546 log = math.log(value)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	547 self.assertAlmostEqual(log, expected)
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19698 diff changeset	548
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	549 for bad in -(1 << 10000), -2, 0:
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	550 self.assertRaises(ValueError, math.log, bad)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	551 self.assertRaises(ValueError, math.log10, bad)
19713 9433dd3c197e Return reasonable results for math.log(long) and math.log10(long) (we were Tim Peters <tim.peters@gmail.com> parents: 19698 diff changeset	552
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	553 def test_mixed_compares(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	554 eq = self.assertEqual
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	555
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	556 # We're mostly concerned with that mixing floats and longs does the
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	557 # right stuff, even when longs are too large to fit in a float.
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	558 # The safest way to check the results is to use an entirely different
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	559 # method, which we do here via a skeletal rational class (which
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	560 # represents all Python ints, longs and floats exactly).
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	561 class Rat:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	562 def __init__(self, value):
41592 1e5a2a2b18ee Fix various spots where int/long and str/unicode unification Walter Dörwald <walter@livinglogic.de> parents: 40644 diff changeset	563 if isinstance(value, int):
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	564 self.n = value
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	565 self.d = 1
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	566 elif isinstance(value, float):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	567 # Convert to exact rational equivalent.
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	568 f, e = math.frexp(abs(value))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	569 assert f == 0 or 0.5 <= f < 1.0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	570 # \|value\| = f * 2**e exactly
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	571
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	572 # Suck up CHUNK bits at a time; 28 is enough so that we suck
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	573 # up all bits in 2 iterations for all known binary double-
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	574 # precision formats, and small enough to fit in an int.
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	575 CHUNK = 28
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	576 top = 0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	577 # invariant: \|value\| = (top + f) * 2**e exactly
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	578 while f:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	579 f = math.ldexp(f, CHUNK)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	580 digit = int(f)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	581 assert digit >> CHUNK == 0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	582 top = (top << CHUNK) \| digit
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	583 f -= digit
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	584 assert 0.0 <= f < 1.0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	585 e -= CHUNK
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	586
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	587 # Now \|value\| = top * 2**e exactly.
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	588 if e >= 0:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	589 n = top << e
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	590 d = 1
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	591 else:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	592 n = top
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	593 d = 1 << -e
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	594 if value < 0:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	595 n = -n
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	596 self.n = n
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	597 self.d = d
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	598 assert float(n) / float(d) == value
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	599 else:
59613 77c71f258df7 Merged revisions 78018,78035-78040,78042-78043,78046,78048-78052,78054,78059,78075-78080 via svnmerge from Georg Brandl <georg@python.org> parents: 58223 diff changeset	600 raise TypeError("can't deal with %r" % value)
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	601
49518 d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	602 def _cmp__(self, other):
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	603 if not isinstance(other, Rat):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	604 other = Rat(other)
51121 74aa43dd875d Issue #1717: Remove cmp. Stage 1: remove all uses of cmp and __cmp__ from Mark Dickinson <dickinsm@gmail.com> parents: 50945 diff changeset	605 x, y = self.n * other.d, self.d * other.n
74aa43dd875d Issue #1717: Remove cmp. Stage 1: remove all uses of cmp and __cmp__ from Mark Dickinson <dickinsm@gmail.com> parents: 50945 diff changeset	606 return (x > y) - (x < y)
49518 d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	607 def __eq__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	608 return self._cmp__(other) == 0
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	609 def __ne__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	610 return self._cmp__(other) != 0
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	611 def __ge__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	612 return self._cmp__(other) >= 0
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	613 def __gt__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	614 return self._cmp__(other) > 0
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	615 def __le__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	616 return self._cmp__(other) <= 0
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	617 def __lt__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	618 return self._cmp__(other) < 0
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	619
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	620 cases = [0, 0.001, 0.99, 1.0, 1.5, 1e20, 1e200]
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	621 # 248 is an important boundary in the internals. 253 is an
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	622 # important boundary for IEEE double precision.
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	623 for t in 2.048, 2.050, 2.0**53:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	624 cases.extend([t - 1.0, t - 0.3, t, t + 0.3, t + 1.0,
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	625 int(t-1), int(t), int(t+1)])
44160 9d152530910a Removed PyInt_GetMax and sys.maxint Christian Heimes <christian@cheimes.de> parents: 43100 diff changeset	626 cases.extend([0, 1, 2, sys.maxsize, float(sys.maxsize)])
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	627 # 1 << 20000 should exceed all double formats. int(1e200) is to
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	628 # check that we get equality with 1e200 above.
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	629 t = int(1e200)
1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	630 cases.extend([0, 1, 2, 1 << 20000, t-1, t, t+1])
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	631 cases.extend([-x for x in cases])
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	632 for x in cases:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	633 Rx = Rat(x)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	634 for y in cases:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	635 Ry = Rat(y)
51121 74aa43dd875d Issue #1717: Remove cmp. Stage 1: remove all uses of cmp and __cmp__ from Mark Dickinson <dickinsm@gmail.com> parents: 50945 diff changeset	636 Rcmp = (Rx > Ry) - (Rx < Ry)
74aa43dd875d Issue #1717: Remove cmp. Stage 1: remove all uses of cmp and __cmp__ from Mark Dickinson <dickinsm@gmail.com> parents: 50945 diff changeset	637 xycmp = (x > y) - (x < y)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	638 eq(Rcmp, xycmp, Frm("%r %r %d %d", x, y, Rcmp, xycmp))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	639 eq(x == y, Rcmp == 0, Frm("%r == %r %d", x, y, Rcmp))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	640 eq(x != y, Rcmp != 0, Frm("%r != %r %d", x, y, Rcmp))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	641 eq(x < y, Rcmp < 0, Frm("%r < %r %d", x, y, Rcmp))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	642 eq(x <= y, Rcmp <= 0, Frm("%r <= %r %d", x, y, Rcmp))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	643 eq(x > y, Rcmp > 0, Frm("%r > %r %d", x, y, Rcmp))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	644 eq(x >= y, Rcmp >= 0, Frm("%r >= %r %d", x, y, Rcmp))
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	645
45281 4565c69420b8 Renamed test_format to test__format__, since it really tests the __format__ method. It was hiding another method of the same name. Eric Smith <eric@trueblade.com> parents: 45032 diff changeset	646 def test__format__(self):
42817 5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	647 self.assertEqual(format(123456789, 'd'), '123456789')
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	648 self.assertEqual(format(123456789, 'd'), '123456789')
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	649
43097 a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	650 # sign and aligning are interdependent
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	651 self.assertEqual(format(1, "-"), '1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	652 self.assertEqual(format(-1, "-"), '-1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	653 self.assertEqual(format(1, "-3"), ' 1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	654 self.assertEqual(format(-1, "-3"), ' -1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	655 self.assertEqual(format(1, "+3"), ' +1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	656 self.assertEqual(format(-1, "+3"), ' -1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	657 self.assertEqual(format(1, " 3"), ' 1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	658 self.assertEqual(format(-1, " 3"), ' -1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	659 self.assertEqual(format(1, " "), ' 1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	660 self.assertEqual(format(-1, " "), '-1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	661
42817 5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	662 # hex
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	663 self.assertEqual(format(3, "x"), "3")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	664 self.assertEqual(format(3, "X"), "3")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	665 self.assertEqual(format(1234, "x"), "4d2")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	666 self.assertEqual(format(-1234, "x"), "-4d2")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	667 self.assertEqual(format(1234, "8x"), " 4d2")
43097 a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	668 self.assertEqual(format(-1234, "8x"), " -4d2")
42817 5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	669 self.assertEqual(format(1234, "x"), "4d2")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	670 self.assertEqual(format(-1234, "x"), "-4d2")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	671 self.assertEqual(format(-3, "x"), "-3")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	672 self.assertEqual(format(-3, "X"), "-3")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	673 self.assertEqual(format(int('be', 16), "x"), "be")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	674 self.assertEqual(format(int('be', 16), "X"), "BE")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	675 self.assertEqual(format(-int('be', 16), "x"), "-be")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	676 self.assertEqual(format(-int('be', 16), "X"), "-BE")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	677
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	678 # octal
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	679 self.assertEqual(format(3, "b"), "11")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	680 self.assertEqual(format(-3, "b"), "-11")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	681 self.assertEqual(format(1234, "b"), "10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	682 self.assertEqual(format(-1234, "b"), "-10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	683 self.assertEqual(format(1234, "-b"), "10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	684 self.assertEqual(format(-1234, "-b"), "-10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	685 self.assertEqual(format(1234, " b"), " 10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	686 self.assertEqual(format(-1234, " b"), "-10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	687 self.assertEqual(format(1234, "+b"), "+10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	688 self.assertEqual(format(-1234, "+b"), "-10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	689
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	690 # make sure these are errors
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	691 self.assertRaises(ValueError, format, 3, "1.3") # precision disallowed
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	692 self.assertRaises(ValueError, format, 3, "+c") # sign not allowed
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	693 # with 'c'
45032 a28d0b14b77d Partially revert r60376: restore ability for ints to be automatically converted to floats, if a float type specifier is given to an int. PEP 3101 should be clarified on this point.Also, remove unused local variables left over from r60376. Eric Smith <eric@trueblade.com> parents: 45023 diff changeset	694
a28d0b14b77d Partially revert r60376: restore ability for ints to be automatically converted to floats, if a float type specifier is given to an int. PEP 3101 should be clarified on this point.Also, remove unused local variables left over from r60376. Eric Smith <eric@trueblade.com> parents: 45023 diff changeset	695 # ensure that only int and float type specifiers work
45023 727cc810d690 Restrict format presentation types to those specified in the 'Standard Format Specifiers' section of PEP 3101. Eric Smith <eric@trueblade.com> parents: 44683 diff changeset	696 for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
727cc810d690 Restrict format presentation types to those specified in the 'Standard Format Specifiers' section of PEP 3101. Eric Smith <eric@trueblade.com> parents: 44683 diff changeset	697 [chr(x) for x in range(ord('A'), ord('Z')+1)]):
45032 a28d0b14b77d Partially revert r60376: restore ability for ints to be automatically converted to floats, if a float type specifier is given to an int. PEP 3101 should be clarified on this point.Also, remove unused local variables left over from r60376. Eric Smith <eric@trueblade.com> parents: 45023 diff changeset	698 if not format_spec in 'bcdoxXeEfFgGn%':
45023 727cc810d690 Restrict format presentation types to those specified in the 'Standard Format Specifiers' section of PEP 3101. Eric Smith <eric@trueblade.com> parents: 44683 diff changeset	699 self.assertRaises(ValueError, format, 0, format_spec)
727cc810d690 Restrict format presentation types to those specified in the 'Standard Format Specifiers' section of PEP 3101. Eric Smith <eric@trueblade.com> parents: 44683 diff changeset	700 self.assertRaises(ValueError, format, 1, format_spec)
727cc810d690 Restrict format presentation types to those specified in the 'Standard Format Specifiers' section of PEP 3101. Eric Smith <eric@trueblade.com> parents: 44683 diff changeset	701 self.assertRaises(ValueError, format, -1, format_spec)
727cc810d690 Restrict format presentation types to those specified in the 'Standard Format Specifiers' section of PEP 3101. Eric Smith <eric@trueblade.com> parents: 44683 diff changeset	702 self.assertRaises(ValueError, format, 2**100, format_spec)
727cc810d690 Restrict format presentation types to those specified in the 'Standard Format Specifiers' section of PEP 3101. Eric Smith <eric@trueblade.com> parents: 44683 diff changeset	703 self.assertRaises(ValueError, format, -(2**100), format_spec)
727cc810d690 Restrict format presentation types to those specified in the 'Standard Format Specifiers' section of PEP 3101. Eric Smith <eric@trueblade.com> parents: 44683 diff changeset	704
45032 a28d0b14b77d Partially revert r60376: restore ability for ints to be automatically converted to floats, if a float type specifier is given to an int. PEP 3101 should be clarified on this point.Also, remove unused local variables left over from r60376. Eric Smith <eric@trueblade.com> parents: 45023 diff changeset	705 # ensure that float type specifiers work; format converts
a28d0b14b77d Partially revert r60376: restore ability for ints to be automatically converted to floats, if a float type specifier is given to an int. PEP 3101 should be clarified on this point.Also, remove unused local variables left over from r60376. Eric Smith <eric@trueblade.com> parents: 45023 diff changeset	706 # the int to a float
46909 ef4ec968fdb6 Merged revisions 63078 via svnmerge from Eric Smith <eric@trueblade.com> parents: 46664 diff changeset	707 for format_spec in 'eEfFgG%':
45032 a28d0b14b77d Partially revert r60376: restore ability for ints to be automatically converted to floats, if a float type specifier is given to an int. PEP 3101 should be clarified on this point.Also, remove unused local variables left over from r60376. Eric Smith <eric@trueblade.com> parents: 45023 diff changeset	708 for value in [0, 1, -1, 100, -100, 1234567890, -1234567890]:
a28d0b14b77d Partially revert r60376: restore ability for ints to be automatically converted to floats, if a float type specifier is given to an int. PEP 3101 should be clarified on this point.Also, remove unused local variables left over from r60376. Eric Smith <eric@trueblade.com> parents: 45023 diff changeset	709 self.assertEqual(format(value, format_spec),
a28d0b14b77d Partially revert r60376: restore ability for ints to be automatically converted to floats, if a float type specifier is given to an int. PEP 3101 should be clarified on this point.Also, remove unused local variables left over from r60376. Eric Smith <eric@trueblade.com> parents: 45023 diff changeset	710 format(float(value), format_spec))
42817 5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	711
44460 13aabc23cf2e Merged revisions 59680-59695 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44160 diff changeset	712 def test_nan_inf(self):
44463 d2c1ba099290 Fixed test_long Christian Heimes <christian@cheimes.de> parents: 44460 diff changeset	713 self.assertRaises(OverflowError, int, float('inf'))
48680 7779af388aec Merged revisions 65459,65472,65481,65518,65536,65581,65609,65637,65641,65644-65645 via svnmerge from Georg Brandl <georg@python.org> parents: 48567 diff changeset	714 self.assertRaises(OverflowError, int, float('-inf'))
7779af388aec Merged revisions 65459,65472,65481,65518,65536,65581,65609,65637,65641,65644-65645 via svnmerge from Georg Brandl <georg@python.org> parents: 48567 diff changeset	715 self.assertRaises(ValueError, int, float('nan'))
44460 13aabc23cf2e Merged revisions 59680-59695 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44160 diff changeset	716
48458 e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	717 def test_true_division(self):
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	718 huge = 1 << 40000
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	719 mhuge = -huge
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	720 self.assertEqual(huge / huge, 1.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	721 self.assertEqual(mhuge / mhuge, 1.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	722 self.assertEqual(huge / mhuge, -1.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	723 self.assertEqual(mhuge / huge, -1.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	724 self.assertEqual(1 / huge, 0.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	725 self.assertEqual(1 / huge, 0.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	726 self.assertEqual(1 / mhuge, 0.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	727 self.assertEqual(1 / mhuge, 0.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	728 self.assertEqual((666 * huge + (huge >> 1)) / huge, 666.5)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	729 self.assertEqual((666 * mhuge + (mhuge >> 1)) / mhuge, 666.5)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	730 self.assertEqual((666 * huge + (huge >> 1)) / mhuge, -666.5)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	731 self.assertEqual((666 * mhuge + (mhuge >> 1)) / huge, -666.5)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	732 self.assertEqual(huge / (huge << 1), 0.5)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	733 self.assertEqual((1000000 * huge) / huge, 1000000)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	734
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	735 namespace = {'huge': huge, 'mhuge': mhuge}
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	736
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	737 for overflow in ["float(huge)", "float(mhuge)",
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	738 "huge / 1", "huge / 2", "huge / -1", "huge / -2",
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	739 "mhuge / 100", "mhuge / 200"]:
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	740 self.assertRaises(OverflowError, eval, overflow, namespace)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	741
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	742 for underflow in ["1 / huge", "2 / huge", "-1 / huge", "-2 / huge",
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	743 "100 / mhuge", "200 / mhuge"]:
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	744 result = eval(underflow, namespace)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	745 self.assertEqual(result, 0.0,
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	746 "expected underflow to 0 from %r" % underflow)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	747
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	748 for zero in ["huge / 0", "mhuge / 0"]:
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	749 self.assertRaises(ZeroDivisionError, eval, zero, namespace)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	750
57942 aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	751 def check_truediv(self, a, b, skip_small=True):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	752 """Verify that the result of a/b is correctly rounded, by
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	753 comparing it with a pure Python implementation of correctly
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	754 rounded division. b should be nonzero."""
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	755
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	756 # skip check for small a and b: in this case, the current
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	757 # implementation converts the arguments to float directly and
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	758 # then applies a float division. This can give doubly-rounded
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	759 # results on x87-using machines (particularly 32-bit Linux).
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	760 if skip_small and max(abs(a), abs(b)) < 2**DBL_MANT_DIG:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	761 return
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	762
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	763 try:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	764 # use repr so that we can distinguish between -0.0 and 0.0
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	765 expected = repr(truediv(a, b))
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	766 except OverflowError:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	767 expected = 'overflow'
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	768 except ZeroDivisionError:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	769 expected = 'zerodivision'
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	770
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	771 try:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	772 got = repr(a / b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	773 except OverflowError:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	774 got = 'overflow'
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	775 except ZeroDivisionError:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	776 got = 'zerodivision'
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	777
57951 73365bb26fd6 Merged revisions 77071 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57946 diff changeset	778 self.assertEqual(expected, got, "Incorrectly rounded division {}/{}: "
73365bb26fd6 Merged revisions 77071 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57946 diff changeset	779 "expected {}, got {}".format(a, b, expected, got))
57942 aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	780
66709 f2a4ade36a1e Issue #10624: Use support.requires_IEEE_754 in all appropriate tests. Eric Smith <eric@trueblade.com> parents: 66686 diff changeset	781 @support.requires_IEEE_754
57942 aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	782 def test_correctly_rounded_true_division(self):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	783 # more stringent tests than those above, checking that the
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	784 # result of true division of ints is always correctly rounded.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	785 # This test should probably be considered CPython-specific.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	786
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	787 # Exercise all the code paths not involving Gb-sized ints.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	788 # ... divisions involving zero
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	789 self.check_truediv(123, 0)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	790 self.check_truediv(-456, 0)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	791 self.check_truediv(0, 3)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	792 self.check_truediv(0, -3)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	793 self.check_truediv(0, 0)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	794 # ... overflow or underflow by large margin
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	795 self.check_truediv(671 * 12345 * 2**DBL_MAX_EXP, 12345)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	796 self.check_truediv(12345, 345678 * 2**(DBL_MANT_DIG - DBL_MIN_EXP))
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	797 # ... a much larger or smaller than b
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	798 self.check_truediv(123452*100, 98765)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	799 self.check_truediv(12345230, 987657**81)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	800 # ... a / b near a boundary: one of 1, 2DBL_MANT_DIG, 2DBL_MIN_EXP,
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	801 # 2DBL_MAX_EXP, 2(DBL_MIN_EXP-DBL_MANT_DIG)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	802 bases = (0, DBL_MANT_DIG, DBL_MIN_EXP,
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	803 DBL_MAX_EXP, DBL_MIN_EXP - DBL_MANT_DIG)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	804 for base in bases:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	805 for exp in range(base - 15, base + 15):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	806 self.check_truediv(753122max(exp, 0), 691872**max(-exp, 0))
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	807 self.check_truediv(691872max(exp, 0), 753122**max(-exp, 0))
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	808
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	809 # overflow corner case
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	810 for m in [1, 2, 7, 17, 12345, 7**100,
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	811 -1, -2, -5, -23, -67891, -41**50]:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	812 for n in range(-10, 10):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	813 self.check_truediv(m*DBL_MIN_OVERFLOW + n, m)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	814 self.check_truediv(m*DBL_MIN_OVERFLOW + n, -m)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	815
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	816 # check detection of inexactness in shifting stage
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	817 for n in range(250):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	818 # (2DBL_MANT_DIG+1)/(2DBL_MANT_DIG) lies halfway
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	819 # between two representable floats, and would usually be
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	820 # rounded down under round-half-to-even. The tiniest of
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	821 # additions to the numerator should cause it to be rounded
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	822 # up instead.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	823 self.check_truediv((2*DBL_MANT_DIG + 1)123452200 + 2*n,
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	824 2*DBL_MANT_DIG12345)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	825
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	826 # 1/2731 is one of the smallest division cases that's subject
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	827 # to double rounding on IEEE 754 machines working internally with
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	828 # 64-bit precision. On such machines, the next check would fail,
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	829 # were it not explicitly skipped in check_truediv.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	830 self.check_truediv(1, 2731)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	831
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	832 # a particularly bad case for the old algorithm: gives an
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	833 # error of close to 3.5 ulps.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	834 self.check_truediv(295147931372582273023, 295147932265116303360)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	835 for i in range(1000):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	836 self.check_truediv(10(i+1), 10i)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	837 self.check_truediv(10i, 10(i+1))
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	838
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	839 # test round-half-to-even behaviour, normal result
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	840 for m in [1, 2, 4, 7, 8, 16, 17, 32, 12345, 7**100,
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	841 -1, -2, -5, -23, -67891, -41**50]:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	842 for n in range(-10, 10):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	843 self.check_truediv(2*DBL_MANT_DIGm + n, m)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	844
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	845 # test round-half-to-even, subnormal result
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	846 for n in range(-20, 20):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	847 self.check_truediv(n, 2**1076)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	848
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	849 # largeish random divisions: a/b where \|a\| <= \|b\| <=
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	850 # 2*\|a\|; \|ans\| is between 0.5 and 1.0, so error should
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	851 # always be bounded by 2**-54 with equality possible only
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	852 # if the least significant bit of q=ans2*53 is zero.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	853 for M in [1010, 10100, 10**1000]:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	854 for i in range(1000):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	855 a = random.randrange(1, M)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	856 b = random.randrange(a, 2*a+1)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	857 self.check_truediv(a, b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	858 self.check_truediv(-a, b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	859 self.check_truediv(a, -b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	860 self.check_truediv(-a, -b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	861
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	862 # and some (genuinely) random tests
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	863 for _ in range(10000):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	864 a_bits = random.randrange(1000)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	865 b_bits = random.randrange(1, 1000)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	866 x = random.randrange(2**a_bits)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	867 y = random.randrange(1, 2**b_bits)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	868 self.check_truediv(x, y)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	869 self.check_truediv(x, -y)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	870 self.check_truediv(-x, y)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	871 self.check_truediv(-x, -y)
48458 e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	872
48567 1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	873 def test_small_ints(self):
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	874 for i in range(-5, 257):
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	875 self.assertTrue(i is i + 0)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	876 self.assertTrue(i is i * 1)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	877 self.assertTrue(i is i - 0)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	878 self.assertTrue(i is i // 1)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	879 self.assertTrue(i is i & -1)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	880 self.assertTrue(i is i \| 0)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	881 self.assertTrue(i is i ^ 0)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	882 self.assertTrue(i is ~~i)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	883 self.assertTrue(i is i**1)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	884 self.assertTrue(i is int(str(i)))
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	885 self.assertTrue(i is i<<2>>2, str(i))
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	886 # corner cases
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	887 i = 1 << 70
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	888 self.assertTrue(i - i is 0)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	889 self.assertTrue(0 * i is 0)
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	890
50207 92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	891 def test_bit_length(self):
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	892 tiny = 1e-10
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	893 for x in range(-65000, 65000):
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	894 k = x.bit_length()
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	895 # Check equivalence with Python version
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	896 self.assertEqual(k, len(bin(x).lstrip('-0b')))
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	897 # Behaviour as specified in the docs
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	898 if x != 0:
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	899 self.assertTrue(2(k-1) <= abs(x) < 2k)
50207 92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	900 else:
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	901 self.assertEqual(k, 0)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	902 # Alternative definition: x.bit_length() == 1 + floor(log_2(x))
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	903 if x != 0:
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	904 # When x is an exact power of 2, numeric errors can
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	905 # cause floor(log(x)/log(2)) to be one too small; for
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	906 # small x this can be fixed by adding a small quantity
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	907 # to the quotient before taking the floor.
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	908 self.assertEqual(k, 1 + math.floor(
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	909 math.log(abs(x))/math.log(2) + tiny))
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	910
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	911 self.assertEqual((0).bit_length(), 0)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	912 self.assertEqual((1).bit_length(), 1)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	913 self.assertEqual((-1).bit_length(), 1)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	914 self.assertEqual((2).bit_length(), 2)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	915 self.assertEqual((-2).bit_length(), 2)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	916 for i in [2, 3, 15, 16, 17, 31, 32, 33, 63, 64, 234]:
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	917 a = 2**i
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	918 self.assertEqual((a-1).bit_length(), i)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	919 self.assertEqual((1-a).bit_length(), i)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	920 self.assertEqual((a).bit_length(), i+1)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	921 self.assertEqual((-a).bit_length(), i+1)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	922 self.assertEqual((a+1).bit_length(), i+1)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	923 self.assertEqual((-a-1).bit_length(), i+1)
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	924
51145 9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	925 def test_round(self):
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	926 # check round-half-even algorithm. For round to nearest ten;
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	927 # rounding map is invariant under adding multiples of 20
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	928 test_dict = {0:0, 1:0, 2:0, 3:0, 4:0, 5:0,
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	929 6:10, 7:10, 8:10, 9:10, 10:10, 11:10, 12:10, 13:10, 14:10,
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	930 15:20, 16:20, 17:20, 18:20, 19:20}
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	931 for offset in range(-520, 520, 20):
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	932 for k, v in test_dict.items():
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	933 got = round(k+offset, -1)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	934 expected = v+offset
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	935 self.assertEqual(got, expected)
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	936 self.assertTrue(type(got) is int)
51145 9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	937
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	938 # larger second argument
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	939 self.assertEqual(round(-150, -2), -200)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	940 self.assertEqual(round(-149, -2), -100)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	941 self.assertEqual(round(-51, -2), -100)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	942 self.assertEqual(round(-50, -2), 0)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	943 self.assertEqual(round(-49, -2), 0)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	944 self.assertEqual(round(-1, -2), 0)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	945 self.assertEqual(round(0, -2), 0)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	946 self.assertEqual(round(1, -2), 0)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	947 self.assertEqual(round(49, -2), 0)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	948 self.assertEqual(round(50, -2), 0)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	949 self.assertEqual(round(51, -2), 100)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	950 self.assertEqual(round(149, -2), 100)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	951 self.assertEqual(round(150, -2), 200)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	952 self.assertEqual(round(250, -2), 200)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	953 self.assertEqual(round(251, -2), 300)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	954 self.assertEqual(round(172500, -3), 172000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	955 self.assertEqual(round(173500, -3), 174000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	956 self.assertEqual(round(31415926535, -1), 31415926540)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	957 self.assertEqual(round(31415926535, -2), 31415926500)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	958 self.assertEqual(round(31415926535, -3), 31415927000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	959 self.assertEqual(round(31415926535, -4), 31415930000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	960 self.assertEqual(round(31415926535, -5), 31415900000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	961 self.assertEqual(round(31415926535, -6), 31416000000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	962 self.assertEqual(round(31415926535, -7), 31420000000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	963 self.assertEqual(round(31415926535, -8), 31400000000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	964 self.assertEqual(round(31415926535, -9), 31000000000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	965 self.assertEqual(round(31415926535, -10), 30000000000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	966 self.assertEqual(round(31415926535, -11), 0)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	967 self.assertEqual(round(31415926535, -12), 0)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	968 self.assertEqual(round(31415926535, -999), 0)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	969
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	970 # should get correct results even for huge inputs
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	971 for k in range(10, 100):
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	972 got = round(10**k + 324678, -3)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	973 expect = 10**k + 325000
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	974 self.assertEqual(got, expect)
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	975 self.assertTrue(type(got) is int)
51145 9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	976
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	977 # nonnegative second argument: round(x, n) should just return x
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	978 for n in range(5):
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	979 for i in range(100):
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	980 x = random.randrange(-10000, 10000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	981 got = round(x, n)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	982 self.assertEqual(got, x)
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	983 self.assertTrue(type(got) is int)
51145 9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	984 for huge_n in 231-1, 231, 263-1, 263, 2100, 10100:
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	985 self.assertEqual(round(8979323, huge_n), 8979323)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	986
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	987 # omitted second argument
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	988 for i in range(100):
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	989 x = random.randrange(-10000, 10000)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	990 got = round(x)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	991 self.assertEqual(got, x)
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	992 self.assertTrue(type(got) is int)
51145 9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	993
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	994 # bad second argument
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	995 bad_exponents = ('brian', 2.0, 0j, None)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	996 for e in bad_exponents:
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	997 self.assertRaises(TypeError, round, 3, e)
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	998
58223 f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	999 def test_to_bytes(self):
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1000 def check(tests, byteorder, signed=False):
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1001 for test, expected in tests.items():
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1002 try:
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1003 self.assertEqual(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1004 test.to_bytes(len(expected), byteorder, signed=signed),
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1005 expected)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1006 except Exception as err:
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1007 raise AssertionError(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1008 "failed to convert {0} with byteorder={1} and signed={2}"
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1009 .format(test, byteorder, signed)) from err
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1010
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1011 # Convert integers to signed big-endian byte arrays.
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1012 tests1 = {
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1013 0: b'\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1014 1: b'\x01',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1015 -1: b'\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1016 -127: b'\x81',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1017 -128: b'\x80',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1018 -129: b'\xff\x7f',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1019 127: b'\x7f',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1020 129: b'\x00\x81',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1021 -255: b'\xff\x01',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1022 -256: b'\xff\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1023 255: b'\x00\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1024 256: b'\x01\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1025 32767: b'\x7f\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1026 -32768: b'\xff\x80\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1027 65535: b'\x00\xff\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1028 -65536: b'\xff\x00\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1029 -8388608: b'\x80\x00\x00'
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1030 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1031 check(tests1, 'big', signed=True)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1032
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1033 # Convert integers to signed little-endian byte arrays.
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1034 tests2 = {
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1035 0: b'\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1036 1: b'\x01',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1037 -1: b'\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1038 -127: b'\x81',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1039 -128: b'\x80',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1040 -129: b'\x7f\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1041 127: b'\x7f',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1042 129: b'\x81\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1043 -255: b'\x01\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1044 -256: b'\x00\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1045 255: b'\xff\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1046 256: b'\x00\x01',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1047 32767: b'\xff\x7f',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1048 -32768: b'\x00\x80',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1049 65535: b'\xff\xff\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1050 -65536: b'\x00\x00\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1051 -8388608: b'\x00\x00\x80'
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1052 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1053 check(tests2, 'little', signed=True)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1054
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1055 # Convert integers to unsigned big-endian byte arrays.
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1056 tests3 = {
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1057 0: b'\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1058 1: b'\x01',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1059 127: b'\x7f',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1060 128: b'\x80',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1061 255: b'\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1062 256: b'\x01\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1063 32767: b'\x7f\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1064 32768: b'\x80\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1065 65535: b'\xff\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1066 65536: b'\x01\x00\x00'
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1067 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1068 check(tests3, 'big', signed=False)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1069
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1070 # Convert integers to unsigned little-endian byte arrays.
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1071 tests4 = {
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1072 0: b'\x00',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1073 1: b'\x01',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1074 127: b'\x7f',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1075 128: b'\x80',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1076 255: b'\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1077 256: b'\x00\x01',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1078 32767: b'\xff\x7f',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1079 32768: b'\x00\x80',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1080 65535: b'\xff\xff',
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1081 65536: b'\x00\x00\x01'
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1082 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1083 check(tests4, 'little', signed=False)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1084
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1085 self.assertRaises(OverflowError, (256).to_bytes, 1, 'big', signed=False)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1086 self.assertRaises(OverflowError, (256).to_bytes, 1, 'big', signed=True)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1087 self.assertRaises(OverflowError, (256).to_bytes, 1, 'little', signed=False)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1088 self.assertRaises(OverflowError, (256).to_bytes, 1, 'little', signed=True)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1089 self.assertRaises(OverflowError, (-1).to_bytes, 2, 'big', signed=False),
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1090 self.assertRaises(OverflowError, (-1).to_bytes, 2, 'little', signed=False)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1091 self.assertEqual((0).to_bytes(0, 'big'), b'')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1092 self.assertEqual((1).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x01')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1093 self.assertEqual((0).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x00')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1094 self.assertEqual((-1).to_bytes(5, 'big', signed=True),
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1095 b'\xff\xff\xff\xff\xff')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1096 self.assertRaises(OverflowError, (1).to_bytes, 0, 'big')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1097
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1098 def test_from_bytes(self):
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1099 def check(tests, byteorder, signed=False):
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1100 for test, expected in tests.items():
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1101 try:
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1102 self.assertEqual(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1103 int.from_bytes(test, byteorder, signed=signed),
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1104 expected)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1105 except Exception as err:
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1106 raise AssertionError(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1107 "failed to convert {0} with byteorder={1!r} and signed={2}"
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1108 .format(test, byteorder, signed)) from err
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1109
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1110 # Convert signed big-endian byte arrays to integers.
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1111 tests1 = {
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1112 b'': 0,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1113 b'\x00': 0,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1114 b'\x00\x00': 0,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1115 b'\x01': 1,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1116 b'\x00\x01': 1,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1117 b'\xff': -1,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1118 b'\xff\xff': -1,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1119 b'\x81': -127,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1120 b'\x80': -128,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1121 b'\xff\x7f': -129,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1122 b'\x7f': 127,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1123 b'\x00\x81': 129,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1124 b'\xff\x01': -255,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1125 b'\xff\x00': -256,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1126 b'\x00\xff': 255,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1127 b'\x01\x00': 256,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1128 b'\x7f\xff': 32767,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1129 b'\x80\x00': -32768,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1130 b'\x00\xff\xff': 65535,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1131 b'\xff\x00\x00': -65536,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1132 b'\x80\x00\x00': -8388608
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1133 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1134 check(tests1, 'big', signed=True)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1135
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1136 # Convert signed little-endian byte arrays to integers.
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1137 tests2 = {
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1138 b'': 0,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1139 b'\x00': 0,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1140 b'\x00\x00': 0,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1141 b'\x01': 1,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1142 b'\x00\x01': 256,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1143 b'\xff': -1,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1144 b'\xff\xff': -1,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1145 b'\x81': -127,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1146 b'\x80': -128,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1147 b'\x7f\xff': -129,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1148 b'\x7f': 127,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1149 b'\x81\x00': 129,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1150 b'\x01\xff': -255,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1151 b'\x00\xff': -256,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1152 b'\xff\x00': 255,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1153 b'\x00\x01': 256,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1154 b'\xff\x7f': 32767,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1155 b'\x00\x80': -32768,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1156 b'\xff\xff\x00': 65535,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1157 b'\x00\x00\xff': -65536,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1158 b'\x00\x00\x80': -8388608
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1159 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1160 check(tests2, 'little', signed=True)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1161
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1162 # Convert unsigned big-endian byte arrays to integers.
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1163 tests3 = {
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1164 b'': 0,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1165 b'\x00': 0,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1166 b'\x01': 1,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1167 b'\x7f': 127,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1168 b'\x80': 128,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1169 b'\xff': 255,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1170 b'\x01\x00': 256,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1171 b'\x7f\xff': 32767,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1172 b'\x80\x00': 32768,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1173 b'\xff\xff': 65535,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1174 b'\x01\x00\x00': 65536,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1175 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1176 check(tests3, 'big', signed=False)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1177
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1178 # Convert integers to unsigned little-endian byte arrays.
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1179 tests4 = {
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1180 b'': 0,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1181 b'\x00': 0,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1182 b'\x01': 1,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1183 b'\x7f': 127,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1184 b'\x80': 128,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1185 b'\xff': 255,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1186 b'\x00\x01': 256,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1187 b'\xff\x7f': 32767,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1188 b'\x00\x80': 32768,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1189 b'\xff\xff': 65535,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1190 b'\x00\x00\x01': 65536,
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1191 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1192 check(tests4, 'little', signed=False)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1193
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1194 class myint(int):
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1195 pass
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1196
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1197 self.assertTrue(type(myint.from_bytes(b'\x00', 'big')) is myint)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1198 self.assertEqual(myint.from_bytes(b'\x01', 'big'), 1)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1199 self.assertTrue(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1200 type(myint.from_bytes(b'\x00', 'big', signed=False)) is myint)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1201 self.assertEqual(myint.from_bytes(b'\x01', 'big', signed=False), 1)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1202 self.assertTrue(type(myint.from_bytes(b'\x00', 'little')) is myint)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1203 self.assertEqual(myint.from_bytes(b'\x01', 'little'), 1)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1204 self.assertTrue(type(myint.from_bytes(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1205 b'\x00', 'little', signed=False)) is myint)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1206 self.assertEqual(myint.from_bytes(b'\x01', 'little', signed=False), 1)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1207 self.assertEqual(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1208 int.from_bytes([255, 0, 0], 'big', signed=True), -65536)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1209 self.assertEqual(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1210 int.from_bytes((255, 0, 0), 'big', signed=True), -65536)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1211 self.assertEqual(int.from_bytes(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1212 bytearray(b'\xff\x00\x00'), 'big', signed=True), -65536)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1213 self.assertEqual(int.from_bytes(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1214 bytearray(b'\xff\x00\x00'), 'big', signed=True), -65536)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1215 self.assertEqual(int.from_bytes(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1216 array.array('B', b'\xff\x00\x00'), 'big', signed=True), -65536)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1217 self.assertEqual(int.from_bytes(
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1218 memoryview(b'\xff\x00\x00'), 'big', signed=True), -65536)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1219 self.assertRaises(ValueError, int.from_bytes, [256], 'big')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1220 self.assertRaises(ValueError, int.from_bytes, [0], 'big\x00')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1221 self.assertRaises(ValueError, int.from_bytes, [0], 'little\x00')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1222 self.assertRaises(TypeError, int.from_bytes, "", 'big')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1223 self.assertRaises(TypeError, int.from_bytes, "\x00", 'big')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1224 self.assertRaises(TypeError, int.from_bytes, 0, 'big')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1225 self.assertRaises(TypeError, int.from_bytes, 0, 'big', True)
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1226 self.assertRaises(TypeError, myint.from_bytes, "", 'big')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1227 self.assertRaises(TypeError, myint.from_bytes, "\x00", 'big')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1228 self.assertRaises(TypeError, myint.from_bytes, 0, 'big')
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	1229 self.assertRaises(TypeError, int.from_bytes, 0, 'big', True)
51145 9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	1230
76440 cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1231 def test_access_to_nonexistent_digit_0(self):
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1232 # http://bugs.python.org/issue14630: A bug in _PyLong_Copy meant that
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1233 # ob_digit[0] was being incorrectly accessed for instances of a
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1234 # subclass of int, with value 0.
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1235 class Integer(int):
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1236 def __new__(cls, value=0):
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1237 self = int.__new__(cls, value)
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1238 self.foo = 'foo'
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1239 return self
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1240
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1241 integers = [Integer(0) for i in range(1000)]
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1242 for n in map(int, integers):
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1243 self.assertEqual(n, 0)
cdcc6b489862 Issue #14630: Fix an incorrect access of ob_digit[0] for a zero instance of an int subclass. Mark Dickinson <mdickinson@enthought.com> parents: 68257 diff changeset	1244
50207 92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	1245
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	1246 def test_main():
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 46909 diff changeset	1247 support.run_unittest(LongTest)
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	1248
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	1249 if __name__ == "__main__":
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	1250 test_main()

Mercurial > cpython-lru_cache-weakref

annotate Lib/test/test_long.py @ 80272:ec00f8570c55