cpython-lru_cache-weakref: Lib/test/test

annotate Lib/test/test_long.py @ 70626:aa07c1237f4e

(Merge 3.2) Issue #12016: Reindent decoders of HK and JP codecs

author	Victor Stinner <victor.stinner@haypocalc.com>
date	Fri, 03 Jun 2011 23:34:32 +0200
parents	3c9232a684ae
children	cdcc6b489862 117d51d3dd7d

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
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	46 # pure Python version of correctly-rounded true division
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	47 def truediv(a, b):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	48 """Correctly-rounded true division for integers."""
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	49 negative = a^b < 0
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	50 a, b = abs(a), abs(b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	51
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	52 # exceptions: division by zero, overflow
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	53 if not b:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	54 raise ZeroDivisionError("division by zero")
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	55 if a >= DBL_MIN_OVERFLOW * b:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	56 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	57
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	58 # 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	59 d = a.bit_length() - b.bit_length()
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	60 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	61 d += 1
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	62
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	63 # compute 2*-exp a / b for suitable exp
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	64 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	65 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	66 q, r = divmod(a, b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	67
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	68 # 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	69 # 2r > b, and == 0.5 iff 2r == b.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	70 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	71 q += 1
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	72
57946 dd6726c978c6 Merged revisions 77066 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57942 diff changeset	73 result = math.ldexp(q, exp)
57942 aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	74 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	75
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	76
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	77 class LongTest(unittest.TestCase):
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	78
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	79 # 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	80 # 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	81 # 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	82 # 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	83 # 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	84
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	85 def getran(self, ndigits):
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	86 self.assertTrue(ndigits > 0)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	87 nbits_hi = ndigits * SHIFT
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	88 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	89 answer = 0
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	90 nbits = 0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	91 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	92 while nbits < nbits_lo:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	93 bits = (r >> 1) + 1
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	94 bits = min(bits, nbits_hi - nbits)
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	95 self.assertTrue(1 <= bits <= SHIFT)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	96 nbits = nbits + bits
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	97 answer = answer << bits
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	98 if r & 1:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	99 answer = answer \| ((1 << bits) - 1)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	100 r = int(random.random() * (SHIFT * 2))
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	101 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	102 if random.random() < 0.5:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	103 answer = -answer
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	104 return answer
9209 d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	105
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	106 # 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	107 # 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	108
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	109 def getran2(ndigits):
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	110 answer = 0
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	111 for i in range(ndigits):
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	112 answer = (answer << SHIFT) \| random.randint(0, MASK)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	113 if random.random() < 0.5:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	114 answer = -answer
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	115 return answer
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	116
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	117 def check_division(self, x, y):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	118 eq = self.assertEqual
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	119 q, r = divmod(x, y)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	120 q2, r2 = x//y, x%y
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	121 pab, pba = xy, yx
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	122 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	123 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	124 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	125 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	126 if y > 0:
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	127 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	128 else:
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	129 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	130
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	131 def test_division(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	132 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	133 KARATSUBA_CUTOFF + 14))
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	134 digits.append(KARATSUBA_CUTOFF * 3)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	135 for lenx in digits:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	136 x = self.getran(lenx)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	137 for leny in digits:
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	138 y = self.getran(leny) or 1
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	139 self.check_division(x, y)
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	140
52215 bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	141 # 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	142 # 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	143
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	144 # 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	145 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	146 1147341367131428698)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	147 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	148 707270836069027745)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	149 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	150 643588798496057020)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	151 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	152 1038556335171453937726882627)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	153 # 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	154 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	155 949985870686786135626943396)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	156 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	157 1091555541180371554426545266)
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	158
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	159 # 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	160 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	161 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	162 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	163 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	164 # 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	165 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	166 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	167
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	168
bb5de24a343f Issue #4258: Make it possible to use 30-bit digits for PyLongs: Mark Dickinson <dickinsm@gmail.com> parents: 51145 diff changeset	169
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	170 def test_karatsuba(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	171 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	172 KARATSUBA_CUTOFF + 10))
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	173 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	174
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	175 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	176
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	177 # 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	178 # 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	179 for abits in bits:
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	180 a = (1 << abits) - 1
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	181 for bbits in bits:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	182 if bbits < abits:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	183 continue
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	184 b = (1 << bbits) - 1
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	185 x = a * b
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	186 y = ((1 << (abits + bbits)) -
1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	187 (1 << abits) -
1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	188 (1 << bbits) +
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	189 1)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	190 self.assertEqual(x, y,
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	191 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	192
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	193 def check_bitop_identities_1(self, x):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	194 eq = self.assertEqual
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	195 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	196 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	197 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	198 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	199 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	200 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	201 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	202 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	203 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	204 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	205 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	206 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	207 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	208 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	209 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	210 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	211 p2 = 2 ** n
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	212 eq(x << n >> n, x,
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	213 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	214 eq(x // p2, x >> n,
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	215 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	216 eq(x * p2, x << n,
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	217 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	218 eq(x & -p2, x >> n << n,
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	219 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	220 eq(x & -p2, x & ~(p2 - 1),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	221 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	222
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	223 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	224 eq = self.assertEqual
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	225 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	226 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	227 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	228 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	229 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	230 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	231 eq(x ^ y, (x \| y) & ~(x & y),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	232 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	233 eq(x ^ y, (x & ~y) \| (~x & y),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	234 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	235 eq(x ^ y, (x \| y) & (~x \| ~y),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	236 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	237
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	238 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	239 eq = self.assertEqual
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	240 eq((x & y) & z, x & (y & z),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	241 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	242 eq((x \| y) \| z, x \| (y \| z),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	243 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	244 eq((x ^ y) ^ z, x ^ (y ^ z),
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	245 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	246 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	247 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	248 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	249 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	250
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	251 def test_bitop_identities(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	252 for x in special:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	253 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	254 digits = range(1, MAXDIGITS+1)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	255 for lenx in digits:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	256 x = self.getran(lenx)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	257 self.check_bitop_identities_1(x)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	258 for leny in digits:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	259 y = self.getran(leny)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	260 self.check_bitop_identities_2(x, y)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	261 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	262
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	263 def slow_format(self, x, base):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	264 digits = []
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	265 sign = 0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	266 if x < 0:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	267 sign, x = 1, -x
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	268 while x:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	269 x, r = divmod(x, base)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	270 digits.append(int(r))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	271 digits.reverse()
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	272 digits = digits or [0]
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	273 return '-'[:sign] + \
42084 229c28cb9afb Merged revisions 55817-55961 via svnmerge from Guido van Rossum <guido@python.org> parents: 41642 diff changeset	274 {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	275 "".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	276
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	277 def check_format_1(self, x):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	278 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	279 got = mapper(x)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	280 expected = self.slow_format(x, base)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	281 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	282 mapper.__name__, got, expected, x)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	283 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	284 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	285 # 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	286 # trailing "L"
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	287 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	288 expected = self.slow_format(x, 10)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	289 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	290 mapper.__name__, got, expected, x)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	291 self.assertEqual(got, expected, msg)
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	292
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	293 def test_format(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	294 for x in special:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	295 self.check_format_1(x)
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	296 for i in range(10):
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	297 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	298 x = self.getran(lenx)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	299 self.check_format_1(x)
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	300
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	301 def test_long(self):
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	302 # 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	303 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	304 ('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	305 ('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	306 ]
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	307 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	308 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	309 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	310 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	311 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	312 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	313 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	314 try:
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	315 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	316 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	317 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	318
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	319 # 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	320 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	321 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	322 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	323 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	324 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	325 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	326 # ... 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	327 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	328
61937 8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	329 # tests with base 0
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	330 self.assertEqual(int('000', 0), 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	331 self.assertEqual(int('0o123', 0), 83)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	332 self.assertEqual(int('0x123', 0), 291)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	333 self.assertEqual(int('0b100', 0), 4)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	334 self.assertEqual(int(' 0O123 ', 0), 83)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	335 self.assertEqual(int(' 0X123 ', 0), 291)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	336 self.assertEqual(int(' 0B100 ', 0), 4)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	337 self.assertEqual(int('0', 0), 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	338 self.assertEqual(int('+0', 0), 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	339 self.assertEqual(int('-0', 0), 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	340 self.assertEqual(int('00', 0), 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	341 self.assertRaises(ValueError, int, '08', 0)
8180abbd07cb Merged revisions 81553 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	342 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	343
61940 c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	344 # invalid bases
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	345 invalid_bases = [-909,
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	346 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	347 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	348 2100, -2100,
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	349 ]
c42ffb3d63af Issue #2844: Make int('42', n) consistently raise ValueError for Mark Dickinson <dickinsm@gmail.com> parents: 61936 diff changeset	350 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	351 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	352
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 def test_conversion(self):
9209 d3af310f230c New test_long.py from Tim Peters. Guido van Rossum <guido@python.org> parents: 8989 diff changeset	355
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	356 class JustLong:
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	357 # 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	358 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	359 return 42
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	360 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	361
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	362 class LongTrunc:
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	363 # __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	364 def __long__(self):
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	365 return 42
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	366 def __trunc__(self):
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	367 return 1729
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	368 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	369
66709 f2a4ade36a1e Issue #10624: Use support.requires_IEEE_754 in all appropriate tests. Eric Smith <eric@trueblade.com> parents: 66686 diff changeset	370 @support.requires_IEEE_754
53290 41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	371 def test_float_conversion(self):
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	372
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	373 exact_values = [0, 1, 2,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	374 2**53-3,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	375 2**53-2,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	376 2**53-1,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	377 2**53,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	378 2**53+2,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	379 2**54-4,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	380 2**54-2,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	381 2**54,
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	382 2**54+4]
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	383 for x in exact_values:
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	384 self.assertEqual(float(x), x)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	385 self.assertEqual(float(-x), -x)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	386
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	387 # test round-half-even
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	388 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	389 for p in range(15):
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	390 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	391
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	392 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	393 (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	394 (13, 12), (14, 16), (15, 16)]:
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	395 for p in range(15):
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	396 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	397
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	398 # behaviour near extremes of floating-point range
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	399 int_dbl_max = int(DBL_MAX)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	400 top_power = 2**DBL_MAX_EXP
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	401 halfway = (int_dbl_max + top_power)//2
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	402 self.assertEqual(float(int_dbl_max), DBL_MAX)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	403 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	404 self.assertEqual(float(halfway-1), DBL_MAX)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	405 self.assertRaises(OverflowError, float, halfway)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	406 self.assertEqual(float(1-halfway), -DBL_MAX)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	407 self.assertRaises(OverflowError, float, -halfway)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	408 self.assertRaises(OverflowError, float, top_power-1)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	409 self.assertRaises(OverflowError, float, top_power)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	410 self.assertRaises(OverflowError, float, top_power+1)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	411 self.assertRaises(OverflowError, float, 2*top_power-1)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	412 self.assertRaises(OverflowError, float, 2*top_power)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	413 self.assertRaises(OverflowError, float, top_power*top_power)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	414
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	415 for p in range(100):
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	416 x = 2*p (2**53 + 1) + 1
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	417 y = 2*p (2**53 + 2)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	418 self.assertEqual(int(float(x)), y)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	419
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	420 x = 2*p (2**53 + 1)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	421 y = 2*p 2**53
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	422 self.assertEqual(int(float(x)), y)
41293fa6f0dd Merged revisions 71772 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 52215 diff changeset	423
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	424 def test_float_overflow(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	425 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	426 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	427
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	428 shuge = '12345' * 120
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	429 huge = 1 << 30000
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	430 mhuge = -huge
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	431 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	432 for test in ["float(huge)", "float(mhuge)",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	433 "complex(huge)", "complex(mhuge)",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	434 "complex(huge, 1)", "complex(mhuge, 1)",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	435 "complex(1, huge)", "complex(1, mhuge)",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	436 "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	437 "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	438 "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	439 "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	440 "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	441 "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	442 "math.sin(huge)", "math.sin(mhuge)",
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	443 "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	444 # 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	445 ##"math.floor(huge)", "math.floor(mhuge)",
83c8448c6de4 math.floor(<int>) now returns the argument, Guido van Rossum <guido@python.org> parents: 42142 diff changeset	446 ]:
19679 6958784b1cef Whitespace normalization. Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	447
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	448 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	449
57582 1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	450 # 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	451 # The comparison should not.
1c92fbb3baf2 Issue #7435: Remove duplicate int/long tests, and other Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	452 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	453 "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	454
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	455 def test_logs(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	456 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	457
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41592 diff changeset	458 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	459 value = 10 ** exp
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	460 log10 = math.log10(value)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	461 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	462
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	463 # 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	464 # exp/LOG10E
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	465 expected = exp / LOG10E
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	466 log = math.log(value)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	467 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	468
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	469 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	470 self.assertRaises(ValueError, math.log, bad)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	471 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	472
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	473 def test_mixed_compares(self):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	474 eq = self.assertEqual
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	475
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	476 # 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	477 # 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	478 # 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	479 # 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	480 # 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	481 class Rat:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	482 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	483 if isinstance(value, int):
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	484 self.n = value
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	485 self.d = 1
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	486 elif isinstance(value, float):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	487 # Convert to exact rational equivalent.
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	488 f, e = math.frexp(abs(value))
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	489 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	490 # \|value\| = f * 2**e exactly
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	491
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	492 # 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	493 # 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	494 # 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	495 CHUNK = 28
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	496 top = 0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	497 # invariant: \|value\| = (top + f) * 2**e exactly
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	498 while f:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	499 f = math.ldexp(f, CHUNK)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	500 digit = int(f)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	501 assert digit >> CHUNK == 0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	502 top = (top << CHUNK) \| digit
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	503 f -= digit
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	504 assert 0.0 <= f < 1.0
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	505 e -= CHUNK
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	506
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	507 # Now \|value\| = top * 2**e exactly.
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	508 if e >= 0:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	509 n = top << e
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	510 d = 1
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	511 else:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	512 n = top
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	513 d = 1 << -e
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	514 if value < 0:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	515 n = -n
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	516 self.n = n
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	517 self.d = d
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	518 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	519 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	520 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	521
49518 d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	522 def _cmp__(self, other):
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	523 if not isinstance(other, Rat):
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	524 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	525 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	526 return (x > y) - (x < y)
49518 d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	527 def __eq__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	528 return self._cmp__(other) == 0
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	529 def __ne__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	530 return self._cmp__(other) != 0
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	531 def __ge__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	532 return self._cmp__(other) >= 0
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	533 def __gt__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	534 return self._cmp__(other) > 0
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	535 def __le__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	536 return self._cmp__(other) <= 0
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	537 def __lt__(self, other):
d0619e210ac4 remove some more references to __cmp__ #1717 Benjamin Peterson <benjamin@python.org> parents: 48680 diff changeset	538 return self._cmp__(other) < 0
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 33348 diff changeset	539
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	540 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	541 # 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	542 # important boundary for IEEE double precision.
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	543 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	544 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	545 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	546 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	547 # 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	548 # 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	549 t = int(1e200)
1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 40450 diff changeset	550 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	551 cases.extend([-x for x in cases])
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	552 for x in cases:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	553 Rx = Rat(x)
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	554 for y in cases:
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	555 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	556 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	557 xycmp = (x > y) - (x < y)
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	558 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	559 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	560 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	561 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	562 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	563 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	564 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	565
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	566 def test__format__(self):
42817 5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	567 self.assertEqual(format(123456789, 'd'), '123456789')
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	568 self.assertEqual(format(123456789, 'd'), '123456789')
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	569
43097 a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	570 # sign and aligning are interdependent
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	571 self.assertEqual(format(1, "-"), '1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	572 self.assertEqual(format(-1, "-"), '-1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	573 self.assertEqual(format(1, "-3"), ' 1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	574 self.assertEqual(format(-1, "-3"), ' -1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	575 self.assertEqual(format(1, "+3"), ' +1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	576 self.assertEqual(format(-1, "+3"), ' -1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	577 self.assertEqual(format(1, " 3"), ' 1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	578 self.assertEqual(format(-1, " 3"), ' -1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	579 self.assertEqual(format(1, " "), ' 1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	580 self.assertEqual(format(-1, " "), '-1')
a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	581
42817 5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	582 # hex
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	583 self.assertEqual(format(3, "x"), "3")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	584 self.assertEqual(format(3, "X"), "3")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	585 self.assertEqual(format(1234, "x"), "4d2")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	586 self.assertEqual(format(-1234, "x"), "-4d2")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	587 self.assertEqual(format(1234, "8x"), " 4d2")
43097 a9acc06da57a Added format tests. Eric Smith <eric@trueblade.com> parents: 42817 diff changeset	588 self.assertEqual(format(-1234, "8x"), " -4d2")
42817 5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	589 self.assertEqual(format(1234, "x"), "4d2")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	590 self.assertEqual(format(-1234, "x"), "-4d2")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	591 self.assertEqual(format(-3, "x"), "-3")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	592 self.assertEqual(format(-3, "X"), "-3")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	593 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	594 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	595 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	596 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	597
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	598 # octal
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	599 self.assertEqual(format(3, "b"), "11")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	600 self.assertEqual(format(-3, "b"), "-11")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	601 self.assertEqual(format(1234, "b"), "10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	602 self.assertEqual(format(-1234, "b"), "-10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	603 self.assertEqual(format(1234, "-b"), "10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	604 self.assertEqual(format(-1234, "-b"), "-10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	605 self.assertEqual(format(1234, " b"), " 10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	606 self.assertEqual(format(-1234, " b"), "-10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	607 self.assertEqual(format(1234, "+b"), "+10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	608 self.assertEqual(format(-1234, "+b"), "-10011010010")
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	609
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	610 # make sure these are errors
5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	611 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	612 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	613 # 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	614
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	615 # 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	616 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	617 [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	618 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	619 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	620 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	621 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	622 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	623 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	624
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	625 # 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	626 # the int to a float
46909 ef4ec968fdb6 Merged revisions 63078 via svnmerge from Eric Smith <eric@trueblade.com> parents: 46664 diff changeset	627 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	628 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	629 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	630 format(float(value), format_spec))
42817 5355337709e1 Implementation of PEP 3101, Advanced String Formatting. Eric Smith <eric@trueblade.com> parents: 42762 diff changeset	631
44460 13aabc23cf2e Merged revisions 59680-59695 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44160 diff changeset	632 def test_nan_inf(self):
44463 d2c1ba099290 Fixed test_long Christian Heimes <christian@cheimes.de> parents: 44460 diff changeset	633 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	634 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	635 self.assertRaises(ValueError, int, float('nan'))
44460 13aabc23cf2e Merged revisions 59680-59695 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44160 diff changeset	636
48458 e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	637 def test_true_division(self):
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	638 huge = 1 << 40000
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	639 mhuge = -huge
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	640 self.assertEqual(huge / huge, 1.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	641 self.assertEqual(mhuge / mhuge, 1.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	642 self.assertEqual(huge / mhuge, -1.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	643 self.assertEqual(mhuge / huge, -1.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	644 self.assertEqual(1 / huge, 0.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	645 self.assertEqual(1 / huge, 0.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	646 self.assertEqual(1 / mhuge, 0.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	647 self.assertEqual(1 / mhuge, 0.0)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	648 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	649 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	650 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	651 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	652 self.assertEqual(huge / (huge << 1), 0.5)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	653 self.assertEqual((1000000 * huge) / huge, 1000000)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	654
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	655 namespace = {'huge': huge, 'mhuge': mhuge}
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	656
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	657 for overflow in ["float(huge)", "float(mhuge)",
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	658 "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	659 "mhuge / 100", "mhuge / 200"]:
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	660 self.assertRaises(OverflowError, eval, overflow, namespace)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	661
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	662 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	663 "100 / mhuge", "200 / mhuge"]:
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	664 result = eval(underflow, namespace)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	665 self.assertEqual(result, 0.0,
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	666 "expected underflow to 0 from %r" % underflow)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	667
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	668 for zero in ["huge / 0", "mhuge / 0"]:
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	669 self.assertRaises(ZeroDivisionError, eval, zero, namespace)
e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	670
57942 aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	671 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	672 """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	673 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	674 rounded division. b should be nonzero."""
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	675
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	676 # 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	677 # implementation converts the arguments to float directly and
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	678 # 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	679 # 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	680 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	681 return
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	682
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	683 try:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	684 # 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	685 expected = repr(truediv(a, b))
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	686 except OverflowError:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	687 expected = 'overflow'
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	688 except ZeroDivisionError:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	689 expected = 'zerodivision'
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	690
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	691 try:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	692 got = repr(a / b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	693 except OverflowError:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	694 got = 'overflow'
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	695 except ZeroDivisionError:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	696 got = 'zerodivision'
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	697
57951 73365bb26fd6 Merged revisions 77071 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57946 diff changeset	698 self.assertEqual(expected, got, "Incorrectly rounded division {}/{}: "
73365bb26fd6 Merged revisions 77071 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57946 diff changeset	699 "expected {}, got {}".format(a, b, expected, got))
57942 aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	700
66709 f2a4ade36a1e Issue #10624: Use support.requires_IEEE_754 in all appropriate tests. Eric Smith <eric@trueblade.com> parents: 66686 diff changeset	701 @support.requires_IEEE_754
57942 aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	702 def test_correctly_rounded_true_division(self):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	703 # 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	704 # 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	705 # This test should probably be considered CPython-specific.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	706
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	707 # 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	708 # ... divisions involving zero
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	709 self.check_truediv(123, 0)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	710 self.check_truediv(-456, 0)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	711 self.check_truediv(0, 3)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	712 self.check_truediv(0, -3)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	713 self.check_truediv(0, 0)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	714 # ... overflow or underflow by large margin
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	715 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	716 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	717 # ... a much larger or smaller than b
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	718 self.check_truediv(123452*100, 98765)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	719 self.check_truediv(12345230, 987657**81)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	720 # ... 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	721 # 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	722 bases = (0, DBL_MANT_DIG, DBL_MIN_EXP,
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	723 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	724 for base in bases:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	725 for exp in range(base - 15, base + 15):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	726 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	727 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	728
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	729 # overflow corner case
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	730 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	731 -1, -2, -5, -23, -67891, -41**50]:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	732 for n in range(-10, 10):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	733 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	734 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	735
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	736 # check detection of inexactness in shifting stage
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	737 for n in range(250):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	738 # (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	739 # between two representable floats, and would usually be
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	740 # 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	741 # 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	742 # up instead.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	743 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	744 2*DBL_MANT_DIG12345)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	745
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	746 # 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	747 # 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	748 # 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	749 # were it not explicitly skipped in check_truediv.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	750 self.check_truediv(1, 2731)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	751
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	752 # 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	753 # error of close to 3.5 ulps.
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	754 self.check_truediv(295147931372582273023, 295147932265116303360)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	755 for i in range(1000):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	756 self.check_truediv(10(i+1), 10i)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	757 self.check_truediv(10i, 10(i+1))
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	758
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	759 # test round-half-to-even behaviour, normal result
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	760 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	761 -1, -2, -5, -23, -67891, -41**50]:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	762 for n in range(-10, 10):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	763 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	764
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	765 # test round-half-to-even, subnormal result
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	766 for n in range(-20, 20):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	767 self.check_truediv(n, 2**1076)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	768
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	769 # largeish random divisions: a/b where \|a\| <= \|b\| <=
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	770 # 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	771 # 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	772 # 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	773 for M in [1010, 10100, 10**1000]:
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	774 for i in range(1000):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	775 a = random.randrange(1, M)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	776 b = random.randrange(a, 2*a+1)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	777 self.check_truediv(a, b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	778 self.check_truediv(-a, b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	779 self.check_truediv(a, -b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	780 self.check_truediv(-a, -b)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	781
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	782 # and some (genuinely) random tests
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	783 for _ in range(10000):
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	784 a_bits = random.randrange(1000)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	785 b_bits = random.randrange(1, 1000)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	786 x = random.randrange(2**a_bits)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	787 y = random.randrange(1, 2**b_bits)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	788 self.check_truediv(x, y)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	789 self.check_truediv(x, -y)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	790 self.check_truediv(-x, y)
aaa5ab7b942a Merged revisions 77062 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 57582 diff changeset	791 self.check_truediv(-x, -y)
48458 e53e4a71f56f move test_long_future into test_long Benjamin Peterson <benjamin@python.org> parents: 47201 diff changeset	792
48567 1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	793 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	794 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	795 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	796 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	797 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	798 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	799 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	800 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	801 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	802 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	803 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	804 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	805 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	806 # corner cases
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	807 i = 1 << 70
1ce7e5c5a761 Optimization to stop creating new small longs and use the Facundo Batista <facundobatista@gmail.com> parents: 48458 diff changeset	808 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	809 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	810
50207 92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	811 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	812 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	813 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	814 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	815 # 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	816 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	817 # 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	818 if x != 0:
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	819 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	820 else:
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	821 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	822 # 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	823 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	824 # 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	825 # 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	826 # 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	827 # 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	828 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	829 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	830
92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	831 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	832 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	833 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	834 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	835 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	836 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	837 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	838 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	839 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	840 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	841 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	842 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	843 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	844
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	845 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	846 # 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	847 # 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	848 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	849 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	850 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	851 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	852 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	853 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	854 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	855 self.assertEqual(got, expected)
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	856 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	857
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	858 # 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	859 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	860 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	861 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	862 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	863 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	864 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	865 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	866 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	867 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	868 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	869 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	870 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	871 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	872 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	873 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	874 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	875 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	876 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	877 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	878 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	879 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	880 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	881 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	882 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	883 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	884 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	885 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	886 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	887 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	888 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	889
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	890 # 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	891 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	892 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	893 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	894 self.assertEqual(got, expect)
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	895 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	896
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	897 # 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	898 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	899 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	900 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	901 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	902 self.assertEqual(got, x)
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	903 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	904 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	905 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	906
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	907 # 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	908 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	909 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	910 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	911 self.assertEqual(got, x)
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 53290 diff changeset	912 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	913
9742e8a4dca1 Issue #4707: round(x, n) now returns an integer when x is an integer. Mark Dickinson <dickinsm@gmail.com> parents: 51121 diff changeset	914 # 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	915 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	916 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	917 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	918
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	919 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	920 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	921 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	922 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	923 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	924 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	925 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	926 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	927 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	928 "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	929 .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	930
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	931 # 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	932 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	933 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	934 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	935 -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	936 -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	937 -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	938 -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	939 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	940 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	941 -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	942 -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	943 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	944 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	945 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	946 -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	947 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	948 -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	949 -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	950 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	951 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	952
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	953 # 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	954 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	955 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	956 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	957 -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	958 -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	959 -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	960 -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	961 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	962 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	963 -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	964 -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	965 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	966 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	967 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	968 -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	969 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	970 -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	971 -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	972 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	973 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	974
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	975 # 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	976 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	977 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	978 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	979 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	980 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	981 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	982 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	983 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	984 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	985 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	986 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	987 }
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	988 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	989
f9c0c411f80c Issue #1023290: Added API for the conversion of longs to bytes and vice-versa. Alexandre Vassalotti <alexandre@peadrop.com> parents: 57951 diff changeset	990 # 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	991 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	992 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	993 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	994 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	995 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	996 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	997 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	998 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	999 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	1000 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	1001 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	1002 }
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 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	1004
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 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	1006 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	1007 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	1008 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	1009 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	1010 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	1011 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	1012 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	1013 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	1014 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	1015 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	1016 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	1017
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 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	1019 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	1020 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	1021 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	1022 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	1023 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	1024 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	1025 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	1026 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	1027 "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	1028 .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	1029
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 # 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	1031 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	1032 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	1033 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	1034 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	1035 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	1036 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	1037 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	1038 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	1039 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	1040 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	1041 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	1042 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	1043 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	1044 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	1045 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	1046 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	1047 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	1048 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	1049 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	1050 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	1051 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	1052 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	1053 }
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 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	1055
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 # 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	1057 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	1058 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	1059 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	1060 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	1061 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	1062 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	1063 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	1064 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	1065 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	1066 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	1067 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	1068 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	1069 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	1070 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	1071 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	1072 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	1073 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	1074 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	1075 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	1076 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	1077 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	1078 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	1079 }
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 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	1081
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 # 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	1083 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	1084 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	1085 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	1086 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	1087 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	1088 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	1089 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	1090 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	1091 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	1092 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	1093 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	1094 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	1095 }
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 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	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 # 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	1099 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	1100 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	1101 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	1102 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	1103 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	1104 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	1105 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	1106 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	1107 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	1108 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	1109 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	1110 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	1111 }
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 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	1113
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 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	1115 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	1116
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 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	1118 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	1119 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	1120 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	1121 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	1122 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	1123 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	1124 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	1125 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	1126 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	1127 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	1128 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	1129 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	1130 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	1131 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	1132 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	1133 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	1134 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	1135 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	1136 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	1137 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	1138 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	1139 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	1140 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	1141 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	1142 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	1143 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	1144 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	1145 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	1146 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	1147 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	1148 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	1149 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	1150
50207 92e21652f2f4 Forward merge of r67822 to py3k: add bit_length method to int. Mark Dickinson <dickinsm@gmail.com> parents: 49518 diff changeset	1151
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	1152 def test_main():
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 46909 diff changeset	1153 support.run_unittest(LongTest)
8989 5fb3c683e862 Add Tim Peters' test for long ints Guido van Rossum <guido@python.org> parents: diff changeset	1154
35072 5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	1155 if __name__ == "__main__":
5fb2163231d3 Port test_long.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 33547 diff changeset	1156 test_main()

Mercurial > cpython-lru_cache-weakref

annotate Lib/test/test_long.py @ 70626:aa07c1237f4e