Lines Matching full:decimal
11 These are the test cases for the Decimal module.
14 the Decimal arithmetic using the tests provided by Mike Cowlishaw. The latter
19 http://speleotrove.com/decimal/dectest.zip
53 C = import_fresh_module('decimal', fresh=['_decimal'])
54 P = import_fresh_module('decimal', blocked=['_decimal'])
55 import decimal as orig_sys_decimal
57 # fractions module must import the correct decimal module.
59 sys.modules['decimal'] = P
61 sys.modules['decimal'] = C
63 sys.modules['decimal'] = orig_sys_decimal
138 """Class which tests the Decimal class against the IBM test cases."""
141 self.context = self.decimal.Context()
142 self.readcontext = self.decimal.Context()
157 # Decimal behaves differently from decNumber for these testcases so these
183 if self.decimal == C:
203 # Name adapter to be able to change the Decimal and Context
254 self.ErrorNames = {'clamped' : self.decimal.Clamped,
255 'conversion_syntax' : self.decimal.InvalidOperation,
256 'division_by_zero' : self.decimal.DivisionByZero,
257 'division_impossible' : self.decimal.InvalidOperation,
258 'division_undefined' : self.decimal.InvalidOperation,
259 'inexact' : self.decimal.Inexact,
260 'invalid_context' : self.decimal.InvalidOperation,
261 'invalid_operation' : self.decimal.InvalidOperation,
262 'overflow' : self.decimal.Overflow,
263 'rounded' : self.decimal.Rounded,
264 'subnormal' : self.decimal.Subnormal,
265 'underflow' : self.decimal.Underflow}
268 # Decimal instance.
287 if self.decimal == C and self.decimal.MAX_EMAX == 425000000:
293 return self.decimal.Decimal(v, context)
305 except self.decimal.DecimalException as exception:
360 raise self.decimal.InvalidOperation
379 for exception in Signals[self.decimal]:
401 except Signals[self.decimal] as e:
421 except Signals[self.decimal] as e:
429 ordered_errors = [e for e in OrderedSignals[self.decimal] if e in theirexceptions]
436 except Signals[self.decimal] as e:
452 except Signals[self.decimal] as error:
470 return [e for e in Signals[self.decimal] if self.context.flags[e]]
473 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
480 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
485 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
493 # The following classes test the behaviour of Decimal according to PEP 327
496 '''Unit tests for Explicit Construction cases of Decimal.'''
499 Decimal = self.decimal.Decimal
500 self.assertEqual(Decimal(), Decimal("0"))
503 Decimal = self.decimal.Decimal
504 self.assertRaises(TypeError, Decimal, None)
507 Decimal = self.decimal.Decimal
510 d = Decimal(45)
514 d = Decimal(500000123)
518 d = Decimal(-45)
522 d = Decimal(0)
530 d = Decimal(i)
534 Decimal = self.decimal.Decimal
535 InvalidOperation = self.decimal.InvalidOperation
536 localcontext = self.decimal.localcontext
539 self.assertEqual(str(Decimal('')), 'NaN')
542 self.assertEqual(str(Decimal('45')), '45')
545 self.assertEqual(str(Decimal('45.34')), '45.34')
548 self.assertEqual(str(Decimal('45e2')), '4.5E+3')
551 self.assertEqual(str(Decimal('ugly')), 'NaN')
554 self.assertEqual(str(Decimal('1.3E4 \n')), '1.3E+4')
555 self.assertEqual(str(Decimal(' -7.89')), '-7.89')
556 self.assertEqual(str(Decimal(" 3.45679 ")), '3.45679')
559 self.assertEqual(str(Decimal('1_3.3e4_0')), '1.33E+41')
560 self.assertEqual(str(Decimal('1_0_0_0')), '1000')
565 self.assertEqual(str(Decimal(lead + '9.311E+28' + trail)),
571 self.assertRaises(InvalidOperation, Decimal, "xyz")
573 self.assertRaises(TypeError, Decimal, "1234", "x", "y")
576 self.assertRaises(InvalidOperation, Decimal, "1\u00a02\u00a03")
577 self.assertRaises(InvalidOperation, Decimal, "\u00a01\u00a02\u00a0")
580 self.assertRaises(InvalidOperation, Decimal, "\u00a0")
581 self.assertRaises(InvalidOperation, Decimal, "\u00a0\u00a0")
584 self.assertRaises(InvalidOperation, Decimal, "12\u00003")
587 self.assertRaises(InvalidOperation, Decimal, "1_2_\u00003")
590 Decimal = self.decimal.Decimal
593 d = Decimal( (0, (0,), 0) )
597 d = Decimal( (1, (4, 5), 0) )
601 d = Decimal( (0, (4, 5, 3, 4), -2) )
605 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
609 d = Decimal( (0, (), "F") )
613 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1)) )
616 self.assertRaises(ValueError, Decimal, (8, (4, 3, 4, 9, 1), 2) )
617 self.assertRaises(ValueError, Decimal, (0., (4, 3, 4, 9, 1), 2) )
618 self.assertRaises(ValueError, Decimal, (Decimal(1), (4, 3, 4, 9, 1), 2))
621 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!') )
622 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 0.) )
623 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), '1') )
626 self.assertRaises(ValueError, Decimal, (1, "xyz", 2) )
627 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) )
628 self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) )
629 self.assertRaises(ValueError, Decimal, (1, (4, 10, 4, 9, 1), 2) )
630 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 'a', 1), 2) )
633 Decimal = self.decimal.Decimal
635 d = Decimal([0, [0], 0])
638 d = Decimal([1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25])
641 d = Decimal([1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25])
644 d = Decimal((1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25))
648 Decimal = self.decimal.Decimal
650 self.assertIs(bool(Decimal(0)), False)
651 self.assertIs(bool(Decimal(1)), True)
652 self.assertEqual(Decimal(False), Decimal(0))
653 self.assertEqual(Decimal(True), Decimal(1))
656 Decimal = self.decimal.Decimal
659 d = Decimal(45)
660 e = Decimal(d)
664 d = Decimal(500000123)
665 e = Decimal(d)
669 d = Decimal(-45)
670 e = Decimal(d)
674 d = Decimal(0)
675 e = Decimal(d)
681 Decimal = self.decimal.Decimal
683 r = Decimal(0.1)
684 self.assertEqual(type(r), Decimal)
687 self.assertTrue(Decimal(float('nan')).is_qnan())
688 self.assertTrue(Decimal(float('inf')).is_infinite())
689 self.assertTrue(Decimal(float('-inf')).is_infinite())
690 self.assertEqual(str(Decimal(float('nan'))),
691 str(Decimal('NaN')))
692 self.assertEqual(str(Decimal(float('inf'))),
693 str(Decimal('Infinity')))
694 self.assertEqual(str(Decimal(float('-inf'))),
695 str(Decimal('-Infinity')))
696 self.assertEqual(str(Decimal(float('-0.0'))),
697 str(Decimal('-0')))
700 self.assertEqual(x, float(Decimal(x))) # roundtrip
703 Decimal = self.decimal.Decimal
704 InvalidOperation = self.decimal.InvalidOperation
705 Rounded = self.decimal.Rounded
707 nc = copy.copy(self.decimal.getcontext())
711 d = Decimal()
721 self.assertIsInstance(d, Decimal)
726 d = Decimal('456789')
736 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
741 # from Decimal
742 prevdec = Decimal(500000123)
743 d = Decimal(prevdec)
755 self.assertTrue(isinstance(d, Decimal))
781 Decimal('NaN12345'))
788 self.assertEqual(str(nc.create_decimal(Decimal('NaN12345'))), 'NaN')
793 Decimal = self.decimal.Decimal
795 nc = self.decimal.Context()
797 self.assertEqual(type(r), Decimal)
816 Decimal = self.decimal.Decimal
824 self.assertEqual(str(Decimal(input)), expected)
828 decimal = C variable in CExplicitConstructionTest
830 decimal = P variable in PyExplicitConstructionTest
833 '''Unit tests for Implicit Construction cases of Decimal.'''
836 Decimal = self.decimal.Decimal
837 self.assertRaises(TypeError, eval, 'Decimal(5) + None', locals())
840 Decimal = self.decimal.Decimal
843 self.assertEqual(str(Decimal(5) + 45), '50')
845 self.assertEqual(Decimal(5) + 123456789000, Decimal(123456789000))
848 Decimal = self.decimal.Decimal
849 self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', locals())
852 Decimal = self.decimal.Decimal
853 self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', locals())
856 Decimal = self.decimal.Decimal
857 self.assertEqual(Decimal(5) + Decimal(45), Decimal(50))
860 Decimal = self.decimal.Decimal
881 self.assertEqual(divmod(E(), Decimal(10)), 'divmod 10')
882 self.assertEqual(divmod(Decimal(10), E()), '10 rdivmod')
883 self.assertEqual(eval('Decimal(10) < E()'), 'gt 10')
884 self.assertEqual(eval('Decimal(10) > E()'), 'lt 10')
885 self.assertEqual(eval('Decimal(10) <= E()'), 'ge 10')
886 self.assertEqual(eval('Decimal(10) >= E()'), 'le 10')
887 self.assertEqual(eval('Decimal(10) == E()'), 'eq 10')
888 self.assertEqual(eval('Decimal(10) != E()'), 'ne 10')
904 self.assertEqual(eval('E()' + sym + 'Decimal(10)'),
906 self.assertEqual(eval('Decimal(10)' + sym + 'E()'),
911 decimal = C variable in CImplicitConstructionTest
913 decimal = P variable in PyImplicitConstructionTest
918 Decimal = self.decimal.Decimal
920 # triples giving a format, a Decimal, and the expected result
956 ('.0f', '0', '0'), # no decimal point
1129 self.assertEqual(format(Decimal(d), fmt), result)
1132 self.assertRaises(TypeError, Decimal(1).__format__, b'-020')
1135 with self.decimal.localcontext() as ctx:
1137 self.assertEqual(format(self.decimal.Decimal('-0.001'), 'z.2f'),
1141 self.assertRaises(ValueError, format, self.decimal.Decimal('1.23'), 'fz')
1144 Decimal = self.decimal.Decimal
1152 return ''.join([chr(x) for x in lst]) if self.decimal == C else lst
1155 if self.decimal == C:
1156 return Decimal(x).__format__(fmt, override)
1158 return Decimal(x).__format__(fmt, _localeconv=override)
1191 self.assertEqual(get_fmt(Decimal('12.7'), en_US), '12.7')
1192 self.assertEqual(get_fmt(Decimal('12.7'), fr_FR), '12,7')
1193 self.assertEqual(get_fmt(Decimal('12.7'), ru_RU), '12,7')
1194 self.assertEqual(get_fmt(Decimal('12.7'), crazy), '1-2&7')
1228 # wide char separator and decimal point
1229 self.assertEqual(get_fmt(Decimal('-1.5'), dotsep_wide, '020n'),
1233 Decimal = self.decimal.Decimal
1234 h = Decimal('6.62607015e-34')
1235 if self.decimal == C:
1258 # locale with wide char separator and decimal point
1259 Decimal = self.decimal.Decimal
1264 self.skipTest('inappropriate decimal point separator '
1270 self.assertEqual(format(Decimal('100000000.123'), 'n'),
1274 class A(self.decimal.Decimal):
1278 self.assertEqual(self.decimal.Decimal, a.a_type)
1281 self.assertEqual(self.decimal.Decimal, a.a_type)
1285 decimal = C variable in CFormatTest
1287 decimal = P variable in PyFormatTest
1293 Decimal = self.decimal.Decimal
1295 d1 = Decimal('-11.1')
1296 d2 = Decimal('22.2')
1299 self.assertEqual(d1+d2, Decimal('11.1'))
1300 self.assertEqual(d2+d1, Decimal('11.1'))
1304 self.assertEqual(c, Decimal('-6.1'))
1309 self.assertEqual(c, Decimal('-6.1'))
1312 #inline with decimal
1314 self.assertEqual(d1, Decimal('11.1'))
1318 self.assertEqual(d1, Decimal('16.1'))
1321 Decimal = self.decimal.Decimal
1323 d1 = Decimal('-11.1')
1324 d2 = Decimal('22.2')
1327 self.assertEqual(d1-d2, Decimal('-33.3'))
1328 self.assertEqual(d2-d1, Decimal('33.3'))
1332 self.assertEqual(c, Decimal('-16.1'))
1337 self.assertEqual(c, Decimal('16.1'))
1340 #inline with decimal
1342 self.assertEqual(d1, Decimal('-33.3'))
1346 self.assertEqual(d1, Decimal('-38.3'))
1349 Decimal = self.decimal.Decimal
1351 d1 = Decimal('-5')
1352 d2 = Decimal('3')
1355 self.assertEqual(d1*d2, Decimal('-15'))
1356 self.assertEqual(d2*d1, Decimal('-15'))
1360 self.assertEqual(c, Decimal('-25'))
1365 self.assertEqual(c, Decimal('-25'))
1368 #inline with decimal
1370 self.assertEqual(d1, Decimal('-15'))
1374 self.assertEqual(d1, Decimal('-75'))
1377 Decimal = self.decimal.Decimal
1379 d1 = Decimal('-5')
1380 d2 = Decimal('2')
1383 self.assertEqual(d1/d2, Decimal('-2.5'))
1384 self.assertEqual(d2/d1, Decimal('-0.4'))
1388 self.assertEqual(c, Decimal('-1.25'))
1393 self.assertEqual(c, Decimal('-0.8'))
1396 #inline with decimal
1398 self.assertEqual(d1, Decimal('-2.5'))
1402 self.assertEqual(d1, Decimal('-0.625'))
1405 Decimal = self.decimal.Decimal
1407 d1 = Decimal('5')
1408 d2 = Decimal('2')
1411 self.assertEqual(d1//d2, Decimal('2'))
1412 self.assertEqual(d2//d1, Decimal('0'))
1416 self.assertEqual(c, Decimal('1'))
1421 self.assertEqual(c, Decimal('1'))
1424 #inline with decimal
1426 self.assertEqual(d1, Decimal('2'))
1430 self.assertEqual(d1, Decimal('1'))
1433 Decimal = self.decimal.Decimal
1435 d1 = Decimal('5')
1436 d2 = Decimal('2')
1439 self.assertEqual(d1**d2, Decimal('25'))
1440 self.assertEqual(d2**d1, Decimal('32'))
1444 self.assertEqual(c, Decimal('625'))
1449 self.assertEqual(c, Decimal('16807'))
1452 #inline with decimal
1454 self.assertEqual(d1, Decimal('25'))
1458 self.assertEqual(d1, Decimal('390625'))
1461 Decimal = self.decimal.Decimal
1463 d1 = Decimal('5')
1464 d2 = Decimal('2')
1467 self.assertEqual(d1%d2, Decimal('1'))
1468 self.assertEqual(d2%d1, Decimal('2'))
1472 self.assertEqual(c, Decimal('1'))
1477 self.assertEqual(c, Decimal('2'))
1480 #inline with decimal
1482 self.assertEqual(d1, Decimal('1'))
1486 self.assertEqual(d1, Decimal('1'))
1489 Decimal = self.decimal.Decimal
1491 d1 = Decimal('5')
1492 d2 = Decimal('2')
1496 self.assertEqual(p, Decimal('2'))
1497 self.assertEqual(q, Decimal('1'))
1503 self.assertEqual(p, Decimal('1'))
1504 self.assertEqual(q, Decimal('1'))
1510 self.assertEqual(p, Decimal('1'))
1511 self.assertEqual(q, Decimal('2'))
1516 Decimal = self.decimal.Decimal
1518 self.assertEqual(+Decimal(45), Decimal(+45)) # +
1519 self.assertEqual(-Decimal(45), Decimal(-45)) # -
1520 self.assertEqual(abs(Decimal(45)), abs(Decimal(-45))) # abs
1530 Decimal = self.decimal.Decimal
1531 InvalidOperation = self.decimal.InvalidOperation
1532 localcontext = self.decimal.localcontext
1534 n = Decimal('NaN')
1535 s = Decimal('sNaN')
1536 i = Decimal('Inf')
1537 f = Decimal('2')
1581 Decimal = self.decimal.Decimal
1583 d = Decimal(1).copy_sign(Decimal(-2))
1584 self.assertEqual(Decimal(1).copy_sign(-2), d)
1585 self.assertRaises(TypeError, Decimal(1).copy_sign, '-2')
1589 decimal = C variable in CArithmeticOperatorsTest
1591 decimal = P variable in PyArithmeticOperatorsTest
1596 Decimal = cls.decimal.Decimal
1597 InvalidOperation = cls.decimal.InvalidOperation
1598 DivisionByZero = cls.decimal.DivisionByZero
1599 Overflow = cls.decimal.Overflow
1600 Underflow = cls.decimal.Underflow
1601 Inexact = cls.decimal.Inexact
1602 getcontext = cls.decimal.getcontext
1603 localcontext = cls.decimal.localcontext
1605 d1 = Decimal(1)
1606 d3 = Decimal(3)
1620 cls.assertRaises(InvalidOperation, c3.compare, d1, Decimal('sNaN'))
1626 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1627 cls.assertEqual(test2, Decimal('0.333333333333333333333333'))
1635 Decimal = cls.decimal.Decimal
1636 InvalidOperation = cls.decimal.InvalidOperation
1637 DivisionByZero = cls.decimal.DivisionByZero
1638 Overflow = cls.decimal.Overflow
1639 Underflow = cls.decimal.Underflow
1640 Inexact = cls.decimal.Inexact
1641 getcontext = cls.decimal.getcontext
1642 localcontext = cls.decimal.localcontext
1644 d1 = Decimal(1)
1645 d3 = Decimal(3)
1654 cls.assertRaises(Overflow, c2.multiply, Decimal('1e425000000'), 999)
1660 cls.assertRaises(Underflow, c3.divide, Decimal('1e-425000000'), 999)
1670 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1671 cls.assertEqual(test2, Decimal('0.333333333333333333'))
1681 '''Unit tests for thread local contexts in Decimal.'''
1687 DefaultContext = self.decimal.DefaultContext
1689 if self.decimal == C and not self.decimal.HAVE_THREADS:
1714 for sig in Signals[self.decimal]:
1727 decimal = C variable in CThreadingTest
1730 decimal = P variable in PyThreadingTest
1733 '''Unit tests for Usability cases of Decimal.'''
1737 Decimal = self.decimal.Decimal
1739 da = Decimal('23.42')
1740 db = Decimal('23.42')
1741 dc = Decimal('45')
1753 #a Decimal and an int
1758 #a Decimal and uncomparable
1765 a = list(map(Decimal, range(100)))
1772 Decimal = self.decimal.Decimal
1774 da = Decimal('0.25')
1775 db = Decimal('3.0')
1788 self.assertNotEqual(0.1, Decimal('0.1'))
1791 Decimal = self.decimal.Decimal
1793 da = Decimal('0.25')
1794 db = Decimal('3.0')
1811 D = self.decimal.Decimal
1812 F = fractions[self.decimal].Fraction
1813 Context = self.decimal.Context
1814 localcontext = self.decimal.localcontext
1815 InvalidOperation = self.decimal.InvalidOperation
1853 Decimal = self.decimal.Decimal
1855 d = Decimal('43.24')
1863 Decimal = self.decimal.Decimal
1864 localcontext = self.decimal.localcontext
1873 hashit(Decimal(23))
1874 hashit(Decimal('Infinity'))
1875 hashit(Decimal('-Infinity'))
1876 hashit(Decimal('nan123'))
1877 hashit(Decimal('-NaN'))
1879 test_values = [Decimal(sign*(2**m + n))
1885 Decimal("-1"), # ==> -2
1886 Decimal("-0"), # zeros
1887 Decimal("0.00"),
1888 Decimal("-0.000"),
1889 Decimal("0E10"),
1890 Decimal("-0E12"),
1891 Decimal("10.0"), # negative exponent
1892 Decimal("-23.00000"),
1893 Decimal("1230E100"), # positive exponent
1894 Decimal("-4.5678E50"),
1897 Decimal(2**64 + 2**32 - 1),
1900 Decimal("1.634E100"),
1901 Decimal("90.697E100"),
1902 Decimal("188.83E100"),
1903 Decimal("1652.9E100"),
1904 Decimal("56531E100"),
1911 # check that the hashes of a Decimal float match when they
1917 d = Decimal(s)
1923 x = Decimal("123456789.1")
1937 self.assertEqual(hashit(Decimal(x)), hashit(x))
1940 Decimal = self.decimal.Decimal
1941 self.assertRaises(TypeError, hash, Decimal('sNaN'))
1942 value = Decimal('NaN')
1947 class D(Decimal, H):
1953 Decimal = self.decimal.Decimal
1955 d1 = Decimal('15.32')
1956 d2 = Decimal('28.5')
1966 #between Decimal and int
1973 Decimal = self.decimal.Decimal
1976 self.assertFalse(Decimal(0))
1978 self.assertTrue(Decimal('0.372'))
1982 Decimal = self.decimal.Decimal
1984 d = Decimal('15.32')
1986 self.assertEqual(repr(d), "Decimal('15.32')") # repr
1990 Decimal = self.decimal.Decimal
1992 d1 = Decimal('66')
1993 d2 = Decimal('15.32')
2016 self.assertEqual(math.floor(Decimal(d)), i)
2017 self.assertRaises(ValueError, math.floor, Decimal('-NaN'))
2018 self.assertRaises(ValueError, math.floor, Decimal('sNaN'))
2019 self.assertRaises(ValueError, math.floor, Decimal('NaN123'))
2020 self.assertRaises(OverflowError, math.floor, Decimal('Inf'))
2021 self.assertRaises(OverflowError, math.floor, Decimal('-Inf'))
2036 self.assertEqual(math.ceil(Decimal(d)), i)
2037 self.assertRaises(ValueError, math.ceil, Decimal('-NaN'))
2038 self.assertRaises(ValueError, math.ceil, Decimal('sNaN'))
2039 self.assertRaises(ValueError, math.ceil, Decimal('NaN123'))
2040 self.assertRaises(OverflowError, math.ceil, Decimal('Inf'))
2041 self.assertRaises(OverflowError, math.ceil, Decimal('-Inf'))
2063 self.assertEqual(round(Decimal(d)), i)
2064 self.assertRaises(ValueError, round, Decimal('-NaN'))
2065 self.assertRaises(ValueError, round, Decimal('sNaN'))
2066 self.assertRaises(ValueError, round, Decimal('NaN123'))
2067 self.assertRaises(OverflowError, round, Decimal('Inf'))
2068 self.assertRaises(OverflowError, round, Decimal('-Inf'))
2091 self.assertEqual(str(round(Decimal(d), n)), r)
2094 # Test conversions of decimal NANs to float.
2096 Decimal = self.decimal.Decimal
2098 f = float(Decimal(s))
2104 Decimal = self.decimal.Decimal
2106 d = Decimal(s)
2110 Decimal = self.decimal.Decimal
2113 d = Decimal( (0, (0,), 0) )
2117 d = Decimal( (1, (4, 5), 0) )
2121 d = Decimal( (0, (4, 5, 3, 4), -2) )
2125 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
2129 Decimal = self.decimal.Decimal
2132 d = Decimal(0)
2136 d = Decimal(-45)
2140 d = Decimal("-4.34913534E-17")
2143 # The '0' coefficient is implementation specific to decimal.py.
2145 d = Decimal("Infinity")
2149 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), -2) )
2151 d = Decimal( (1, (0, 0, 0), 37) )
2153 d = Decimal( (1, (), 37) )
2157 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), 'n') )
2159 d = Decimal( (1, (0, 0, 0), 'N') )
2161 d = Decimal( (1, (), 'n') )
2164 # For infinities, decimal.py has always silently accepted any
2166 d = Decimal( (0, (0,), 'F') )
2168 d = Decimal( (0, (4, 5, 3, 4), 'F') )
2170 d = Decimal( (1, (0, 2, 7, 1), 'F') )
2174 Decimal = self.decimal.Decimal
2178 Decimal.as_integer_ratio, Decimal('inf'))
2180 Decimal.as_integer_ratio, Decimal('-inf'))
2182 Decimal.as_integer_ratio, Decimal('-nan'))
2184 Decimal.as_integer_ratio, Decimal('snan123'))
2189 d = Decimal('%s%dE%d' % (sign, coeff, exp))
2204 self.assertEqual(Decimal(p) / Decimal(q), d)
2207 # Different behaviours when subclassing Decimal
2208 Decimal = self.decimal.Decimal
2210 class MyDecimal(Decimal):
2216 self.assertIs(type(d), Decimal)
2219 self.assertIs(type(d), Decimal)
2229 # Decimal(Decimal)
2230 d = Decimal('1.0')
2231 x = Decimal(d)
2232 self.assertIs(type(x), Decimal)
2235 # MyDecimal(Decimal)
2241 # Decimal(MyDecimal)
2242 x = Decimal(m)
2243 self.assertIs(type(x), Decimal)
2254 Decimal = self.decimal.Decimal
2255 getcontext = self.decimal.getcontext
2259 self.assertEqual(str(Decimal(0).sqrt()),
2260 str(c.sqrt(Decimal(0))))
2263 Decimal = self.decimal.Decimal
2264 Context = self.decimal.Context
2265 localcontext = self.decimal.localcontext
2266 InvalidOperation = self.decimal.InvalidOperation
2267 DivisionByZero = self.decimal.DivisionByZero
2268 Overflow = self.decimal.Overflow
2269 Underflow = self.decimal.Underflow
2270 Subnormal = self.decimal.Subnormal
2271 Inexact = self.decimal.Inexact
2272 Rounded = self.decimal.Rounded
2273 Clamped = self.decimal.Clamped
2280 x = Decimal("111")
2281 y = Decimal("1e9999")
2282 z = Decimal("1e-9999")
2301 self.assertRaises(InvalidOperation, Decimal(-1).ln, context=None)
2309 self.assertRaises(InvalidOperation, Decimal(-1).log10, context=None)
2314 self.assertRaises(DivisionByZero, Decimal(0).logb, context=None)
2324 self.assertRaises(InvalidOperation, Decimal('sNaN').next_minus, context=None)
2329 self.assertRaises(InvalidOperation, Decimal('sNaN').next_plus, context=None)
2357 ans = str(x.compare(Decimal('Nan891287828'), context=None))
2359 self.assertRaises(InvalidOperation, x.compare, Decimal('sNaN'), context=None)
2365 self.assertRaises(InvalidOperation, x.compare_signal, Decimal('NaN'), context=None)
2389 self.assertRaises(InvalidOperation, x.max, Decimal('sNaN'), context=None)
2395 self.assertRaises(InvalidOperation, x.max_mag, Decimal('sNaN'), context=None)
2401 self.assertRaises(InvalidOperation, x.min, Decimal('sNaN'), context=None)
2407 self.assertRaises(InvalidOperation, x.min_mag, Decimal('sNaN'), context=None)
2439 self.assertRaises(Overflow, x.fma, Decimal('1e9999'), 3, context=None)
2445 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2448 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2450 ans = str(Decimal('1.5').to_integral(rounding=ROUND_UP, context=None))
2453 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral, context=None)
2457 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2460 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2462 ans = str(Decimal('1.5').to_integral_value(rounding=ROUND_UP, context=None))
2465 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_value, context=None)
2469 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2472 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2474 ans = str(Decimal('1.5').to_integral_exact(rounding=ROUND_UP, context=None))
2477 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_exact, context=None)
2481 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2484 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2486 … ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=ROUND_UP, context=None))
2489 … self.assertRaises(InvalidOperation, y.quantize, Decimal('1e-10'), rounding=ROUND_UP, context=None)
2502 # Check that methods taking a second Decimal argument will
2503 # always accept an integer in place of a Decimal.
2504 Decimal = self.decimal.Decimal
2506 self.assertEqual(Decimal(4).compare(3),
2507 Decimal(4).compare(Decimal(3)))
2508 self.assertEqual(Decimal(4).compare_signal(3),
2509 Decimal(4).compare_signal(Decimal(3)))
2510 self.assertEqual(Decimal(4).compare_total(3),
2511 Decimal(4).compare_total(Decimal(3)))
2512 self.assertEqual(Decimal(4).compare_total_mag(3),
2513 Decimal(4).compare_total_mag(Decimal(3)))
2514 self.assertEqual(Decimal(10101).logical_and(1001),
2515 Decimal(10101).logical_and(Decimal(1001)))
2516 self.assertEqual(Decimal(10101).logical_or(1001),
2517 Decimal(10101).logical_or(Decimal(1001)))
2518 self.assertEqual(Decimal(10101).logical_xor(1001),
2519 Decimal(10101).logical_xor(Decimal(1001)))
2520 self.assertEqual(Decimal(567).max(123),
2521 Decimal(567).max(Decimal(123)))
2522 self.assertEqual(Decimal(567).max_mag(123),
2523 Decimal(567).max_mag(Decimal(123)))
2524 self.assertEqual(Decimal(567).min(123),
2525 Decimal(567).min(Decimal(123)))
2526 self.assertEqual(Decimal(567).min_mag(123),
2527 Decimal(567).min_mag(Decimal(123)))
2528 self.assertEqual(Decimal(567).next_toward(123),
2529 Decimal(567).next_toward(Decimal(123)))
2530 self.assertEqual(Decimal(1234).quantize(100),
2531 Decimal(1234).quantize(Decimal(100)))
2532 self.assertEqual(Decimal(768).remainder_near(1234),
2533 Decimal(768).remainder_near(Decimal(1234)))
2534 self.assertEqual(Decimal(123).rotate(1),
2535 Decimal(123).rotate(Decimal(1)))
2536 self.assertEqual(Decimal(1234).same_quantum(1000),
2537 Decimal(1234).same_quantum(Decimal(1000)))
2538 self.assertEqual(Decimal('9.123').scaleb(-100),
2539 Decimal('9.123').scaleb(Decimal(-100)))
2540 self.assertEqual(Decimal(456).shift(-1),
2541 Decimal(456).shift(Decimal(-1)))
2543 self.assertEqual(Decimal(-12).fma(Decimal(45), 67),
2544 Decimal(-12).fma(Decimal(45), Decimal(67)))
2545 self.assertEqual(Decimal(-12).fma(45, 67),
2546 Decimal(-12).fma(Decimal(45), Decimal(67)))
2547 self.assertEqual(Decimal(-12).fma(45, Decimal(67)),
2548 Decimal(-12).fma(Decimal(45), Decimal(67)))
2552 decimal = C variable in CUsabilityTest
2554 decimal = P variable in PyUsabilityTest
2568 Decimal = self.decimal.Decimal
2570 self.assertTrue(issubclass(Decimal, numbers.Number))
2571 self.assertFalse(issubclass(Decimal, numbers.Real))
2572 self.assertIsInstance(Decimal(0), numbers.Number)
2573 self.assertNotIsInstance(Decimal(0), numbers.Real)
2577 Decimal = self.decimal.Decimal
2579 savedecimal = sys.modules['decimal']
2582 sys.modules['decimal'] = self.decimal
2583 d = Decimal('-3.141590000')
2590 x = C.Decimal('-3.123e81723')
2591 y = P.Decimal('-3.123e81723')
2593 sys.modules['decimal'] = C
2595 sys.modules['decimal'] = P
2597 self.assertIsInstance(r, P.Decimal)
2600 sys.modules['decimal'] = P
2602 sys.modules['decimal'] = C
2604 self.assertIsInstance(r, C.Decimal)
2607 x = C.Decimal('-3.123e81723').as_tuple()
2608 y = P.Decimal('-3.123e81723').as_tuple()
2610 sys.modules['decimal'] = C
2612 sys.modules['decimal'] = P
2617 sys.modules['decimal'] = P
2619 sys.modules['decimal'] = C
2624 sys.modules['decimal'] = savedecimal
2627 Decimal = self.decimal.Decimal
2632 self.assertEqual(int(Decimal(s)), int(float(s)))
2634 d = Decimal(s)
2636 self.assertEqual(Decimal(int(d)), r)
2638 self.assertRaises(ValueError, int, Decimal('-nan'))
2639 self.assertRaises(ValueError, int, Decimal('snan'))
2640 self.assertRaises(OverflowError, int, Decimal('inf'))
2641 self.assertRaises(OverflowError, int, Decimal('-inf'))
2645 Decimal = self.decimal.Decimal
2648 self.assertIs(int(Decimal(x)), x)
2651 Decimal = self.decimal.Decimal
2656 self.assertEqual(int(Decimal(s)), int(float(s)))
2658 d = Decimal(s)
2660 self.assertEqual(Decimal(math.trunc(d)), r)
2664 Decimal = self.decimal.Decimal
2666 class MyDecimal(Decimal):
2670 self.assertTrue(issubclass(MyDecimal, Decimal))
2684 str(Decimal('NaN')))
2686 str(Decimal('Infinity')))
2688 str(Decimal('-Infinity')))
2695 Decimal = self.decimal.Decimal
2696 Context = self.decimal.Context
2697 Inexact = self.decimal.Inexact
2702 Decimal('3.1415')
2707 Decimal('3.1416')
2716 "Decimal('-0')")
2718 "Decimal('1')")
2720 "Decimal('10')")
2723 Decimal = self.decimal.Decimal
2724 Context = self.decimal.Context
2725 InvalidOperation = self.decimal.InvalidOperation
2729 Decimal('7.335').quantize(Decimal('.01')),
2730 Decimal('7.34')
2733 Decimal('7.335').quantize(Decimal('.01'), rounding=ROUND_DOWN),
2734 Decimal('7.33')
2738 Decimal("10e99999").quantize, Decimal('1e100000'), context=c
2742 d = Decimal("0.871831e800")
2743 x = d.quantize(context=c, exp=Decimal("1e797"), rounding=ROUND_DOWN)
2744 self.assertEqual(x, Decimal('8.71E+799'))
2747 Decimal = self.decimal.Decimal
2749 x = Decimal("9.8182731e181273")
2754 x = Decimal("1")
2763 D = self.decimal.Decimal
2764 Context = self.decimal.Context
2765 localcontext = self.decimal.localcontext
2766 InvalidOperation = self.decimal.InvalidOperation
2767 Overflow = self.decimal.Overflow
2876 decimal = self.decimal
2877 DecimalException = decimal.DecimalException
2878 InvalidOperation = decimal.InvalidOperation
2879 FloatOperation = decimal.FloatOperation
2880 DivisionByZero = decimal.DivisionByZero
2881 Overflow = decimal.Overflow
2882 Underflow = decimal.Underflow
2883 Subnormal = decimal.Subnormal
2884 Inexact = decimal.Inexact
2885 Rounded = decimal.Rounded
2886 Clamped = decimal.Clamped
2908 self.assertTrue(issubclass(decimal.ConversionSyntax, InvalidOperation))
2909 self.assertTrue(issubclass(decimal.DivisionImpossible, InvalidOperation))
2910 self.assertTrue(issubclass(decimal.DivisionUndefined, InvalidOperation))
2911 self.assertTrue(issubclass(decimal.DivisionUndefined, ZeroDivisionError))
2912 self.assertTrue(issubclass(decimal.InvalidContext, InvalidOperation))
2916 decimal = C variable in CPythonAPItests
2918 decimal = P variable in PyPythonAPItests
2923 Context = self.decimal.Context
2924 InvalidOperation = self.decimal.InvalidOperation
2925 DivisionByZero = self.decimal.DivisionByZero
2926 Overflow = self.decimal.Overflow
2945 Context = self.decimal.Context
2947 savedecimal = sys.modules['decimal']
2950 sys.modules['decimal'] = self.decimal
2977 sys.modules['decimal'] = dumper
2988 sys.modules['decimal'] = loader
3001 sys.modules['decimal'] = savedecimal
3004 Decimal = self.decimal.Decimal
3006 self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}])
3007 self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}])
3011 Decimal = self.decimal.Decimal
3012 Context = self.decimal.Context
3031 Context = self.decimal.Context
3036 Decimal = self.decimal.Decimal
3037 Context = self.decimal.Context
3040 d = c.abs(Decimal(-1))
3045 Decimal = self.decimal.Decimal
3046 Context = self.decimal.Context
3049 d = c.add(Decimal(1), Decimal(1))
3051 self.assertEqual(c.add(Decimal(1), 1), d)
3052 self.assertEqual(c.add(1, Decimal(1)), d)
3057 Decimal = self.decimal.Decimal
3058 Context = self.decimal.Context
3061 d = c.compare(Decimal(1), Decimal(1))
3063 self.assertEqual(c.compare(Decimal(1), 1), d)
3064 self.assertEqual(c.compare(1, Decimal(1)), d)
3069 Decimal = self.decimal.Decimal
3070 Context = self.decimal.Context
3073 d = c.compare_signal(Decimal(1), Decimal(1))
3075 self.assertEqual(c.compare_signal(Decimal(1), 1), d)
3076 self.assertEqual(c.compare_signal(1, Decimal(1)), d)
3081 Decimal = self.decimal.Decimal
3082 Context = self.decimal.Context
3085 d = c.compare_total(Decimal(1), Decimal(1))
3087 self.assertEqual(c.compare_total(Decimal(1), 1), d)
3088 self.assertEqual(c.compare_total(1, Decimal(1)), d)
3093 Decimal = self.decimal.Decimal
3094 Context = self.decimal.Context
3097 d = c.compare_total_mag(Decimal(1), Decimal(1))
3099 self.assertEqual(c.compare_total_mag(Decimal(1), 1), d)
3100 self.assertEqual(c.compare_total_mag(1, Decimal(1)), d)
3105 Decimal = self.decimal.Decimal
3106 Context = self.decimal.Context
3109 d = c.copy_abs(Decimal(-1))
3114 Decimal = self.decimal.Decimal
3115 Context = self.decimal.Context
3118 d = c.copy_decimal(Decimal(-1))
3123 Decimal = self.decimal.Decimal
3124 Context = self.decimal.Context
3127 d = c.copy_negate(Decimal(-1))
3132 Decimal = self.decimal.Decimal
3133 Context = self.decimal.Context
3136 d = c.copy_sign(Decimal(1), Decimal(-2))
3138 self.assertEqual(c.copy_sign(Decimal(1), -2), d)
3139 self.assertEqual(c.copy_sign(1, Decimal(-2)), d)
3144 Decimal = self.decimal.Decimal
3145 Context = self.decimal.Context
3148 d = c.divide(Decimal(1), Decimal(2))
3150 self.assertEqual(c.divide(Decimal(1), 2), d)
3151 self.assertEqual(c.divide(1, Decimal(2)), d)
3156 Decimal = self.decimal.Decimal
3157 Context = self.decimal.Context
3160 d = c.divide_int(Decimal(1), Decimal(2))
3162 self.assertEqual(c.divide_int(Decimal(1), 2), d)
3163 self.assertEqual(c.divide_int(1, Decimal(2)), d)
3168 Decimal = self.decimal.Decimal
3169 Context = self.decimal.Context
3172 d = c.divmod(Decimal(1), Decimal(2))
3174 self.assertEqual(c.divmod(Decimal(1), 2), d)
3175 self.assertEqual(c.divmod(1, Decimal(2)), d)
3180 Decimal = self.decimal.Decimal
3181 Context = self.decimal.Context
3184 d = c.exp(Decimal(10))
3189 Decimal = self.decimal.Decimal
3190 Context = self.decimal.Context
3193 d = c.fma(Decimal(2), Decimal(3), Decimal(4))
3195 self.assertEqual(c.fma(Decimal(2), 3, 4), d)
3196 self.assertEqual(c.fma(2, Decimal(3), 4), d)
3197 self.assertEqual(c.fma(2, 3, Decimal(4)), d)
3198 self.assertEqual(c.fma(Decimal(2), Decimal(3), 4), d)
3205 Decimal('Infinity'), Decimal(0), "not a decimal")
3207 Decimal(1), Decimal('snan'), 1.222)
3208 # ... and for Decimal.fma.
3209 self.assertRaises(TypeError, Decimal('Infinity').fma,
3210 Decimal(0), "not a decimal")
3211 self.assertRaises(TypeError, Decimal(1).fma,
3212 Decimal('snan'), 1.222)
3215 Decimal = self.decimal.Decimal
3216 Context = self.decimal.Context
3219 d = c.is_finite(Decimal(10))
3224 Decimal = self.decimal.Decimal
3225 Context = self.decimal.Context
3228 d = c.is_infinite(Decimal(10))
3233 Decimal = self.decimal.Decimal
3234 Context = self.decimal.Context
3237 d = c.is_nan(Decimal(10))
3242 Decimal = self.decimal.Decimal
3243 Context = self.decimal.Context
3246 d = c.is_normal(Decimal(10))
3251 Decimal = self.decimal.Decimal
3252 Context = self.decimal.Context
3255 d = c.is_qnan(Decimal(10))
3260 Decimal = self.decimal.Decimal
3261 Context = self.decimal.Context
3264 d = c.is_signed(Decimal(10))
3269 Decimal = self.decimal.Decimal
3270 Context = self.decimal.Context
3273 d = c.is_snan(Decimal(10))
3278 Decimal = self.decimal.Decimal
3279 Context = self.decimal.Context
3282 d = c.is_subnormal(Decimal(10))
3287 Decimal = self.decimal.Decimal
3288 Context = self.decimal.Context
3291 d = c.is_zero(Decimal(10))
3296 Decimal = self.decimal.Decimal
3297 Context = self.decimal.Context
3300 d = c.ln(Decimal(10))
3305 Decimal = self.decimal.Decimal
3306 Context = self.decimal.Context
3309 d = c.log10(Decimal(10))
3314 Decimal = self.decimal.Decimal
3315 Context = self.decimal.Context
3318 d = c.logb(Decimal(10))
3323 Decimal = self.decimal.Decimal
3324 Context = self.decimal.Context
3327 d = c.logical_and(Decimal(1), Decimal(1))
3329 self.assertEqual(c.logical_and(Decimal(1), 1), d)
3330 self.assertEqual(c.logical_and(1, Decimal(1)), d)
3335 Decimal = self.decimal.Decimal
3336 Context = self.decimal.Context
3339 d = c.logical_invert(Decimal(1000))
3344 Decimal = self.decimal.Decimal
3345 Context = self.decimal.Context
3348 d = c.logical_or(Decimal(1), Decimal(1))
3350 self.assertEqual(c.logical_or(Decimal(1), 1), d)
3351 self.assertEqual(c.logical_or(1, Decimal(1)), d)
3356 Decimal = self.decimal.Decimal
3357 Context = self.decimal.Context
3360 d = c.logical_xor(Decimal(1), Decimal(1))
3362 self.assertEqual(c.logical_xor(Decimal(1), 1), d)
3363 self.assertEqual(c.logical_xor(1, Decimal(1)), d)
3368 Decimal = self.decimal.Decimal
3369 Context = self.decimal.Context
3372 d = c.max(Decimal(1), Decimal(2))
3374 self.assertEqual(c.max(Decimal(1), 2), d)
3375 self.assertEqual(c.max(1, Decimal(2)), d)
3380 Decimal = self.decimal.Decimal
3381 Context = self.decimal.Context
3384 d = c.max_mag(Decimal(1), Decimal(2))
3386 self.assertEqual(c.max_mag(Decimal(1), 2), d)
3387 self.assertEqual(c.max_mag(1, Decimal(2)), d)
3392 Decimal = self.decimal.Decimal
3393 Context = self.decimal.Context
3396 d = c.min(Decimal(1), Decimal(2))
3398 self.assertEqual(c.min(Decimal(1), 2), d)
3399 self.assertEqual(c.min(1, Decimal(2)), d)
3404 Decimal = self.decimal.Decimal
3405 Context = self.decimal.Context
3408 d = c.min_mag(Decimal(1), Decimal(2))
3410 self.assertEqual(c.min_mag(Decimal(1), 2), d)
3411 self.assertEqual(c.min_mag(1, Decimal(2)), d)
3416 Decimal = self.decimal.Decimal
3417 Context = self.decimal.Context
3420 d = c.minus(Decimal(10))
3425 Decimal = self.decimal.Decimal
3426 Context = self.decimal.Context
3429 d = c.multiply(Decimal(1), Decimal(2))
3431 self.assertEqual(c.multiply(Decimal(1), 2), d)
3432 self.assertEqual(c.multiply(1, Decimal(2)), d)
3437 Decimal = self.decimal.Decimal
3438 Context = self.decimal.Context
3441 d = c.next_minus(Decimal(10))
3446 Decimal = self.decimal.Decimal
3447 Context = self.decimal.Context
3450 d = c.next_plus(Decimal(10))
3455 Decimal = self.decimal.Decimal
3456 Context = self.decimal.Context
3459 d = c.next_toward(Decimal(1), Decimal(2))
3461 self.assertEqual(c.next_toward(Decimal(1), 2), d)
3462 self.assertEqual(c.next_toward(1, Decimal(2)), d)
3467 Decimal = self.decimal.Decimal
3468 Context = self.decimal.Context
3471 d = c.normalize(Decimal(10))
3476 Decimal = self.decimal.Decimal
3477 Context = self.decimal.Context
3480 self.assertEqual(c.number_class(123), c.number_class(Decimal(123)))
3481 self.assertEqual(c.number_class(0), c.number_class(Decimal(0)))
3482 self.assertEqual(c.number_class(-45), c.number_class(Decimal(-45)))
3485 Decimal = self.decimal.Decimal
3486 Context = self.decimal.Context
3489 d = c.plus(Decimal(10))
3494 Decimal = self.decimal.Decimal
3495 Context = self.decimal.Context
3498 d = c.power(Decimal(1), Decimal(4))
3500 self.assertEqual(c.power(Decimal(1), 4), d)
3501 self.assertEqual(c.power(1, Decimal(4)), d)
3502 self.assertEqual(c.power(Decimal(1), Decimal(4)), d)
3508 Decimal = self.decimal.Decimal
3509 Context = self.decimal.Context
3512 d = c.quantize(Decimal(1), Decimal(2))
3514 self.assertEqual(c.quantize(Decimal(1), 2), d)
3515 self.assertEqual(c.quantize(1, Decimal(2)), d)
3520 Decimal = self.decimal.Decimal
3521 Context = self.decimal.Context
3524 d = c.remainder(Decimal(1), Decimal(2))
3526 self.assertEqual(c.remainder(Decimal(1), 2), d)
3527 self.assertEqual(c.remainder(1, Decimal(2)), d)
3532 Decimal = self.decimal.Decimal
3533 Context = self.decimal.Context
3536 d = c.remainder_near(Decimal(1), Decimal(2))
3538 self.assertEqual(c.remainder_near(Decimal(1), 2), d)
3539 self.assertEqual(c.remainder_near(1, Decimal(2)), d)
3544 Decimal = self.decimal.Decimal
3545 Context = self.decimal.Context
3548 d = c.rotate(Decimal(1), Decimal(2))
3550 self.assertEqual(c.rotate(Decimal(1), 2), d)
3551 self.assertEqual(c.rotate(1, Decimal(2)), d)
3556 Decimal = self.decimal.Decimal
3557 Context = self.decimal.Context
3560 d = c.sqrt(Decimal(10))
3565 Decimal = self.decimal.Decimal
3566 Context = self.decimal.Context
3569 d = c.same_quantum(Decimal(1), Decimal(2))
3571 self.assertEqual(c.same_quantum(Decimal(1), 2), d)
3572 self.assertEqual(c.same_quantum(1, Decimal(2)), d)
3577 Decimal = self.decimal.Decimal
3578 Context = self.decimal.Context
3581 d = c.scaleb(Decimal(1), Decimal(2))
3583 self.assertEqual(c.scaleb(Decimal(1), 2), d)
3584 self.assertEqual(c.scaleb(1, Decimal(2)), d)
3589 Decimal = self.decimal.Decimal
3590 Context = self.decimal.Context
3593 d = c.shift(Decimal(1), Decimal(2))
3595 self.assertEqual(c.shift(Decimal(1), 2), d)
3596 self.assertEqual(c.shift(1, Decimal(2)), d)
3601 Decimal = self.decimal.Decimal
3602 Context = self.decimal.Context
3605 d = c.subtract(Decimal(1), Decimal(2))
3607 self.assertEqual(c.subtract(Decimal(1), 2), d)
3608 self.assertEqual(c.subtract(1, Decimal(2)), d)
3613 Decimal = self.decimal.Decimal
3614 Context = self.decimal.Context
3617 d = c.to_eng_string(Decimal(10))
3622 Decimal = self.decimal.Decimal
3623 Context = self.decimal.Context
3626 d = c.to_sci_string(Decimal(10))
3631 Decimal = self.decimal.Decimal
3632 Context = self.decimal.Context
3635 d = c.to_integral_exact(Decimal(10))
3640 Decimal = self.decimal.Decimal
3641 Context = self.decimal.Context
3644 d = c.to_integral_value(Decimal(10))
3651 decimal = C variable in CContextAPItests
3653 decimal = P variable in PyContextAPItests
3661 getcontext = self.decimal.getcontext
3662 localcontext = self.decimal.localcontext
3674 Context = self.decimal.Context
3675 getcontext = self.decimal.getcontext
3676 localcontext = self.decimal.localcontext
3678 localcontext = self.decimal.localcontext
3690 with self.decimal.localcontext(
3696 self.assertEqual(ctx.rounding, self.decimal.ROUND_HALF_DOWN)
3702 self.assertRaises(TypeError, self.decimal.localcontext, precision=10)
3704 self.assertRaises(ValueError, self.decimal.localcontext, Emin=1)
3705 self.assertRaises(ValueError, self.decimal.localcontext, Emax=-1)
3706 self.assertRaises(ValueError, self.decimal.localcontext, capitals=2)
3707 self.assertRaises(ValueError, self.decimal.localcontext, clamp=2)
3709 self.assertRaises(TypeError, self.decimal.localcontext, rounding="")
3710 self.assertRaises(TypeError, self.decimal.localcontext, rounding=1)
3712 self.assertRaises(TypeError, self.decimal.localcontext, flags="")
3713 self.assertRaises(TypeError, self.decimal.localcontext, traps="")
3714 self.assertRaises(TypeError, self.decimal.localcontext, Emin="")
3715 self.assertRaises(TypeError, self.decimal.localcontext, Emax="")
3718 ctx = self.decimal.getcontext()
3720 with self.decimal.localcontext(prec=10) as ctx2:
3723 with self.decimal.localcontext(prec=20) as ctx2:
3729 Decimal = self.decimal.Decimal
3730 Context = self.decimal.Context
3731 getcontext = self.decimal.getcontext
3732 localcontext = self.decimal.localcontext
3733 Clamped = self.decimal.Clamped
3734 Overflow = self.decimal.Overflow
3750 self.assertRaises(Overflow, c2.power, Decimal('3.4e200'), 2)
3763 localcontext = self.decimal.localcontext
3775 localcontext = self.decimal.localcontext
3787 Context = self.decimal.Context
3788 localcontext = self.decimal.localcontext
3789 getcontext = self.decimal.getcontext
3790 setcontext = self.decimal.setcontext
3821 decimal = C variable in CContextWithStatement
3823 decimal = P variable in PyContextWithStatement
3830 Decimal = self.decimal.Decimal
3831 Context = self.decimal.Context
3832 Inexact = self.decimal.Inexact
3833 Rounded = self.decimal.Rounded
3834 Underflow = self.decimal.Underflow
3835 Clamped = self.decimal.Clamped
3836 Subnormal = self.decimal.Subnormal
3839 if self.decimal == C:
3851 (context._apply, [Decimal("100E-425000010")]),
3852 (context.sqrt, [Decimal(2)]),
3853 (context.add, [Decimal("1.23456789"), Decimal("9.87654321")]),
3854 (context.multiply, [Decimal("1.23456789"), Decimal("9.87654321")]),
3855 (context.subtract, [Decimal("1.23456789"), Decimal("9.87654321")]),
3894 Context = self.decimal.Context
3895 Inexact = self.decimal.Inexact
3896 Rounded = self.decimal.Rounded
3933 Decimal = self.decimal.Decimal
3934 FloatOperation = self.decimal.FloatOperation
3935 localcontext = self.decimal.localcontext
3943 self.assertEqual(Decimal(7.5), 7.5)
3952 x = Decimal.from_float(7.5)
3969 self.assertRaises(FloatOperation, Decimal, 7.5)
3978 x = Decimal.from_float(7.5)
3986 Decimal = self.decimal.Decimal
3987 Context = self.decimal.Context
3988 FloatOperation = self.decimal.FloatOperation
3989 localcontext = self.decimal.localcontext
4000 small_d = Decimal('0.25')
4001 big_d = Decimal('3.0')
4005 zero_d = Decimal('0.0')
4006 neg_zero_d = Decimal('-0.0')
4010 inf_d = Decimal('Infinity')
4011 neg_inf_d = Decimal('-Infinity')
4038 assert_attr(Decimal('0.1'), 0.1, '__ne__', c, None)
4043 assert_attr(Decimal('NaN'), float('nan'), '__ne__', c, None)
4047 s = set([100.0, Decimal('100.0')])
4053 self.assertRaises(signal, sorted, [1.0, Decimal('10.0')])
4055 s = sorted([10.0, Decimal('10.0')])
4059 b = 10.0 in [Decimal('10.0'), 1.0]
4063 b = 10.0 in {Decimal('10.0'):'a', 1.0:'b'}
4077 Decimal = self.decimal.Decimal
4078 Context = self.decimal.Context
4079 Inexact = self.decimal.Inexact
4080 FloatOperation= self.decimal.FloatOperation
4094 decimal = C variable in CContextFlags
4096 decimal = P variable in PyContextFlags
4102 BasicContext = self.decimal.BasicContext
4103 ExtendedContext = self.decimal.ExtendedContext
4104 getcontext = self.decimal.getcontext
4105 setcontext = self.decimal.setcontext
4106 InvalidOperation = self.decimal.InvalidOperation
4107 DivisionByZero = self.decimal.DivisionByZero
4108 Overflow = self.decimal.Overflow
4109 Underflow = self.decimal.Underflow
4110 Clamped = self.decimal.Clamped
4138 DefaultContext = self.decimal.DefaultContext
4139 BasicContext = self.decimal.BasicContext
4140 ExtendedContext = self.decimal.ExtendedContext
4141 getcontext = self.decimal.getcontext
4142 setcontext = self.decimal.setcontext
4143 InvalidOperation = self.decimal.InvalidOperation
4144 DivisionByZero = self.decimal.DivisionByZero
4145 Overflow = self.decimal.Overflow
4180 decimal = C variable in CSpecialContexts
4182 decimal = P variable in PySpecialContexts
4187 Context = self.decimal.Context
4188 DefaultContext = self.decimal.DefaultContext
4248 decimal = C variable in CContextInputValidation
4250 decimal = P variable in PyContextInputValidation
4255 decimal = self.decimal
4256 Decimal = decimal.Decimal
4257 Context = decimal.Context
4258 Clamped = decimal.Clamped
4259 DivisionByZero = decimal.DivisionByZero
4260 Inexact = decimal.Inexact
4261 Overflow = decimal.Overflow
4262 Rounded = decimal.Rounded
4263 Subnormal = decimal.Subnormal
4264 Underflow = decimal.Underflow
4265 InvalidOperation = decimal.InvalidOperation
4286 flags = {v:(v in flags) for v in OrderedSignals[decimal] + flags}
4290 traps = {v:(v in traps) for v in OrderedSignals[decimal] + traps}
4303 self.assertRaises(InvalidOperation, c.quantize, Decimal('9e2'), 0)
4309 self.assertEqual(c.plus(Decimal('9.9')), 9)
4315 x = c.add(Decimal('1e-99'), Decimal('2.234e-2000'))
4316 self.assertEqual(x, Decimal('0.0'))
4324 self.assertRaises(Overflow, c.add, Decimal('1e99'), Decimal('2.234e2000'))
4325 if self.decimal == C:
4340 x = c.plus(Decimal('1e99'))
4349 for signal in OrderedSignals[decimal]:
4358 for signal in OrderedSignals[decimal]:
4363 decimal = C variable in CContextSubclassing
4365 decimal = P variable in PyContextSubclassing
4395 x = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4396 y = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4402 Decimal = self.decimal.Decimal
4404 self.assertEqual(Decimal('1234e9999').adjusted(), 10002)
4406 self.assertEqual(Decimal('nan').adjusted(), 0)
4407 self.assertEqual(Decimal('inf').adjusted(), 0)
4410 Decimal = self.decimal.Decimal
4411 getcontext = self.decimal.getcontext
4413 x = Decimal(9).canonical()
4417 x = c.canonical(Decimal(9))
4421 c = self.decimal.DefaultContext.copy()
4429 for sig in OrderedSignals[self.decimal]:
4440 Decimal = self.decimal.Decimal
4441 localcontext = self.decimal.localcontext
4449 self.assertEqual(abs(Decimal("-10")), 10)
4451 self.assertEqual(Decimal("7") + 1, 8)
4453 self.assertEqual(Decimal("10") / 5, 2)
4455 self.assertEqual(Decimal("10") // 7, 1)
4457 self.assertEqual(Decimal("1.2").fma(Decimal("0.01"), 1), 1)
4458 self.assertIs(Decimal("NaN").fma(7, 1).is_nan(), True)
4460 self.assertEqual(pow(Decimal(10), 2, 7), 2)
4462 self.assertEqual(Decimal("1.01").exp(), 3)
4464 self.assertIs(Decimal("0.01").is_normal(), False)
4466 self.assertIs(Decimal("0.01").is_subnormal(), True)
4468 self.assertEqual(Decimal("20").ln(), 3)
4470 self.assertEqual(Decimal("20").log10(), 1)
4472 self.assertEqual(Decimal("580").logb(), 2)
4474 self.assertEqual(Decimal("10").logical_invert(), 1)
4476 self.assertEqual(-Decimal("-10"), 10)
4478 self.assertEqual(Decimal("2") * 4, 8)
4480 self.assertEqual(Decimal("10").next_minus(), 9)
4482 self.assertEqual(Decimal("10").next_plus(), Decimal('2E+1'))
4484 self.assertEqual(Decimal("-10").normalize(), Decimal('-1E+1'))
4486 self.assertEqual(Decimal("10").number_class(), '+Normal')
4488 self.assertEqual(+Decimal("-1"), -1)
4490 self.assertEqual(Decimal("10") % 7, 3)
4492 self.assertEqual(Decimal("10") - 7, 3)
4494 self.assertEqual(Decimal("1.12345").to_integral_exact(), 1)
4497 self.assertTrue(Decimal("1").is_canonical())
4498 self.assertTrue(Decimal("1").is_finite())
4499 self.assertTrue(Decimal("1").is_finite())
4500 self.assertTrue(Decimal("snan").is_snan())
4501 self.assertTrue(Decimal("-1").is_signed())
4502 self.assertTrue(Decimal("0").is_zero())
4503 self.assertTrue(Decimal("0").is_zero())
4509 y = -Decimal(x)
4517 z = y.copy_sign(Decimal(1))
4521 Decimal = self.decimal.Decimal
4522 localcontext = self.decimal.localcontext
4523 InvalidOperation = self.decimal.InvalidOperation
4524 DivisionByZero = self.decimal.DivisionByZero
4527 q, r = divmod(Decimal("10912837129"), 1001)
4528 self.assertEqual(q, Decimal('10901935'))
4529 self.assertEqual(r, Decimal('194'))
4531 q, r = divmod(Decimal("NaN"), 7)
4535 q, r = divmod(Decimal("NaN"), 7)
4540 q, r = divmod(Decimal("inf"), Decimal("inf"))
4545 q, r = divmod(Decimal("inf"), 101)
4550 q, r = divmod(Decimal(0), 0)
4556 q, r = divmod(Decimal(11), 0)
4562 Decimal = self.decimal.Decimal
4563 localcontext = self.decimal.localcontext
4564 Overflow = self.decimal.Overflow
4565 Rounded = self.decimal.Rounded
4570 self.assertEqual(Decimal("1.0") ** 100, Decimal('1.00'))
4578 self.assertEqual(Decimal(10000) ** Decimal("0.5"), Decimal('inf'))
4582 Decimal = self.decimal.Decimal
4583 localcontext = self.decimal.localcontext
4584 InvalidOperation = self.decimal.InvalidOperation
4591 x = Decimal(99).quantize(Decimal("1e1"))
4595 Decimal = self.decimal.Decimal
4596 getcontext = self.decimal.getcontext
4599 self.assertEqual(Decimal("1").radix(), 10)
4603 Decimal = self.decimal.Decimal
4607 self.assertIs(getattr(Decimal("1"), attr)("xyz"), NotImplemented)
4610 # Python3 behavior: round() returns Decimal
4611 Decimal = self.decimal.Decimal
4612 localcontext = self.decimal.localcontext
4617 self.assertEqual(str(Decimal("9.99").__round__()), "10")
4618 self.assertEqual(str(Decimal("9.99e-5").__round__()), "0")
4619 self.assertEqual(str(Decimal("1.23456789").__round__(5)), "1.23457")
4620 self.assertEqual(str(Decimal("1.2345").__round__(10)), "1.2345000000")
4621 self.assertEqual(str(Decimal("1.2345").__round__(-10)), "0E+10")
4623 self.assertRaises(TypeError, Decimal("1.23").__round__, "5")
4624 self.assertRaises(TypeError, Decimal("1.23").__round__, 5, 8)
4627 c = self.decimal.Context()
4631 Decimal = self.decimal.Decimal
4632 localcontext = self.decimal.localcontext
4636 x = Decimal(1221**1271) / 10**3923
4641 Context = self.decimal.Context
4658 decimal = C variable in CCoverage
4660 decimal = P variable in PyCoverage
4672 """Extra functionality in decimal.py"""
4675 # triples giving a format, a Decimal, and the expected result
4676 Decimal = P.Decimal
4693 self.assertEqual(format(Decimal(d), fmt), result)
4696 """White box testing for decimal.py"""
4700 Decimal = P.Decimal
4705 x = Decimal(2**16) ** Decimal("-0.5")
4706 self.assertEqual(x, Decimal('0.00390625'))
4708 x = Decimal(2**16) ** Decimal("-0.6")
4709 self.assertEqual(x, Decimal('0.0012885819'))
4711 x = Decimal("256e7") ** Decimal("-0.5")
4713 x = Decimal(152587890625) ** Decimal('-0.0625')
4714 self.assertEqual(x, Decimal("0.2"))
4716 x = Decimal("152587890625e7") ** Decimal('-0.0625')
4718 x = Decimal(5**2659) ** Decimal('-0.0625')
4721 x = Decimal("152587890625") ** Decimal('-0.5')
4722 self.assertEqual(x, Decimal('3e-6'))
4724 x = Decimal("152587890625") ** Decimal('-0.5')
4725 self.assertEqual(x, Decimal('2.6e-6'))
4727 x = Decimal("152587890625") ** Decimal('-0.5')
4728 self.assertEqual(x, Decimal('2.56e-6'))
4730 x = Decimal("152587890625") ** Decimal('-0.5')
4731 self.assertEqual(x, Decimal('2.56e-6'))
4734 x = Decimal(2**578) ** Decimal("-0.5")
4744 D2 = Decimal(2)
4751 Decimal = P.Decimal
4759 d1 = Decimal('-25e55')
4760 b1 = Decimal('-25e55')
4761 d2 = Decimal('33e+33')
4762 b2 = Decimal('33e+33')
4779 Decimal(d1)
4829 Decimal = P.Decimal
4831 d = Decimal(45)
4832 e = Decimal(d)
4838 Decimal = P.Decimal
4842 x = Decimal("NaN")._rescale(3, ROUND_UP)
4847 Decimal = P.Decimal
4849 self.assertRaises(ValueError, Decimal("3.1234")._round, 0, ROUND_UP)
4856 # issue 8786: Add support for IEEE 754 contexts to decimal module.
4943 Decimal = C.Decimal
4954 y = Decimal(a) ** Decimal(b)
4958 self.assertRaises(TypeError, C.Decimal, 9, "xyz")
4962 Decimal = C.Decimal
4968 self.assertRaises(InvalidOperation, Decimal,
5204 Decimal = C.Decimal
5213 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5215 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5217 self.assertRaises(InvalidOperation, Decimal("1").__round__,
5219 self.assertRaises(C.InvalidOperation, Decimal("1").__round__,
5221 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5223 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5228 Decimal = C.Decimal
5231 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", [], 9)
5232 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", 9)
5233 self.assertRaises(TypeError, Decimal(1).__format__, [])
5235 self.assertRaises(ValueError, Decimal(1).__format__, "<>=10.10")
5237 self.assertRaises(ValueError, Decimal("1.23456789").__format__,
5241 Decimal = C.Decimal
5245 x = Decimal(10)
5262 x = Decimal("99999999999999999999999999.9").to_integral_value(ROUND_UP)
5263 self.assertEqual(x, Decimal('100000000000000000000000000'))
5265 x = Decimal("99999999999999999999999999.9").to_integral_exact(ROUND_UP)
5266 self.assertEqual(x, Decimal('100000000000000000000000000'))
5269 self.assertRaises(Inexact, Decimal("999.9").to_integral_exact, ROUND_UP)
5273 Decimal = C.Decimal
5279 self.assertEqual(Decimal('9.99e10').to_eng_string(), '99.9E+9')
5281 self.assertRaises(TypeError, pow, Decimal(1), 2, "3")
5282 self.assertRaises(TypeError, Decimal(9).number_class, "x", "y")
5283 self.assertRaises(TypeError, Decimal(9).same_quantum, 3, "x", "y")
5287 Decimal("1.23456789").quantize, Decimal('1e-100000'), []
5291 Decimal("1.23456789").quantize, Decimal('1e-100000'), getcontext()
5295 Decimal("1.23456789").quantize, Decimal('1e-100000'), 10
5299 Decimal("1.23456789").quantize, Decimal('1e-100000'), ROUND_UP, 1000
5306 self.assertRaises(TypeError, c.copy_sign, Decimal(1), "x", "y")
5312 self.assertEqual(str(c.canonical(Decimal(200))), '200')
5316 self.assertRaises(DivisionByZero, Decimal(9).__divmod__, 0)
5322 self.assertRaises(InvalidOperation, Decimal(9).__divmod__, 0)
5328 self.assertRaises(InvalidOperation, pow, Decimal(1000), 1, 501)
5331 Decimal = C.Decimal
5334 x = Decimal("10001111111")
5521 Decimal = C.Decimal
5532 return Decimal(x).__format__(fmt, override)
5558 Decimal = C.Decimal
5568 self.assertRaises(InvalidOperation, Decimal, x)
5571 self.assertRaises(InvalidOperation, Decimal, x)
5575 self.assertRaises(InvalidOperation, Decimal, x)
5579 self.assertRaises(InvalidOperation, Decimal, x)
5582 Decimal = C.Decimal
5598 self.assertRaises(InvalidOperation, Decimal, x)
5602 self.assertRaises(InvalidOperation, Decimal, x)
5607 self.assertRaises(InvalidOperation, Decimal, x)
5611 self.assertRaises(InvalidOperation, Decimal, x)
5616 self.assertRaises(OverflowError, Decimal, x)
5620 self.assertRaises(OverflowError, Decimal, x)
5624 self.assertEqual(str(Decimal(x)), '-sNaN')
5626 self.assertEqual(str(Decimal(x)), '-sNaN')
5628 self.assertEqual(str(Decimal(x)), '-sNaN1')
5631 Decimal = C.Decimal
5634 self.assertGreater(Decimal(0).__sizeof__(), 0)
5636 x = Decimal(10**(19*24)).__sizeof__()
5637 y = Decimal(10**(19*25)).__sizeof__()
5640 x = Decimal(10**(9*24)).__sizeof__()
5641 y = Decimal(10**(9*25)).__sizeof__()
5645 Decimal = C.Decimal
5669 self.assertEqual(Decimal.from_float(cls(101.1)),
5670 Decimal.from_float(101.1))
5679 C.Decimal,
5724 x = C.Decimal('6.09e+23')
5730 y = C.Decimal('6.09')
5746 if (attr == 'Decimal' or attr == 'Context' or
5774 pdict = {C: {'other': C.Decimal(1),
5775 'third': C.Decimal(1),
5776 'x': C.Decimal(1),
5777 'y': C.Decimal(1),
5778 'z': C.Decimal(1),
5779 'a': C.Decimal(1),
5780 'b': C.Decimal(1),
5781 'c': C.Decimal(1),
5782 'exp': C.Decimal(1),
5783 'modulo': C.Decimal(1),
5788 P: {'other': P.Decimal(1),
5789 'third': P.Decimal(1),
5790 'a': P.Decimal(1),
5791 'b': P.Decimal(1),
5792 'c': P.Decimal(1),
5793 'exp': P.Decimal(1),
5794 'modulo': P.Decimal(1),
5848 if ty == 'Decimal':
5868 doit('Decimal')
5893 {'decimal': mod})
5903 sys.modules['decimal'] = mod
5906 sys.modules['decimal'] = orig_sys_decimal
5910 sys.modules['decimal'] = mod
5913 sys.modules['decimal'] = orig_sys_decimal
5920 TEST_ALL = ARITH if ARITH is not None else is_resource_enabled('decimal')
5928 if not orig_sys_decimal is sys.modules['decimal']:
5930 "sys.modules['decimal'].")
5941 Runs all arithmetic tests if arith is True or if the "decimal" resource