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