Lines Matching refs:self
123 def getran(self, ndigits):
124 self.assertGreater(ndigits, 0)
133 self.assertTrue(1 <= bits <= SHIFT)
139 self.assertTrue(nbits_lo <= nbits <= nbits_hi)
155 def check_division(self, x, y):
156 eq = self.assertEqual
157 with self.subTest(x=x, y=y):
166 self.assertTrue(0 <= r < y, "bad mod from divmod")
168 self.assertTrue(y < r <= 0, "bad mod from divmod")
170 def test_division(self):
175 x = self.getran(lenx)
177 y = self.getran(leny) or 1
178 self.check_division(x, y)
184 self.check_division(1231948412290879395966702881,
186 self.check_division(815427756481275430342312021515587883,
188 self.check_division(627976073697012820849443363563599041,
190 self.check_division(1115141373653752303710932756325578065,
193 self.check_division(922498905405436751940989320930368494,
195 self.check_division(768235853328091167204009652174031844,
199 self.check_division(20172188947443, 615611397)
200 self.check_division(1020908530270155025, 950795710)
201 self.check_division(128589565723112408, 736393718)
202 self.check_division(609919780285761575, 18613274546784)
204 self.check_division(710031681576388032, 26769404391308)
205 self.check_division(1933622614268221, 30212853348836)
209 def test_karatsuba(self):
223 with self.subTest(abits=abits, bbits=bbits):
230 self.assertEqual(x, y)
232 def check_bitop_identities_1(self, x):
233 eq = self.assertEqual
234 with self.subTest(x=x):
252 with self.subTest(x=x, n=n, p2=p2):
259 def check_bitop_identities_2(self, x, y):
260 eq = self.assertEqual
261 with self.subTest(x=x, y=y):
272 def check_bitop_identities_3(self, x, y, z):
273 eq = self.assertEqual
274 with self.subTest(x=x, y=y, z=z):
281 def test_bitop_identities(self):
283 self.check_bitop_identities_1(x)
286 x = self.getran(lenx)
287 self.check_bitop_identities_1(x)
289 y = self.getran(leny)
290 self.check_bitop_identities_2(x, y)
291 self.check_bitop_identities_3(x, y, self.getran((lenx + leny)//2))
293 def slow_format(self, x, base):
307 def check_format_1(self, x):
310 with self.subTest(x=x, mapper=mapper.__name__):
311 expected = self.slow_format(x, base)
312 self.assertEqual(got, expected)
313 with self.subTest(got=got):
314 self.assertEqual(int(got, 0), x)
316 def test_format(self):
318 self.check_format_1(x)
321 x = self.getran(lenx)
322 self.check_format_1(x)
324 def test_long(self):
338 self.assertEqual(int(ss), vv)
343 self.assertRaises(ValueError, int, '123L')
344 self.assertRaises(ValueError, int, '123l')
345 self.assertRaises(ValueError, int, '0L')
346 self.assertRaises(ValueError, int, '-37L')
347 self.assertRaises(ValueError, int, '0x32L', 16)
348 self.assertRaises(ValueError, int, '1L', 21)
350 self.assertEqual(int('1L', 22), 43)
353 self.assertEqual(int('000', 0), 0)
354 self.assertEqual(int('0o123', 0), 83)
355 self.assertEqual(int('0x123', 0), 291)
356 self.assertEqual(int('0b100', 0), 4)
357 self.assertEqual(int(' 0O123 ', 0), 83)
358 self.assertEqual(int(' 0X123 ', 0), 291)
359 self.assertEqual(int(' 0B100 ', 0), 4)
360 self.assertEqual(int('0', 0), 0)
361 self.assertEqual(int('+0', 0), 0)
362 self.assertEqual(int('-0', 0), 0)
363 self.assertEqual(int('00', 0), 0)
364 self.assertRaises(ValueError, int, '08', 0)
365 self.assertRaises(ValueError, int, '-012395', 0)
374 self.assertRaises(ValueError, int, '42', base)
378 self.assertRaises(ValueError, int, '\u3053\u3093\u306b\u3061\u306f')
381 def test_conversion(self):
385 def __long__(self):
387 self.assertRaises(TypeError, int, JustLong())
391 def __long__(self):
393 def __trunc__(self):
395 with self.assertWarns(DeprecationWarning):
396 self.assertEqual(int(LongTrunc()), 1729)
398 def check_float_conversion(self, n):
413 self.assertEqual(actual, expected, msg)
416 def test_float_conversion(self):
429 self.assertEqual(float(x), x)
430 self.assertEqual(float(-x), -x)
435 self.assertEqual(int(float(2**p*(2**53+x))), 2**p*(2**53+y))
441 self.assertEqual(int(float(2**p*(2**54+x))), 2**p*(2**54+y))
447 self.assertEqual(float(int_dbl_max), DBL_MAX)
448 self.assertEqual(float(int_dbl_max+1), DBL_MAX)
449 self.assertEqual(float(halfway-1), DBL_MAX)
450 self.assertRaises(OverflowError, float, halfway)
451 self.assertEqual(float(1-halfway), -DBL_MAX)
452 self.assertRaises(OverflowError, float, -halfway)
453 self.assertRaises(OverflowError, float, top_power-1)
454 self.assertRaises(OverflowError, float, top_power)
455 self.assertRaises(OverflowError, float, top_power+1)
456 self.assertRaises(OverflowError, float, 2*top_power-1)
457 self.assertRaises(OverflowError, float, 2*top_power)
458 self.assertRaises(OverflowError, float, top_power*top_power)
463 self.assertEqual(int(float(x)), y)
467 self.assertEqual(int(float(x)), y)
482 self.check_float_conversion(value)
483 self.check_float_conversion(-value)
485 def test_float_overflow(self):
487 self.assertEqual(float(int(x)), x)
509 self.assertRaises(OverflowError, eval, test, namespace)
513 self.assertNotEqual(float(shuge), int(shuge),
516 def test_logs(self):
522 self.assertAlmostEqual(log10, exp)
528 self.assertAlmostEqual(log, expected)
531 self.assertRaises(ValueError, math.log, bad)
532 self.assertRaises(ValueError, math.log10, bad)
534 def test_mixed_compares(self):
535 eq = self.assertEqual
543 def __init__(self, value):
545 self.n = value
546 self.d = 1
577 self.n = n
578 self.d = d
583 def _cmp__(self, other):
586 x, y = self.n * other.d, self.d * other.n
588 def __eq__(self, other):
589 return self._cmp__(other) == 0
590 def __ge__(self, other):
591 return self._cmp__(other) >= 0
592 def __gt__(self, other):
593 return self._cmp__(other) > 0
594 def __le__(self, other):
595 return self._cmp__(other) <= 0
596 def __lt__(self, other):
597 return self._cmp__(other) < 0
616 with self.subTest(x=x, y=y, Rcmp=Rcmp):
626 def test__format__(self):
627 self.assertEqual(format(123456789, 'd'), '123456789')
628 self.assertEqual(format(123456789, 'd'), '123456789')
629 self.assertEqual(format(123456789, ','), '123,456,789')
630 self.assertEqual(format(123456789, '_'), '123_456_789')
633 self.assertEqual(format(1, "-"), '1')
634 self.assertEqual(format(-1, "-"), '-1')
635 self.assertEqual(format(1, "-3"), ' 1')
636 self.assertEqual(format(-1, "-3"), ' -1')
637 self.assertEqual(format(1, "+3"), ' +1')
638 self.assertEqual(format(-1, "+3"), ' -1')
639 self.assertEqual(format(1, " 3"), ' 1')
640 self.assertEqual(format(-1, " 3"), ' -1')
641 self.assertEqual(format(1, " "), ' 1')
642 self.assertEqual(format(-1, " "), '-1')
645 self.assertEqual(format(3, "x"), "3")
646 self.assertEqual(format(3, "X"), "3")
647 self.assertEqual(format(1234, "x"), "4d2")
648 self.assertEqual(format(-1234, "x"), "-4d2")
649 self.assertEqual(format(1234, "8x"), " 4d2")
650 self.assertEqual(format(-1234, "8x"), " -4d2")
651 self.assertEqual(format(1234, "x"), "4d2")
652 self.assertEqual(format(-1234, "x"), "-4d2")
653 self.assertEqual(format(-3, "x"), "-3")
654 self.assertEqual(format(-3, "X"), "-3")
655 self.assertEqual(format(int('be', 16), "x"), "be")
656 self.assertEqual(format(int('be', 16), "X"), "BE")
657 self.assertEqual(format(-int('be', 16), "x"), "-be")
658 self.assertEqual(format(-int('be', 16), "X"), "-BE")
659 self.assertRaises(ValueError, format, 1234567890, ',x')
660 self.assertEqual(format(1234567890, '_x'), '4996_02d2')
661 self.assertEqual(format(1234567890, '_X'), '4996_02D2')
664 self.assertEqual(format(3, "o"), "3")
665 self.assertEqual(format(-3, "o"), "-3")
666 self.assertEqual(format(1234, "o"), "2322")
667 self.assertEqual(format(-1234, "o"), "-2322")
668 self.assertEqual(format(1234, "-o"), "2322")
669 self.assertEqual(format(-1234, "-o"), "-2322")
670 self.assertEqual(format(1234, " o"), " 2322")
671 self.assertEqual(format(-1234, " o"), "-2322")
672 self.assertEqual(format(1234, "+o"), "+2322")
673 self.assertEqual(format(-1234, "+o"), "-2322")
674 self.assertRaises(ValueError, format, 1234567890, ',o')
675 self.assertEqual(format(1234567890, '_o'), '111_4540_1322')
678 self.assertEqual(format(3, "b"), "11")
679 self.assertEqual(format(-3, "b"), "-11")
680 self.assertEqual(format(1234, "b"), "10011010010")
681 self.assertEqual(format(-1234, "b"), "-10011010010")
682 self.assertEqual(format(1234, "-b"), "10011010010")
683 self.assertEqual(format(-1234, "-b"), "-10011010010")
684 self.assertEqual(format(1234, " b"), " 10011010010")
685 self.assertEqual(format(-1234, " b"), "-10011010010")
686 self.assertEqual(format(1234, "+b"), "+10011010010")
687 self.assertEqual(format(-1234, "+b"), "-10011010010")
688 self.assertRaises(ValueError, format, 1234567890, ',b')
689 self.assertEqual(format(12345, '_b'), '11_0000_0011_1001')
692 self.assertRaises(ValueError, format, 3, "1.3") # precision disallowed
693 self.assertRaises(ValueError, format, 3, "_c") # underscore,
694 self.assertRaises(ValueError, format, 3, ",c") # comma, and
695 self.assertRaises(ValueError, format, 3, "+c") # sign not allowed
698 self.assertRaisesRegex(ValueError, 'Cannot specify both', format, 3, '_,')
699 self.assertRaisesRegex(ValueError, 'Cannot specify both', format, 3, ',_')
700 self.assertRaisesRegex(ValueError, 'Cannot specify both', format, 3, '_,d')
701 self.assertRaisesRegex(ValueError, 'Cannot specify both', format, 3, ',_d')
703 self.assertRaisesRegex(ValueError, "Cannot specify ',' with 's'", format, 3, ',s')
704 self.assertRaisesRegex(ValueError, "Cannot specify '_' with 's'", format, 3, '_s')
710 self.assertRaises(ValueError, format, 0, format_spec)
711 self.assertRaises(ValueError, format, 1, format_spec)
712 self.assertRaises(ValueError, format, -1, format_spec)
713 self.assertRaises(ValueError, format, 2**100, format_spec)
714 self.assertRaises(ValueError, format, -(2**100), format_spec)
720 self.assertEqual(format(value, format_spec),
723 def test_nan_inf(self):
724 self.assertRaises(OverflowError, int, float('inf'))
725 self.assertRaises(OverflowError, int, float('-inf'))
726 self.assertRaises(ValueError, int, float('nan'))
728 def test_mod_division(self):
729 with self.assertRaises(ZeroDivisionError):
732 self.assertEqual(13 % 10, 3)
733 self.assertEqual(-13 % 10, 7)
734 self.assertEqual(13 % -10, -7)
735 self.assertEqual(-13 % -10, -3)
737 self.assertEqual(12 % 4, 0)
738 self.assertEqual(-12 % 4, 0)
739 self.assertEqual(12 % -4, 0)
740 self.assertEqual(-12 % -4, 0)
742 def test_true_division(self):
745 self.assertEqual(huge / huge, 1.0)
746 self.assertEqual(mhuge / mhuge, 1.0)
747 self.assertEqual(huge / mhuge, -1.0)
748 self.assertEqual(mhuge / huge, -1.0)
749 self.assertEqual(1 / huge, 0.0)
750 self.assertEqual(1 / huge, 0.0)
751 self.assertEqual(1 / mhuge, 0.0)
752 self.assertEqual(1 / mhuge, 0.0)
753 self.assertEqual((666 * huge + (huge >> 1)) / huge, 666.5)
754 self.assertEqual((666 * mhuge + (mhuge >> 1)) / mhuge, 666.5)
755 self.assertEqual((666 * huge + (huge >> 1)) / mhuge, -666.5)
756 self.assertEqual((666 * mhuge + (mhuge >> 1)) / huge, -666.5)
757 self.assertEqual(huge / (huge << 1), 0.5)
758 self.assertEqual((1000000 * huge) / huge, 1000000)
765 self.assertRaises(OverflowError, eval, overflow, namespace)
770 self.assertEqual(result, 0.0,
774 self.assertRaises(ZeroDivisionError, eval, zero, namespace)
776 def test_floordiv(self):
777 with self.assertRaises(ZeroDivisionError):
780 self.assertEqual(2 // 3, 0)
781 self.assertEqual(2 // -3, -1)
782 self.assertEqual(-2 // 3, -1)
783 self.assertEqual(-2 // -3, 0)
785 self.assertEqual(-11 // -3, 3)
786 self.assertEqual(-11 // 3, -4)
787 self.assertEqual(11 // -3, -4)
788 self.assertEqual(11 // 3, 3)
790 self.assertEqual(-12 // -3, 4)
791 self.assertEqual(-12 // 3, -4)
792 self.assertEqual(12 // -3, -4)
793 self.assertEqual(12 // 3, 4)
795 def check_truediv(self, a, b, skip_small=True):
822 self.assertEqual(expected, got, "Incorrectly rounded division {}/{}: "
826 def test_correctly_rounded_true_division(self):
833 self.check_truediv(123, 0)
834 self.check_truediv(-456, 0)
835 self.check_truediv(0, 3)
836 self.check_truediv(0, -3)
837 self.check_truediv(0, 0)
839 self.check_truediv(671 * 12345 * 2**DBL_MAX_EXP, 12345)
840 self.check_truediv(12345, 345678 * 2**(DBL_MANT_DIG - DBL_MIN_EXP))
842 self.check_truediv(12345*2**100, 98765)
843 self.check_truediv(12345*2**30, 98765*7**81)
850 self.check_truediv(75312*2**max(exp, 0), 69187*2**max(-exp, 0))
851 self.check_truediv(69187*2**max(exp, 0), 75312*2**max(-exp, 0))
857 self.check_truediv(m*DBL_MIN_OVERFLOW + n, m)
858 self.check_truediv(m*DBL_MIN_OVERFLOW + n, -m)
867 self.check_truediv((2**DBL_MANT_DIG + 1)*12345*2**200 + 2**n,
874 self.check_truediv(1, 2731)
878 self.check_truediv(295147931372582273023, 295147932265116303360)
880 self.check_truediv(10**(i+1), 10**i)
881 self.check_truediv(10**i, 10**(i+1))
887 self.check_truediv(2**DBL_MANT_DIG*m + n, m)
891 self.check_truediv(n, 2**1076)
901 self.check_truediv(a, b)
902 self.check_truediv(-a, b)
903 self.check_truediv(a, -b)
904 self.check_truediv(-a, -b)
912 self.check_truediv(x, y)
913 self.check_truediv(x, -y)
914 self.check_truediv(-x, y)
915 self.check_truediv(-x, -y)
917 def test_negative_shift_count(self):
918 with self.assertRaises(ValueError):
920 with self.assertRaises(ValueError):
922 with self.assertRaises(ValueError):
924 with self.assertRaises(ValueError):
927 def test_lshift_of_zero(self):
928 self.assertEqual(0 << 0, 0)
929 self.assertEqual(0 << 10, 0)
930 with self.assertRaises(ValueError):
932 self.assertEqual(0 << (1 << 1000), 0)
933 with self.assertRaises(ValueError):
937 def test_huge_lshift_of_zero(self):
941 self.assertEqual(0 << sys.maxsize, 0)
942 self.assertEqual(0 << (sys.maxsize + 1), 0)
946 def test_huge_lshift(self, size):
947 self.assertEqual(1 << (sys.maxsize + 1000), 1 << 1000 << sys.maxsize)
949 def test_huge_rshift(self):
951 self.assertEqual(42 >> huge_shift, 0)
952 self.assertEqual((-42) >> huge_shift, -1)
953 self.assertEqual(1123 >> huge_shift, 0)
954 self.assertEqual((-1123) >> huge_shift, -1)
955 self.assertEqual(2**128 >> huge_shift, 0)
956 self.assertEqual(-2**128 >> huge_shift, -1)
960 def test_huge_rshift_of_huge(self, size):
962 self.assertEqual(huge >> (sys.maxsize + 1), (1 << 499) + 5)
963 self.assertEqual(huge >> (sys.maxsize + 1000), 0)
965 def test_small_rshift(self):
966 self.assertEqual(42 >> 1, 21)
967 self.assertEqual((-42) >> 1, -21)
968 self.assertEqual(43 >> 1, 21)
969 self.assertEqual((-43) >> 1, -22)
971 self.assertEqual(1122 >> 1, 561)
972 self.assertEqual((-1122) >> 1, -561)
973 self.assertEqual(1123 >> 1, 561)
974 self.assertEqual((-1123) >> 1, -562)
976 self.assertEqual(2**128 >> 1, 2**127)
977 self.assertEqual(-2**128 >> 1, -2**127)
978 self.assertEqual((2**128 + 1) >> 1, 2**127)
979 self.assertEqual(-(2**128 + 1) >> 1, -2**127 - 1)
981 def test_medium_rshift(self):
982 self.assertEqual(42 >> 9, 0)
983 self.assertEqual((-42) >> 9, -1)
984 self.assertEqual(1122 >> 9, 2)
985 self.assertEqual((-1122) >> 9, -3)
986 self.assertEqual(2**128 >> 9, 2**119)
987 self.assertEqual(-2**128 >> 9, -2**119)
990 self.assertEqual((1 - BASE*BASE) >> SHIFT, -BASE)
991 self.assertEqual((BASE - 1 - BASE*BASE) >> SHIFT, -BASE)
993 def test_big_rshift(self):
994 self.assertEqual(42 >> 32, 0)
995 self.assertEqual((-42) >> 32, -1)
996 self.assertEqual(1122 >> 32, 0)
997 self.assertEqual((-1122) >> 32, -1)
998 self.assertEqual(2**128 >> 32, 2**96)
999 self.assertEqual(-2**128 >> 32, -2**96)
1001 def test_small_lshift(self):
1002 self.assertEqual(42 << 1, 84)
1003 self.assertEqual((-42) << 1, -84)
1004 self.assertEqual(561 << 1, 1122)
1005 self.assertEqual((-561) << 1, -1122)
1006 self.assertEqual(2**127 << 1, 2**128)
1007 self.assertEqual(-2**127 << 1, -2**128)
1009 def test_medium_lshift(self):
1010 self.assertEqual(42 << 9, 21504)
1011 self.assertEqual((-42) << 9, -21504)
1012 self.assertEqual(1122 << 9, 574464)
1013 self.assertEqual((-1122) << 9, -574464)
1015 def test_big_lshift(self):
1016 self.assertEqual(42 << 32, 42 * 2**32)
1017 self.assertEqual((-42) << 32, -42 * 2**32)
1018 self.assertEqual(1122 << 32, 1122 * 2**32)
1019 self.assertEqual((-1122) << 32, -1122 * 2**32)
1020 self.assertEqual(2**128 << 32, 2**160)
1021 self.assertEqual(-2**128 << 32, -2**160)
1024 def test_small_ints_in_huge_calculation(self):
1028 self.assertIs(a + b, 1)
1029 self.assertIs(c - a, 1)
1032 def test_pow_uses_cached_small_ints(self):
1033 self.assertIs(pow(10, 3, 998), 2)
1034 self.assertIs(10 ** 3 % 998, 2)
1036 self.assertIs(a ** p % m, 2)
1038 self.assertIs(pow(2, 31, 2 ** 31 - 1), 1)
1039 self.assertIs(2 ** 31 % (2 ** 31 - 1), 1)
1041 self.assertIs(a ** p % m, 1)
1043 self.assertIs(pow(2, 100, 2**100 - 3), 3)
1044 self.assertIs(2 ** 100 % (2 ** 100 - 3), 3)
1046 self.assertIs(a ** p % m, 3)
1049 def test_divmod_uses_cached_small_ints(self):
1052 self.assertIs((big + 1) % big, 1)
1053 self.assertIs((big + 1) // big, 1)
1054 self.assertIs(big // (big // 2), 2)
1055 self.assertIs(big // (big // -4), -4)
1058 self.assertIs(q, 2)
1059 self.assertIs(r, 3)
1062 self.assertIs(q, -4)
1063 self.assertIs(r, 100)
1066 self.assertIs(q, 3)
1067 self.assertIs(r, -1)
1070 self.assertIs(q, -3)
1071 self.assertIs(r, -1)
1073 def test_small_ints(self):
1075 self.assertIs(i, i + 0)
1076 self.assertIs(i, i * 1)
1077 self.assertIs(i, i - 0)
1078 self.assertIs(i, i // 1)
1079 self.assertIs(i, i & -1)
1080 self.assertIs(i, i | 0)
1081 self.assertIs(i, i ^ 0)
1082 self.assertIs(i, ~~i)
1083 self.assertIs(i, i**1)
1084 self.assertIs(i, int(str(i)))
1085 self.assertIs(i, i<<2>>2, str(i))
1088 self.assertIs(i - i, 0)
1089 self.assertIs(0 * i, 0)
1091 def test_bit_length(self):
1096 self.assertEqual(k, len(bin(x).lstrip('-0b')))
1099 self.assertTrue(2**(k-1) <= abs(x) < 2**k)
1101 self.assertEqual(k, 0)
1108 self.assertEqual(k, 1 + math.floor(
1111 self.assertEqual((0).bit_length(), 0)
1112 self.assertEqual((1).bit_length(), 1)
1113 self.assertEqual((-1).bit_length(), 1)
1114 self.assertEqual((2).bit_length(), 2)
1115 self.assertEqual((-2).bit_length(), 2)
1118 self.assertEqual((a-1).bit_length(), i)
1119 self.assertEqual((1-a).bit_length(), i)
1120 self.assertEqual((a).bit_length(), i+1)
1121 self.assertEqual((-a).bit_length(), i+1)
1122 self.assertEqual((a+1).bit_length(), i+1)
1123 self.assertEqual((-a-1).bit_length(), i+1)
1125 def test_bit_count(self):
1127 self.assertEqual(a.bit_count(), bin(a).count("1"))
1131 self.assertEqual(a.bit_count(), 1)
1132 self.assertEqual((a - 1).bit_count(), exp)
1133 self.assertEqual((a ^ 63).bit_count(), 7)
1134 self.assertEqual(((a - 1) ^ 510).bit_count(), exp - 8)
1136 def test_round(self):
1146 self.assertEqual(got, expected)
1147 self.assertIs(type(got), int)
1150 self.assertEqual(round(-150, -2), -200)
1151 self.assertEqual(round(-149, -2), -100)
1152 self.assertEqual(round(-51, -2), -100)
1153 self.assertEqual(round(-50, -2), 0)
1154 self.assertEqual(round(-49, -2), 0)
1155 self.assertEqual(round(-1, -2), 0)
1156 self.assertEqual(round(0, -2), 0)
1157 self.assertEqual(round(1, -2), 0)
1158 self.assertEqual(round(49, -2), 0)
1159 self.assertEqual(round(50, -2), 0)
1160 self.assertEqual(round(51, -2), 100)
1161 self.assertEqual(round(149, -2), 100)
1162 self.assertEqual(round(150, -2), 200)
1163 self.assertEqual(round(250, -2), 200)
1164 self.assertEqual(round(251, -2), 300)
1165 self.assertEqual(round(172500, -3), 172000)
1166 self.assertEqual(round(173500, -3), 174000)
1167 self.assertEqual(round(31415926535, -1), 31415926540)
1168 self.assertEqual(round(31415926535, -2), 31415926500)
1169 self.assertEqual(round(31415926535, -3), 31415927000)
1170 self.assertEqual(round(31415926535, -4), 31415930000)
1171 self.assertEqual(round(31415926535, -5), 31415900000)
1172 self.assertEqual(round(31415926535, -6), 31416000000)
1173 self.assertEqual(round(31415926535, -7), 31420000000)
1174 self.assertEqual(round(31415926535, -8), 31400000000)
1175 self.assertEqual(round(31415926535, -9), 31000000000)
1176 self.assertEqual(round(31415926535, -10), 30000000000)
1177 self.assertEqual(round(31415926535, -11), 0)
1178 self.assertEqual(round(31415926535, -12), 0)
1179 self.assertEqual(round(31415926535, -999), 0)
1185 self.assertEqual(got, expect)
1186 self.assertIs(type(got), int)
1193 self.assertEqual(got, x)
1194 self.assertIs(type(got), int)
1196 self.assertEqual(round(8979323, huge_n), 8979323)
1202 self.assertEqual(got, x)
1203 self.assertIs(type(got), int)
1208 self.assertRaises(TypeError, round, 3, e)
1210 def test_to_bytes(self):
1221 self.assertEqual(
1232 self.assertEqual(test.to_bytes(), expected)
1239 self.assertEqual(
1324 self.assertRaises(OverflowError, (256).to_bytes, 1, 'big', signed=False)
1325 self.assertRaises(OverflowError, (256).to_bytes, 1, 'big', signed=True)
1326 self.assertRaises(OverflowError, (256).to_bytes, 1, 'little', signed=False)
1327 self.assertRaises(OverflowError, (256).to_bytes, 1, 'little', signed=True)
1328 self.assertRaises(OverflowError, (-1).to_bytes, 2, 'big', signed=False)
1329 self.assertRaises(OverflowError, (-1).to_bytes, 2, 'little', signed=False)
1330 self.assertEqual((0).to_bytes(0, 'big'), b'')
1331 self.assertEqual((1).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x01')
1332 self.assertEqual((0).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x00')
1333 self.assertEqual((-1).to_bytes(5, 'big', signed=True),
1335 self.assertRaises(OverflowError, (1).to_bytes, 0, 'big')
1340 self.assertEqual((0).to_bytes(1, SubStr('big')), b'\x00')
1341 self.assertEqual((0).to_bytes(0, SubStr('little')), b'')
1343 def test_from_bytes(self):
1359 self.assertEqual(
1370 self.assertEqual(
1379 self.assertEqual(
1476 self.assertIs(type(myint.from_bytes(b'\x00', 'big')), myint)
1477 self.assertEqual(myint.from_bytes(b'\x01', 'big'), 1)
1478 self.assertIs(
1480 self.assertEqual(myint.from_bytes(b'\x01', 'big', signed=False), 1)
1481 self.assertIs(type(myint.from_bytes(b'\x00', 'little')), myint)
1482 self.assertEqual(myint.from_bytes(b'\x01', 'little'), 1)
1483 self.assertIs(type(myint.from_bytes(
1485 self.assertEqual(myint.from_bytes(b'\x01', 'little', signed=False), 1)
1486 self.assertEqual(
1488 self.assertEqual(
1490 self.assertEqual(int.from_bytes(
1492 self.assertEqual(int.from_bytes(
1494 self.assertEqual(int.from_bytes(
1496 self.assertEqual(int.from_bytes(
1498 self.assertRaises(ValueError, int.from_bytes, [256], 'big')
1499 self.assertRaises(ValueError, int.from_bytes, [0], 'big\x00')
1500 self.assertRaises(ValueError, int.from_bytes, [0], 'little\x00')
1501 self.assertRaises(TypeError, int.from_bytes, "", 'big')
1502 self.assertRaises(TypeError, int.from_bytes, "\x00", 'big')
1503 self.assertRaises(TypeError, int.from_bytes, 0, 'big')
1504 self.assertRaises(TypeError, int.from_bytes, 0, 'big', True)
1505 self.assertRaises(TypeError, myint.from_bytes, "", 'big')
1506 self.assertRaises(TypeError, myint.from_bytes, "\x00", 'big')
1507 self.assertRaises(TypeError, myint.from_bytes, 0, 'big')
1508 self.assertRaises(TypeError, int.from_bytes, 0, 'big', True)
1515 self.assertIs(type(i), myint2)
1516 self.assertEqual(i, 2)
1519 def __init__(self, value):
1520 self.foo = 'bar'
1523 self.assertIs(type(i), myint3)
1524 self.assertEqual(i, 1)
1525 self.assertEqual(getattr(i, 'foo', 'none'), 'bar')
1528 def __bytes__(self):
1531 def __bytes__(self):
1535 def __bytes__(self):
1538 self.assertEqual(int.from_bytes(ValidBytes()), 1)
1539 self.assertRaises(TypeError, int.from_bytes, InvalidBytes())
1540 self.assertRaises(TypeError, int.from_bytes, MissingBytes())
1541 self.assertRaises(ZeroDivisionError, int.from_bytes, RaisingBytes())
1546 self.assertEqual(int.from_bytes(b'', SubStr('big')), 0)
1547 self.assertEqual(int.from_bytes(b'\x00', SubStr('little')), 0)
1550 def test_from_bytes_small(self):
1554 self.assertIs(int.from_bytes(b, signed=True), i)
1556 def test_access_to_nonexistent_digit_0(self):
1562 self = int.__new__(cls, value)
1563 self.foo = 'foo'
1564 return self
1568 self.assertEqual(n, 0)
1570 def test_shift_bool(self):
1574 self.assertEqual(type(value << shift), int)
1575 self.assertEqual(type(value >> shift), int)
1577 def test_as_integer_ratio(self):
1583 self.assertEqual((numerator, denominator), (int(value), 1))
1584 self.assertEqual(type(numerator), int)
1585 self.assertEqual(type(denominator), int)
1587 def test_square(self):
1594 with self.subTest(bitlen=bitlen, n=n):
1596 self.assertEqual(n**2,