1""" 2int tests from Py3.3 3""" 4 5from __future__ import (absolute_import, division, 6 print_function, unicode_literals) 7from future.builtins import * 8from future.tests.base import unittest, expectedFailurePY2 9from future.utils import PY26, PY2, raise_from 10 11import sys 12import random 13import array 14 15try: 16 import numpy as np 17except ImportError: 18 np = None 19 20try: 21 from future.standard_library.test import support 22except ImportError: 23 def cpython_only(f): 24 return f 25else: 26 cpython_only = support.cpython_only 27 28 29L = [ 30 ('0', 0), 31 ('1', 1), 32 ('9', 9), 33 ('10', 10), 34 ('99', 99), 35 ('100', 100), 36 ('314', 314), 37 (' 314', 314), 38 ('314 ', 314), 39 (' \t\t 314 \t\t ', 314), 40 (repr(sys.maxsize), sys.maxsize), 41 (' 1x', ValueError), 42 (' 1 ', 1), 43 (' 1\02 ', ValueError), 44 ('', ValueError), 45 (' ', ValueError), 46 (' \t\t ', ValueError), 47 ("\u0200", ValueError) 48] 49 50class IntTestCases(unittest.TestCase): 51 52 def setUp(self): 53 self.longMessage = True 54 55 def test_isinstance_int_subclass(self): 56 """ 57 Issue #89 58 """ 59 value = int(10) 60 class Magic(int): 61 pass 62 self.assertTrue(isinstance(value, int)) 63 self.assertFalse(isinstance(value, Magic)) 64 65 def test_basic(self): 66 self.assertEqual(int(314), 314) 67 self.assertEqual(int(3.14), 3) 68 # Check that conversion from float truncates towards zero 69 self.assertEqual(int(-3.14), -3) 70 self.assertEqual(int(3.9), 3) 71 self.assertEqual(int(-3.9), -3) 72 self.assertEqual(int(3.5), 3) 73 self.assertEqual(int(-3.5), -3) 74 self.assertEqual(int("-3"), -3) 75 self.assertEqual(int(" -3 "), -3) 76 self.assertEqual(int("\N{EM SPACE}-3\N{EN SPACE}"), -3) 77 # Different base: 78 self.assertEqual(int("10",16), 16) 79 # Test conversion from strings and various anomalies 80 for s, v in L: 81 for sign in "", "+", "-": 82 for prefix in "", " ", "\t", " \t\t ": 83 ss = prefix + sign + s 84 vv = v 85 if sign == "-" and v is not ValueError: 86 vv = -v 87 try: 88 self.assertEqual(int(ss), vv) 89 except ValueError: 90 pass 91 92 s = repr(-1-sys.maxsize) 93 x = int(s) 94 self.assertEqual(x+1, -sys.maxsize) 95 self.assertIsInstance(x, int) 96 # should return int 97 self.assertEqual(int(s[1:]), sys.maxsize+1) 98 99 # should return int 100 x = int(1e100) 101 self.assertIsInstance(x, int) 102 x = int(-1e100) 103 self.assertIsInstance(x, int) 104 105 106 # SF bug 434186: 0x80000000/2 != 0x80000000>>1. 107 # Worked by accident in Windows release build, but failed in debug build. 108 # Failed in all Linux builds. 109 x = -1-sys.maxsize 110 self.assertEqual(x >> 1, x//2) 111 112 self.assertRaises(ValueError, int, '123\0') 113 self.assertRaises(ValueError, int, '53', 40) 114 115 # SF bug 1545497: embedded NULs were not detected with 116 # explicit base 117 self.assertRaises(ValueError, int, '123\0', 10) 118 self.assertRaises(ValueError, int, '123\x00 245', 20) 119 120 x = int('1' * 600) 121 self.assertIsInstance(x, int) 122 123 124 self.assertRaises(TypeError, int, 1, 12) 125 126 self.assertEqual(int('0o123', 0), 83) 127 self.assertEqual(int('0x123', 16), 291) 128 129 # Bug 1679: "0x" is not a valid hex literal 130 self.assertRaises(ValueError, int, "0x", 16) 131 self.assertRaises(ValueError, int, "0x", 0) 132 133 self.assertRaises(ValueError, int, "0o", 8) 134 self.assertRaises(ValueError, int, "0o", 0) 135 136 self.assertRaises(ValueError, int, "0b", 2) 137 self.assertRaises(ValueError, int, "0b", 0) 138 139 # SF bug 1334662: int(string, base) wrong answers 140 # Various representations of 2**32 evaluated to 0 141 # rather than 2**32 in previous versions 142 143 self.assertEqual(int('100000000000000000000000000000000', 2), 4294967296) 144 self.assertEqual(int('102002022201221111211', 3), 4294967296) 145 self.assertEqual(int('10000000000000000', 4), 4294967296) 146 self.assertEqual(int('32244002423141', 5), 4294967296) 147 self.assertEqual(int('1550104015504', 6), 4294967296) 148 self.assertEqual(int('211301422354', 7), 4294967296) 149 self.assertEqual(int('40000000000', 8), 4294967296) 150 self.assertEqual(int('12068657454', 9), 4294967296) 151 self.assertEqual(int('4294967296', 10), 4294967296) 152 self.assertEqual(int('1904440554', 11), 4294967296) 153 self.assertEqual(int('9ba461594', 12), 4294967296) 154 self.assertEqual(int('535a79889', 13), 4294967296) 155 self.assertEqual(int('2ca5b7464', 14), 4294967296) 156 self.assertEqual(int('1a20dcd81', 15), 4294967296) 157 self.assertEqual(int('100000000', 16), 4294967296) 158 self.assertEqual(int('a7ffda91', 17), 4294967296) 159 self.assertEqual(int('704he7g4', 18), 4294967296) 160 self.assertEqual(int('4f5aff66', 19), 4294967296) 161 self.assertEqual(int('3723ai4g', 20), 4294967296) 162 self.assertEqual(int('281d55i4', 21), 4294967296) 163 self.assertEqual(int('1fj8b184', 22), 4294967296) 164 self.assertEqual(int('1606k7ic', 23), 4294967296) 165 self.assertEqual(int('mb994ag', 24), 4294967296) 166 self.assertEqual(int('hek2mgl', 25), 4294967296) 167 self.assertEqual(int('dnchbnm', 26), 4294967296) 168 self.assertEqual(int('b28jpdm', 27), 4294967296) 169 self.assertEqual(int('8pfgih4', 28), 4294967296) 170 self.assertEqual(int('76beigg', 29), 4294967296) 171 self.assertEqual(int('5qmcpqg', 30), 4294967296) 172 self.assertEqual(int('4q0jto4', 31), 4294967296) 173 self.assertEqual(int('4000000', 32), 4294967296) 174 self.assertEqual(int('3aokq94', 33), 4294967296) 175 self.assertEqual(int('2qhxjli', 34), 4294967296) 176 self.assertEqual(int('2br45qb', 35), 4294967296) 177 self.assertEqual(int('1z141z4', 36), 4294967296) 178 179 # tests with base 0 180 # this fails on 3.0, but in 2.x the old octal syntax is allowed 181 self.assertEqual(int(' 0o123 ', 0), 83) 182 self.assertEqual(int(' 0o123 ', 0), 83) 183 self.assertEqual(int('000', 0), 0) 184 self.assertEqual(int('0o123', 0), 83) 185 self.assertEqual(int('0x123', 0), 291) 186 self.assertEqual(int('0b100', 0), 4) 187 self.assertEqual(int(' 0O123 ', 0), 83) 188 self.assertEqual(int(' 0X123 ', 0), 291) 189 self.assertEqual(int(' 0B100 ', 0), 4) 190 191 # without base still base 10 192 self.assertEqual(int('0123'), 123) 193 self.assertEqual(int('0123', 10), 123) 194 195 # tests with prefix and base != 0 196 self.assertEqual(int('0x123', 16), 291) 197 self.assertEqual(int('0o123', 8), 83) 198 self.assertEqual(int('0b100', 2), 4) 199 self.assertEqual(int('0X123', 16), 291) 200 self.assertEqual(int('0O123', 8), 83) 201 self.assertEqual(int('0B100', 2), 4) 202 203 # the code has special checks for the first character after the 204 # type prefix 205 self.assertRaises(ValueError, int, '0b2', 2) 206 self.assertRaises(ValueError, int, '0b02', 2) 207 self.assertRaises(ValueError, int, '0B2', 2) 208 self.assertRaises(ValueError, int, '0B02', 2) 209 self.assertRaises(ValueError, int, '0o8', 8) 210 self.assertRaises(ValueError, int, '0o08', 8) 211 self.assertRaises(ValueError, int, '0O8', 8) 212 self.assertRaises(ValueError, int, '0O08', 8) 213 self.assertRaises(ValueError, int, '0xg', 16) 214 self.assertRaises(ValueError, int, '0x0g', 16) 215 self.assertRaises(ValueError, int, '0Xg', 16) 216 self.assertRaises(ValueError, int, '0X0g', 16) 217 218 # SF bug 1334662: int(string, base) wrong answers 219 # Checks for proper evaluation of 2**32 + 1 220 self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297) 221 self.assertEqual(int('102002022201221111212', 3), 4294967297) 222 self.assertEqual(int('10000000000000001', 4), 4294967297) 223 self.assertEqual(int('32244002423142', 5), 4294967297) 224 self.assertEqual(int('1550104015505', 6), 4294967297) 225 self.assertEqual(int('211301422355', 7), 4294967297) 226 self.assertEqual(int('40000000001', 8), 4294967297) 227 self.assertEqual(int('12068657455', 9), 4294967297) 228 self.assertEqual(int('4294967297', 10), 4294967297) 229 self.assertEqual(int('1904440555', 11), 4294967297) 230 self.assertEqual(int('9ba461595', 12), 4294967297) 231 self.assertEqual(int('535a7988a', 13), 4294967297) 232 self.assertEqual(int('2ca5b7465', 14), 4294967297) 233 self.assertEqual(int('1a20dcd82', 15), 4294967297) 234 self.assertEqual(int('100000001', 16), 4294967297) 235 self.assertEqual(int('a7ffda92', 17), 4294967297) 236 self.assertEqual(int('704he7g5', 18), 4294967297) 237 self.assertEqual(int('4f5aff67', 19), 4294967297) 238 self.assertEqual(int('3723ai4h', 20), 4294967297) 239 self.assertEqual(int('281d55i5', 21), 4294967297) 240 self.assertEqual(int('1fj8b185', 22), 4294967297) 241 self.assertEqual(int('1606k7id', 23), 4294967297) 242 self.assertEqual(int('mb994ah', 24), 4294967297) 243 self.assertEqual(int('hek2mgm', 25), 4294967297) 244 self.assertEqual(int('dnchbnn', 26), 4294967297) 245 self.assertEqual(int('b28jpdn', 27), 4294967297) 246 self.assertEqual(int('8pfgih5', 28), 4294967297) 247 self.assertEqual(int('76beigh', 29), 4294967297) 248 self.assertEqual(int('5qmcpqh', 30), 4294967297) 249 self.assertEqual(int('4q0jto5', 31), 4294967297) 250 self.assertEqual(int('4000001', 32), 4294967297) 251 self.assertEqual(int('3aokq95', 33), 4294967297) 252 self.assertEqual(int('2qhxjlj', 34), 4294967297) 253 self.assertEqual(int('2br45qc', 35), 4294967297) 254 self.assertEqual(int('1z141z5', 36), 4294967297) 255 256 @expectedFailurePY2 # fails on Py2 257 @cpython_only 258 def test_small_ints(self): 259 # Bug #3236: Return small longs from PyLong_FromString 260 self.assertIs(int('10'), 10) 261 self.assertIs(int('-1'), -1) 262 self.assertIs(int(b'10'), 10) 263 self.assertIs(int(b'-1'), -1) 264 265 def test_no_args(self): 266 self.assertEqual(int(), 0) 267 268 @unittest.skipIf(sys.version_info >= (3, 7), 269 "The first parameter must be positional with Python >= 3.7" 270 ) 271 def test_x_keyword_arg(self): 272 # Test invoking int() using keyword arguments. 273 self.assertEqual(int(x=1.2), 1) 274 self.assertEqual(int(x='100', base=2), 4) 275 276 def text_base_keyword_arg(self): 277 self.assertEqual(int('100', base=2), 4) 278 279 def test_newint_plus_float(self): 280 minutes = int(100) 281 second = 0.0 282 seconds = minutes*60 + second 283 self.assertEqual(seconds, 6000) 284 self.assertTrue(isinstance(seconds, float)) 285 286 @expectedFailurePY2 287 def test_keyword_args_2(self): 288 # newint causes these to fail: 289 self.assertRaises(TypeError, int, base=10) 290 self.assertRaises(TypeError, int, base=0) 291 292 def test_non_numeric_input_types(self): 293 # Test possible non-numeric types for the argument x, including 294 # subclasses of the explicitly documented accepted types. 295 class CustomStr(str): pass 296 class CustomBytes(bytes): pass 297 class CustomByteArray(bytearray): pass 298 299 values = [b'100', 300 bytearray(b'100'), 301 CustomStr('100'), 302 CustomBytes(b'100'), 303 CustomByteArray(b'100')] 304 305 for x in values: 306 msg = 'x has type %s' % type(x).__name__ 307 self.assertEqual(int(x), 100, msg=msg) 308 self.assertEqual(int(x, 2), 4, msg=msg) 309 310 def test_newint_of_newstr(self): 311 a = str(u'123') 312 b = int(a) 313 self.assertEqual(b, 123) 314 self.assertTrue(isinstance(b, int)) 315 316 def test_string_float(self): 317 self.assertRaises(ValueError, int, '1.2') 318 319 def test_intconversion(self): 320 # Test __int__() 321 class ClassicMissingMethods: 322 pass 323 # The following raises an AttributeError (for '__trunc__') on Py2 324 # but a TypeError on Py3 (which uses new-style classes). 325 # Perhaps nothing is to be done but avoiding old-style classes! 326 # ... 327 # self.assertRaises(TypeError, int, ClassicMissingMethods()) 328 329 class MissingMethods(object): 330 pass 331 self.assertRaises(TypeError, int, MissingMethods()) 332 333 class Foo0: 334 def __int__(self): 335 return 42 336 337 class Foo1(object): 338 def __int__(self): 339 return 42 340 341 class Foo2(int): 342 def __int__(self): 343 return 42 344 345 class Foo3(int): 346 def __int__(self): 347 return self.real 348 349 class Foo4(int): 350 def __int__(self): 351 return 42 352 353 class Foo5(int): 354 def __int__(self): 355 return 42. 356 357 self.assertEqual(int(Foo0()), 42) 358 self.assertEqual(int(Foo1()), 42) 359 self.assertEqual(int(Foo2()), 42) 360 self.assertEqual(int(Foo3()), 0) 361 self.assertEqual(int(Foo4()), 42) 362 self.assertRaises(TypeError, int, Foo5()) 363 364 class Classic: 365 pass 366 for base in (object, Classic): 367 class IntOverridesTrunc(base): 368 def __int__(self): 369 return 42 370 def __trunc__(self): 371 return -12 372 self.assertEqual(int(IntOverridesTrunc()), 42) 373 374 class JustTrunc(base): 375 def __trunc__(self): 376 return 42 377 # This fails on Python 2.x: 378 # if not PY26: 379 # self.assertEqual(int(JustTrunc()), 42) 380 381 for trunc_result_base in (object, Classic): 382 class Integral(trunc_result_base): 383 def __int__(self): 384 return 42 385 386 class TruncReturnsNonInt(base): 387 def __trunc__(self): 388 return Integral() 389 # Fails on Python 2.6: 390 # self.assertEqual(int(TruncReturnsNonInt()), 42) 391 392 class NonIntegral(trunc_result_base): 393 def __trunc__(self): 394 # Check that we avoid infinite recursion. 395 return NonIntegral() 396 397 class TruncReturnsNonIntegral(base): 398 def __trunc__(self): 399 return NonIntegral() 400 try: 401 int(TruncReturnsNonIntegral()) 402 except TypeError as e: 403 # self.assertEqual(str(e), 404 # "__trunc__ returned non-Integral" 405 # " (type NonIntegral)") 406 pass 407 else: 408 self.fail("Failed to raise TypeError with %s" % 409 ((base, trunc_result_base),)) 410 411 # Regression test for bugs.python.org/issue16060. 412 class BadInt(trunc_result_base): 413 def __int__(self): 414 return 42.0 415 416 class TruncReturnsBadInt(base): 417 def __trunc__(self): 418 return BadInt() 419 420 with self.assertRaises(TypeError): 421 int(TruncReturnsBadInt()) 422 423 #################################################################### 424 # future-specific tests are below: 425 #################################################################### 426 427 # Exception messages in Py2 are 8-bit strings. The following fails, 428 # even if the testlist strings are wrapped in str() calls... 429 @expectedFailurePY2 430 def test_error_message(self): 431 testlist = ('\xbd', '123\xbd', ' 123 456 ') 432 for s in testlist: 433 try: 434 int(s) 435 except ValueError as e: 436 self.assertIn(s.strip(), e.args[0]) 437 else: 438 self.fail("Expected int(%r) to raise a ValueError", s) 439 440 def test_bytes_mul(self): 441 self.assertEqual(b'\x00' * int(5), b'\x00' * 5) 442 self.assertEqual(bytes(b'\x00') * int(5), bytes(b'\x00') * 5) 443 444 def test_str_mul(self): 445 self.assertEqual(u'\x00' * int(5), u'\x00' * 5) 446 self.assertEqual(str(u'\x00') * int(5), str(u'\x00') * 5) 447 448 def test_int_bytes(self): 449 self.assertEqual(int(b'a\r\n', 16), 10) 450 self.assertEqual(int(bytes(b'a\r\n'), 16), 10) 451 452 def test_divmod(self): 453 """ 454 Test int.__divmod__ 455 """ 456 vals = [10**i for i in range(0, 20)] 457 for i in range(200): 458 x = random.choice(vals) 459 y = random.choice(vals) 460 assert divmod(int(x), int(y)) == divmod(x, y) 461 assert divmod(int(-x), int(y)) == divmod(-x, y) 462 assert divmod(int(x), int(-y)) == divmod(x, -y) 463 assert divmod(int(-x), int(-y)) == divmod(-x, -y) 464 465 assert divmod(int(x), float(y)) == divmod(x, float(y)) 466 assert divmod(int(-x), float(y)) == divmod(-x, float(y)) 467 assert divmod(int(x), float(-y)) == divmod(x, float(-y)) 468 assert divmod(int(-x), float(-y)) == divmod(-x, float(-y)) 469 470 def _frange(x, y, step): 471 _x = x ; i = 0 472 while _x < y: 473 yield _x 474 i += 1 ; _x = x + i * step 475 476 for i in range(20): 477 for d in _frange(0.005, 5.0, 0.005): 478 self.assertEqual(divmod(int(i), d), divmod(i, d), msg='i={0}; d={1}'.format(i, d)) 479 self.assertEqual(divmod(int(-i), d), divmod(-i, d), msg='i={0}; d={1}'.format(i, d)) 480 self.assertEqual(divmod(int(i), -d), divmod(i, -d), msg='i={0}; d={1}'.format(i, d)) 481 self.assertEqual(divmod(int(-i), -d), divmod(-i, -d), msg='i={0}; d={1}'.format(i, d)) 482 483 def test_div(self): 484 """ 485 Issue #38 486 """ 487 a = int(3) 488 self.assertEqual(a / 5., 0.6) 489 self.assertEqual(a / 5, 0.6) # the __future__.division import is in 490 # effect 491 492 def test_truediv(self): 493 """ 494 Test int.__truediv__ and friends (rtruediv, itruediv) 495 """ 496 a = int(3) 497 self.assertEqual(a / 2, 1.5) # since "from __future__ import division" 498 # is in effect 499 self.assertEqual(type(a / 2), float) 500 501 b = int(2) 502 self.assertEqual(a / b, 1.5) # since "from __future__ import division" 503 # is in effect 504 self.assertEqual(type(a / b), float) 505 506 c = int(3) / b 507 self.assertEqual(c, 1.5) 508 self.assertTrue(isinstance(c, float)) 509 510 d = int(5) 511 d /= 5 512 self.assertEqual(d, 1.0) 513 self.assertTrue(isinstance(d, float)) 514 515 e = int(10) 516 f = int(20) 517 e /= f 518 self.assertEqual(e, 0.5) 519 self.assertTrue(isinstance(e, float)) 520 521 522 def test_idiv(self): 523 a = int(3) 524 a /= 2 525 self.assertEqual(a, 1.5) 526 self.assertTrue(isinstance(a, float)) 527 b = int(10) 528 b /= 2 529 self.assertEqual(b, 5.0) 530 self.assertTrue(isinstance(b, float)) 531 c = int(-3) 532 c /= 2.0 533 self.assertEqual(c, -1.5) 534 self.assertTrue(isinstance(c, float)) 535 536 def test_floordiv(self): 537 a = int(3) 538 self.assertEqual(a // 2, 1) 539 self.assertEqual(type(a // 2), int) # i.e. another newint 540 self.assertTrue(isinstance(a // 2, int)) 541 542 b = int(2) 543 self.assertEqual(a // b, 1) 544 self.assertEqual(type(a // b), int) # i.e. another newint 545 self.assertTrue(isinstance(a // b, int)) 546 547 c = 3 // b 548 self.assertEqual(c, 1) 549 self.assertEqual(type(c), int) # i.e. another newint 550 self.assertTrue(isinstance(c, int)) 551 552 d = int(5) 553 d //= 5 554 self.assertEqual(d, 1) 555 self.assertEqual(type(d), int) # i.e. another newint 556 self.assertTrue(isinstance(d, int)) 557 558 e = int(10) 559 f = int(20) 560 e //= f 561 self.assertEqual(e, 0) 562 self.assertEqual(type(e), int) # i.e. another newint 563 self.assertTrue(isinstance(e, int)) 564 565 566 def test_div(self): 567 """ 568 Issue #38 569 """ 570 a = int(3) 571 self.assertEqual(a / 5., 0.6) 572 self.assertEqual(a / 5, 0.6) # the __future__.division import is in 573 # effect 574 575 def test_truediv(self): 576 """ 577 Test int.__truediv__ and friends (rtruediv, itruediv) 578 """ 579 a = int(3) 580 self.assertEqual(a / 2, 1.5) # since "from __future__ import division" 581 # is in effect 582 self.assertEqual(type(a / 2), float) 583 584 b = int(2) 585 self.assertEqual(a / b, 1.5) # since "from __future__ import division" 586 # is in effect 587 self.assertEqual(type(a / b), float) 588 589 c = int(3) / b 590 self.assertEqual(c, 1.5) 591 self.assertTrue(isinstance(c, float)) 592 593 d = int(5) 594 d /= 5 595 self.assertEqual(d, 1.0) 596 self.assertTrue(isinstance(d, float)) 597 598 e = int(10) 599 f = int(20) 600 e /= f 601 self.assertEqual(e, 0.5) 602 self.assertTrue(isinstance(e, float)) 603 604 605 def test_idiv(self): 606 a = int(3) 607 a /= 2 608 self.assertEqual(a, 1.5) 609 self.assertTrue(isinstance(a, float)) 610 b = int(10) 611 b /= 2 612 self.assertEqual(b, 5.0) 613 self.assertTrue(isinstance(b, float)) 614 c = int(-3) 615 c /= 2.0 616 self.assertEqual(c, -1.5) 617 self.assertTrue(isinstance(c, float)) 618 619 620 def test_floordiv(self): 621 a = int(3) 622 self.assertEqual(a // 2, 1) 623 self.assertEqual(type(a // 2), int) # i.e. another newint 624 self.assertTrue(isinstance(a // 2, int)) 625 626 b = int(2) 627 self.assertEqual(a // b, 1) 628 self.assertEqual(type(a // b), int) # i.e. another newint 629 self.assertTrue(isinstance(a // b, int)) 630 631 c = 3 // b 632 self.assertEqual(c, 1) 633 self.assertEqual(type(c), int) # i.e. another newint 634 self.assertTrue(isinstance(c, int)) 635 636 d = int(5) 637 d //= 5 638 self.assertEqual(d, 1) 639 self.assertEqual(type(d), int) # i.e. another newint 640 self.assertTrue(isinstance(d, int)) 641 642 e = int(10) 643 f = int(20) 644 e //= f 645 self.assertEqual(e, 0) 646 self.assertEqual(type(e), int) # i.e. another newint 647 self.assertTrue(isinstance(e, int)) 648 649 @unittest.skipIf(np is None, "test requires NumPy") 650 @unittest.expectedFailure 651 def test_numpy_cast_as_long_and_newint(self): 652 """ 653 NumPy currently doesn't like subclasses of ``long``. This should be fixed. 654 """ 655 class longsubclass(long): 656 pass 657 658 a = np.arange(10**3, dtype=np.float64).reshape(10, 100) 659 b = a.astype(longsubclass) 660 c = a.astype(int) 661 print(b.dtype) 662 assert b.dtype == np.int64 == c.dtype 663 664 def test_upcasting_to_floats(self): 665 """ 666 Integers should automatically be upcasted to floats for arithmetic 667 operations. 668 """ 669 a = int(3) 670 671 # Addition with floats. 672 self.assertEqual(a + 0.5, 3.5) 673 self.assertEqual(0.5 + a, 3.5) 674 self.assertTrue(isinstance(a + 0.5, float)) 675 self.assertTrue(isinstance(0.5 + a, float)) 676 677 # Subtraction with floats. 678 self.assertEqual(a - 0.5, 2.5) 679 self.assertEqual(0.5 - a, -2.5) 680 self.assertTrue(isinstance(a - 0.5, float)) 681 self.assertTrue(isinstance(0.5 - a, float)) 682 683 # Multiplication with floats. 684 self.assertEqual(a * 0.5, 1.5) 685 self.assertEqual(0.5 * a, 1.5) 686 self.assertTrue(isinstance(a * 0.5, float)) 687 self.assertTrue(isinstance(0.5 * a, float)) 688 689 # Division with floats. 690 self.assertEqual(a / 0.5, 6.0) 691 self.assertEqual(0.5 / a, 0.5 / 3.0) 692 self.assertTrue(isinstance(a / 0.5, float)) 693 self.assertTrue(isinstance(0.5 / a, float)) 694 695 # Modulo with floats. 696 self.assertEqual(a % 0.5, 0.0) 697 self.assertEqual(0.5 % a, 0.5) 698 self.assertTrue(isinstance(a % 0.5, float)) 699 self.assertTrue(isinstance(0.5 % a, float)) 700 701 # Power with floats. 702 self.assertEqual(1.0 ** a, 1.0) 703 self.assertTrue(isinstance(1.0 ** a, float)) 704 705 self.assertEqual(a ** 1.0, a) 706 self.assertTrue(isinstance(a ** 1.0, float)) 707 708 def test_upcasting_to_complex(self): 709 """ 710 Integers should automatically be upcasted to complex numbers for 711 arithmetic operations. 712 713 Python 3 cannot mod complex numbers so this does not have to be 714 supported here. 715 """ 716 a = int(3) 717 718 # Addition with complex. 719 self.assertEqual(a + 0.5j, 3.0 + 0.5j) 720 self.assertEqual(0.5j + a, 3.0 + 0.5j) 721 self.assertTrue(isinstance(a + 0.5j, complex)) 722 self.assertTrue(isinstance(0.5j + a, complex)) 723 724 # Subtraction with complex. 725 self.assertEqual(a - 0.5j, 3.0 - 0.5j) 726 self.assertEqual(0.5j - a, -3.0 + 0.5j) 727 self.assertTrue(isinstance(a - 0.5j, complex)) 728 self.assertTrue(isinstance(0.5j - a, complex)) 729 730 # Multiplication with complex. 731 self.assertEqual(a * 0.5j, 1.5j) 732 self.assertEqual(0.5j * a, 1.5j) 733 self.assertTrue(isinstance(a * 0.5j, complex)) 734 self.assertTrue(isinstance(0.5j * a, complex)) 735 736 # Division with complex. 737 self.assertEqual(a / 0.5j, -6.0j) 738 self.assertEqual(0.5j / a, (0.5 / 3.0) * 1j) 739 self.assertTrue(isinstance(a / 0.5j, complex)) 740 self.assertTrue(isinstance(0.5j / a, complex)) 741 742 # Power with floats. 743 self.assertEqual(5.0j ** int(1), 5.0j) 744 self.assertTrue(isinstance(5.0j ** int(1), complex)) 745 746 self.assertEqual(a ** 1.0j, 3.0 ** 1.0j) 747 self.assertTrue(isinstance(a ** 1.0j, complex)) 748 749 def test_more_arithmetics(self): 750 """ 751 More arithmetic tests to improve test coverage. 752 """ 753 a = int(3) 754 b = int(5) 755 c = int(-5) 756 757 self.assertEqual(b - a, 2) 758 self.assertTrue(isinstance(b - a, int)) 759 760 self.assertEqual(a * b, 15) 761 self.assertTrue(isinstance(a * b, int)) 762 763 self.assertEqual(b % a, 2) 764 self.assertTrue(isinstance(b % a, int)) 765 766 self.assertEqual(a ** b, 243) 767 self.assertTrue(isinstance(a ** b, int)) 768 769 self.assertEqual(abs(c), 5) 770 self.assertEqual(abs(c), b) 771 self.assertTrue(isinstance(abs(c), int)) 772 773 def test_bitwise_operations(self): 774 """ 775 Tests bitwise operations. 776 """ 777 a = int(3) 778 b = int(1) 779 780 self.assertEqual(a >> b, 1) 781 self.assertEqual(a >> 1, 1) 782 self.assertTrue(isinstance(a >> b, int)) 783 self.assertTrue(isinstance(a >> 1, int)) 784 785 self.assertEqual(a << b, 6) 786 self.assertEqual(a << 1, 6) 787 self.assertTrue(isinstance(a << b, int)) 788 self.assertTrue(isinstance(a << 1, int)) 789 790 self.assertEqual(a & b, 1) 791 self.assertEqual(a & 1, 1) 792 self.assertTrue(isinstance(a & b, int)) 793 self.assertTrue(isinstance(a & 1, int)) 794 795 self.assertEqual(a | b, 3) 796 self.assertEqual(a | 1, 3) 797 self.assertTrue(isinstance(a | b, int)) 798 self.assertTrue(isinstance(a | 1, int)) 799 800 self.assertEqual(a ^ b, 2) 801 self.assertEqual(a ^ 1, 2) 802 self.assertTrue(isinstance(a ^ b, int)) 803 self.assertTrue(isinstance(a ^ 1, int)) 804 805 self.assertEqual(~a, -4) 806 self.assertTrue(isinstance(~a, int)) 807 808 def test_unary_operators(self): 809 a = int(3) 810 b = int(-3) 811 812 self.assertEqual(+a, a) 813 self.assertEqual(+a, 3) 814 self.assertEqual(+b, b) 815 self.assertEqual(+b, -3) 816 self.assertTrue(isinstance(+a, int)) 817 818 self.assertEqual(-a, b) 819 self.assertEqual(-a, -3) 820 self.assertEqual(-b, a) 821 self.assertEqual(-b, 3) 822 self.assertTrue(isinstance(-a, int)) 823 824 def test_to_bytes(self): 825 def check(tests, byteorder, signed=False): 826 for test, expected in tests.items(): 827 try: 828 self.assertEqual( 829 int(test).to_bytes(len(expected), byteorder, signed=signed), 830 expected) 831 except Exception as err: 832 raise_from(AssertionError( 833 "failed to convert {0} with byteorder={1} and signed={2}" 834 .format(test, byteorder, signed)), err) 835 836 # Convert integers to signed big-endian byte arrays. 837 tests1 = { 838 0: bytes(b'\x00'), 839 1: bytes(b'\x01'), 840 -1: bytes(b'\xff'), 841 -127: bytes(b'\x81'), 842 -128: bytes(b'\x80'), 843 -129: bytes(b'\xff\x7f'), 844 127: bytes(b'\x7f'), 845 129: bytes(b'\x00\x81'), 846 -255: bytes(b'\xff\x01'), 847 -256: bytes(b'\xff\x00'), 848 255: bytes(b'\x00\xff'), 849 256: bytes(b'\x01\x00'), 850 32767: bytes(b'\x7f\xff'), 851 -32768: bytes(b'\xff\x80\x00'), 852 65535: bytes(b'\x00\xff\xff'), 853 -65536: bytes(b'\xff\x00\x00'), 854 -8388608: bytes(b'\x80\x00\x00') 855 } 856 check(tests1, 'big', signed=True) 857 858 # Convert integers to signed little-endian byte arrays. 859 tests2 = { 860 0: bytes(b'\x00'), 861 1: bytes(b'\x01'), 862 -1: bytes(b'\xff'), 863 -127: bytes(b'\x81'), 864 -128: bytes(b'\x80'), 865 -129: bytes(b'\x7f\xff'), 866 127: bytes(b'\x7f'), 867 129: bytes(b'\x81\x00'), 868 -255: bytes(b'\x01\xff'), 869 -256: bytes(b'\x00\xff'), 870 255: bytes(b'\xff\x00'), 871 256: bytes(b'\x00\x01'), 872 32767: bytes(b'\xff\x7f'), 873 -32768: bytes(b'\x00\x80'), 874 65535: bytes(b'\xff\xff\x00'), 875 -65536: bytes(b'\x00\x00\xff'), 876 -8388608: bytes(b'\x00\x00\x80') 877 } 878 check(tests2, 'little', signed=True) 879 880 # Convert integers to unsigned big-endian byte arrays. 881 tests3 = { 882 0: bytes(b'\x00'), 883 1: bytes(b'\x01'), 884 127: bytes(b'\x7f'), 885 128: bytes(b'\x80'), 886 255: bytes(b'\xff'), 887 256: bytes(b'\x01\x00'), 888 32767: bytes(b'\x7f\xff'), 889 32768: bytes(b'\x80\x00'), 890 65535: bytes(b'\xff\xff'), 891 65536: bytes(b'\x01\x00\x00') 892 } 893 check(tests3, 'big', signed=False) 894 895 # Convert integers to unsigned little-endian byte arrays. 896 tests4 = { 897 0: bytes(b'\x00'), 898 1: bytes(b'\x01'), 899 127: bytes(b'\x7f'), 900 128: bytes(b'\x80'), 901 255: bytes(b'\xff'), 902 256: bytes(b'\x00\x01'), 903 32767: bytes(b'\xff\x7f'), 904 32768: bytes(b'\x00\x80'), 905 65535: bytes(b'\xff\xff'), 906 65536: bytes(b'\x00\x00\x01') 907 } 908 check(tests4, 'little', signed=False) 909 910 self.assertRaises(OverflowError, int(256).to_bytes, 1, 'big', signed=False) 911 self.assertRaises(OverflowError, int(256).to_bytes, 1, 'big', signed=True) 912 self.assertRaises(OverflowError, int(256).to_bytes, 1, 'little', signed=False) 913 self.assertRaises(OverflowError, int(256).to_bytes, 1, 'little', signed=True) 914 self.assertRaises(OverflowError, int(-1).to_bytes, 2, 'big', signed=False), 915 self.assertRaises(OverflowError, int(-1).to_bytes, 2, 'little', signed=False) 916 self.assertEqual(int(0).to_bytes(0, 'big'), b'') 917 self.assertEqual(int(1).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x01') 918 self.assertEqual(int(0).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x00') 919 self.assertEqual(int(-1).to_bytes(5, 'big', signed=True), 920 bytes(b'\xff\xff\xff\xff\xff')) 921 self.assertRaises(OverflowError, int(1).to_bytes, 0, 'big') 922 923 def test_from_bytes(self): 924 def check(tests, byteorder, signed=False): 925 for test, expected in tests.items(): 926 try: 927 self.assertEqual( 928 int.from_bytes(test, byteorder, signed=signed), 929 int(expected)) 930 except Exception as err: 931 raise_from(AssertionError( 932 "failed to convert {0} with byteorder={1!r} and signed={2}" 933 .format(test, byteorder, signed)), err) 934 935 # Convert signed big-endian byte arrays to integers. 936 tests1 = { 937 bytes(b''): 0, 938 bytes(b'\x00'): 0, 939 bytes(b'\x00\x00'): 0, 940 bytes(b'\x01'): 1, 941 bytes(b'\x00\x01'): 1, 942 bytes(b'\xff'): -1, 943 bytes(b'\xff\xff'): -1, 944 bytes(b'\x81'): -127, 945 bytes(b'\x80'): -128, 946 bytes(b'\xff\x7f'): -129, 947 bytes(b'\x7f'): 127, 948 bytes(b'\x00\x81'): 129, 949 bytes(b'\xff\x01'): -255, 950 bytes(b'\xff\x00'): -256, 951 bytes(b'\x00\xff'): 255, 952 bytes(b'\x01\x00'): 256, 953 bytes(b'\x7f\xff'): 32767, 954 bytes(b'\x80\x00'): -32768, 955 bytes(b'\x00\xff\xff'): 65535, 956 bytes(b'\xff\x00\x00'): -65536, 957 bytes(b'\x80\x00\x00'): -8388608 958 } 959 # check(tests1, 'big', signed=True) 960 961 # Convert signed little-endian byte arrays to integers. 962 tests2 = { 963 bytes(b''): 0, 964 bytes(b'\x00'): 0, 965 bytes(b'\x00\x00'): 0, 966 bytes(b'\x01'): 1, 967 bytes(b'\x00\x01'): 256, 968 bytes(b'\xff'): -1, 969 bytes(b'\xff\xff'): -1, 970 bytes(b'\x81'): -127, 971 bytes(b'\x80'): -128, 972 bytes(b'\x7f\xff'): -129, 973 bytes(b'\x7f'): 127, 974 bytes(b'\x81\x00'): 129, 975 bytes(b'\x01\xff'): -255, 976 bytes(b'\x00\xff'): -256, 977 bytes(b'\xff\x00'): 255, 978 bytes(b'\x00\x01'): 256, 979 bytes(b'\xff\x7f'): 32767, 980 bytes(b'\x00\x80'): -32768, 981 bytes(b'\xff\xff\x00'): 65535, 982 bytes(b'\x00\x00\xff'): -65536, 983 bytes(b'\x00\x00\x80'): -8388608 984 } 985 # check(tests2, 'little', signed=True) 986 987 # Convert unsigned big-endian byte arrays to integers. 988 tests3 = { 989 bytes(b''): 0, 990 bytes(b'\x00'): 0, 991 bytes(b'\x01'): 1, 992 bytes(b'\x7f'): 127, 993 bytes(b'\x80'): 128, 994 bytes(b'\xff'): 255, 995 bytes(b'\x01\x00'): 256, 996 bytes(b'\x7f\xff'): 32767, 997 bytes(b'\x80\x00'): 32768, 998 bytes(b'\xff\xff'): 65535, 999 bytes(b'\x01\x00\x00'): 65536, 1000 } 1001 check(tests3, 'big', signed=False) 1002 1003 # Convert integers to unsigned little-endian byte arrays. 1004 tests4 = { 1005 bytes(b''): 0, 1006 bytes(b'\x00'): 0, 1007 bytes(b'\x01'): 1, 1008 bytes(b'\x7f'): 127, 1009 bytes(b'\x80'): 128, 1010 bytes(b'\xff'): 255, 1011 bytes(b'\x00\x01'): 256, 1012 bytes(b'\xff\x7f'): 32767, 1013 bytes(b'\x00\x80'): 32768, 1014 bytes(b'\xff\xff'): 65535, 1015 bytes(b'\x00\x00\x01'): 65536, 1016 } 1017 check(tests4, 'little', signed=False) 1018 1019 class myint(int): 1020 pass 1021 1022 if PY2: 1023 import __builtin__ 1024 oldbytes = __builtin__.bytes 1025 types = (bytes, oldbytes) 1026 else: 1027 types = (bytes,) 1028 for mytype in types: 1029 self.assertIs(type(myint.from_bytes(mytype(b'\x00'), 'big')), myint) 1030 self.assertEqual(myint.from_bytes(mytype(b'\x01'), 'big'), 1) 1031 self.assertIs( 1032 type(myint.from_bytes(mytype(b'\x00'), 'big', signed=False)), myint) 1033 self.assertEqual(myint.from_bytes(mytype(b'\x01'), 'big', signed=False), 1) 1034 self.assertIs(type(myint.from_bytes(mytype(b'\x00'), 'little')), myint) 1035 self.assertEqual(myint.from_bytes(mytype(b'\x01'), 'little'), 1) 1036 self.assertIs(type(myint.from_bytes( 1037 mytype(b'\x00'), 'little', signed=False)), myint) 1038 self.assertEqual(myint.from_bytes(mytype(b'\x01'), 'little', signed=False), 1) 1039 # self.assertEqual( 1040 # int.from_bytes([255, 0, 0], 'big', signed=True), -65536) 1041 # self.assertEqual( 1042 # int.from_bytes((255, 0, 0), 'big', signed=True), -65536) 1043 # self.assertEqual(int.from_bytes( 1044 # bytearray(mytype(b'\xff\x00\x00')), 'big', signed=True), -65536) 1045 # self.assertEqual(int.from_bytes( 1046 # bytearray(mytype(b'\xff\x00\x00')), 'big', signed=True), -65536) 1047 # self.assertEqual(int.from_bytes( 1048 # array.array('B', mytype(b'\xff\x00\x00')), 'big', signed=True), -65536) 1049 # self.assertEqual(int.from_bytes( 1050 # memoryview(mytype(b'\xff\x00\x00')), 'big', signed=True), -65536) 1051 1052 self.assertRaises(TypeError, int.from_bytes, u"", 'big') 1053 self.assertRaises(TypeError, int.from_bytes, u"\x00", 'big') 1054 self.assertRaises(TypeError, myint.from_bytes, u"", 'big') 1055 self.assertRaises(TypeError, myint.from_bytes, u"\x00", 'big') 1056 1057 types = (int, lambda x: x) if PY2 else (lambda x: x,) 1058 for mytype in types: 1059 self.assertRaises(ValueError, int.from_bytes, [mytype(256)], 'big') 1060 self.assertRaises(ValueError, int.from_bytes, [mytype(0)], 'big\x00') 1061 self.assertRaises(ValueError, int.from_bytes, [mytype(0)], 'little\x00') 1062 self.assertRaises(TypeError, int.from_bytes, mytype(0), 'big') 1063 # self.assertRaises(TypeError, int.from_bytes, mytype(0), 'big', True) 1064 self.assertRaises(TypeError, myint.from_bytes, mytype(0), 'big') 1065 # self.assertRaises(TypeError, int.from_bytes, mytype(0), 'big', True) 1066 1067 @expectedFailurePY2 1068 def test_multiple_inheritance(self): 1069 """ 1070 Issue #96 (for newint instead of newobject) 1071 """ 1072 import collections.abc 1073 1074 class Base(int): 1075 pass 1076 1077 class Foo(Base, collections.abc.Container): 1078 def __add__(self, other): 1079 return 0 1080 1081 @expectedFailurePY2 1082 def test_with_metaclass_and_int(self): 1083 """ 1084 Issue #91 (for newint instead of newobject) 1085 """ 1086 from future.utils import with_metaclass 1087 1088 class MetaClass(type): 1089 pass 1090 1091 class TestClass(with_metaclass(MetaClass, int)): 1092 pass 1093 1094 1095if __name__ == "__main__": 1096 unittest.main() 1097