Lines Matching refs:self
139 def setUp(self):
140 self.context = self.decimal.Context()
141 self.readcontext = self.decimal.Context()
142 self.ignore_list = ['#']
146 self.skipped_test_ids = set([
182 if self.decimal == C:
184 self.skipped_test_ids.add('pwsx803')
185 self.skipped_test_ids.add('pwsx805')
187 self.skipped_test_ids.add('powx4302')
188 self.skipped_test_ids.add('powx4303')
189 self.skipped_test_ids.add('powx4342')
190 self.skipped_test_ids.add('powx4343')
192 self.skipped_test_ids.add('pwmx325')
193 self.skipped_test_ids.add('pwmx326')
196 self.ChangeDict = {'precision' : self.change_precision,
197 'rounding' : self.change_rounding_method,
198 'maxexponent' : self.change_max_exponent,
199 'minexponent' : self.change_min_exponent,
200 'clamp' : self.change_clamp}
204 self.NameAdapter = {'and':'logical_and',
243 self.RoundingDict = {'ceiling' : ROUND_CEILING,
253 self.ErrorNames = {'clamped' : self.decimal.Clamped,
254 'conversion_syntax' : self.decimal.InvalidOperation,
255 'division_by_zero' : self.decimal.DivisionByZero,
256 'division_impossible' : self.decimal.InvalidOperation,
257 'division_undefined' : self.decimal.InvalidOperation,
258 'inexact' : self.decimal.Inexact,
259 'invalid_context' : self.decimal.InvalidOperation,
260 'invalid_operation' : self.decimal.InvalidOperation,
261 'overflow' : self.decimal.Overflow,
262 'rounded' : self.decimal.Rounded,
263 'subnormal' : self.decimal.Subnormal,
264 'underflow' : self.decimal.Underflow}
268 self.LogicalFunctions = ('is_canonical',
280 def read_unlimited(self, v, context):
286 if self.decimal == C and self.decimal.MAX_EMAX == 425000000:
287 self.readcontext._unsafe_setprec(1070000000)
288 self.readcontext._unsafe_setemax(1070000000)
289 self.readcontext._unsafe_setemin(-1070000000)
290 return self.readcontext.create_decimal(v)
292 return self.decimal.Decimal(v, context)
294 def eval_file(self, file):
303 t = self.eval_line(line)
304 except self.decimal.DecimalException as exception:
306 self.fail('Exception "'+exception.__class__.__name__ + '" raised on line '+line)
309 def eval_line(self, s):
316 for ignore in self.ignore_list:
323 return self.eval_directive(s)
325 return self.eval_equation(s)
327 def eval_directive(self, s):
330 value = self.RoundingDict[value]
337 funct = self.ChangeDict.get(funct, (lambda *args: None))
340 def eval_equation(self, s):
345 self.context.clear_flags()
359 raise self.decimal.InvalidOperation
366 if id in self.skipped_test_ids:
369 fname = self.NameAdapter.get(funct, funct)
372 funct = getattr(self.context, fname)
376 theirexceptions = [self.ErrorNames[x.lower()] for x in exceptions]
378 for exception in Signals[self.decimal]:
379 self.context.traps[exception] = 1 #Catch these bugs...
381 self.context.traps[exception] = 0
395 self.context.traps[error] = 1
397 funct(self.context.create_decimal(v))
400 except Signals[self.decimal] as e:
401 self.fail("Raised %s in %s when %s disabled" % \
404 self.fail("Did not raise %s in %s" % (error, s))
405 self.context.traps[error] = 0
406 v = self.context.create_decimal(v)
408 v = self.read_unlimited(v, self.context)
415 self.context.traps[error] = 1
420 except Signals[self.decimal] as e:
421 self.fail("Raised %s in %s when %s disabled" % \
424 self.fail("Did not raise %s in %s" % (error, s))
425 self.context.traps[error] = 0
428 ordered_errors = [e for e in OrderedSignals[self.decimal] if e in theirexceptions]
430 self.context.traps[error] = 1
435 except Signals[self.decimal] as e:
436 self.fail("Raised %s in %s; expected %s" %
439 self.fail("Did not raise %s in %s" % (error, s))
442 self.context.traps[error] = 0
446 print("--", self.context)
449 if fname in self.LogicalFunctions:
451 except Signals[self.decimal] as error:
452 self.fail("Raised %s in %s" % (error, s))
457 myexceptions = self.getexceptions()
462 self.assertEqual(result, ans,
465 self.assertEqual(myexceptions, theirexceptions,
468 def getexceptions(self):
469 return [e for e in Signals[self.decimal] if self.context.flags[e]]
471 def change_precision(self, prec):
472 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
473 self.context._unsafe_setprec(prec)
475 self.context.prec = prec
476 def change_rounding_method(self, rounding):
477 self.context.rounding = rounding
478 def change_min_exponent(self, exp):
479 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
480 self.context._unsafe_setemin(exp)
482 self.context.Emin = exp
483 def change_max_exponent(self, exp):
484 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
485 self.context._unsafe_setemax(exp)
487 self.context.Emax = exp
488 def change_clamp(self, clamp):
489 self.context.clamp = clamp
501 def test_explicit_empty(self):
502 Decimal = self.decimal.Decimal
503 self.assertEqual(Decimal(), Decimal("0"))
505 def test_explicit_from_None(self):
506 Decimal = self.decimal.Decimal
507 self.assertRaises(TypeError, Decimal, None)
509 def test_explicit_from_int(self):
510 Decimal = self.decimal.Decimal
514 self.assertEqual(str(d), '45')
518 self.assertEqual(str(d), '500000123')
522 self.assertEqual(str(d), '-45')
526 self.assertEqual(str(d), '0')
534 self.assertEqual(str(d), str(i))
536 def test_explicit_from_string(self):
537 Decimal = self.decimal.Decimal
538 InvalidOperation = self.decimal.InvalidOperation
539 localcontext = self.decimal.localcontext
542 self.assertEqual(str(Decimal('')), 'NaN')
545 self.assertEqual(str(Decimal('45')), '45')
548 self.assertEqual(str(Decimal('45.34')), '45.34')
551 self.assertEqual(str(Decimal('45e2')), '4.5E+3')
554 self.assertEqual(str(Decimal('ugly')), 'NaN')
557 self.assertEqual(str(Decimal('1.3E4 \n')), '1.3E+4')
558 self.assertEqual(str(Decimal(' -7.89')), '-7.89')
559 self.assertEqual(str(Decimal(" 3.45679 ")), '3.45679')
562 self.assertEqual(str(Decimal('1_3.3e4_0')), '1.33E+41')
563 self.assertEqual(str(Decimal('1_0_0_0')), '1000')
568 self.assertEqual(str(Decimal(lead + '9.311E+28' + trail)),
574 self.assertRaises(InvalidOperation, Decimal, "xyz")
576 self.assertRaises(TypeError, Decimal, "1234", "x", "y")
579 self.assertRaises(InvalidOperation, Decimal, "1\u00a02\u00a03")
580 self.assertRaises(InvalidOperation, Decimal, "\u00a01\u00a02\u00a0")
583 self.assertRaises(InvalidOperation, Decimal, "\u00a0")
584 self.assertRaises(InvalidOperation, Decimal, "\u00a0\u00a0")
587 self.assertRaises(InvalidOperation, Decimal, "12\u00003")
590 self.assertRaises(InvalidOperation, Decimal, "1_2_\u00003")
595 def test_from_legacy_strings(self):
597 Decimal = self.decimal.Decimal
598 context = self.decimal.Context()
601 self.assertEqual(str(Decimal(s)), '9.999999')
602 self.assertEqual(str(context.create_decimal(s)), '9.999999')
604 def test_explicit_from_tuples(self):
605 Decimal = self.decimal.Decimal
609 self.assertEqual(str(d), '0')
613 self.assertEqual(str(d), '-45')
617 self.assertEqual(str(d), '45.34')
621 self.assertEqual(str(d), '-4.34913534E-17')
625 self.assertEqual(str(d), 'Infinity')
628 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1)) )
631 self.assertRaises(ValueError, Decimal, (8, (4, 3, 4, 9, 1), 2) )
632 self.assertRaises(ValueError, Decimal, (0., (4, 3, 4, 9, 1), 2) )
633 self.assertRaises(ValueError, Decimal, (Decimal(1), (4, 3, 4, 9, 1), 2))
636 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!') )
637 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 0.) )
638 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), '1') )
641 self.assertRaises(ValueError, Decimal, (1, "xyz", 2) )
642 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) )
643 self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) )
644 self.assertRaises(ValueError, Decimal, (1, (4, 10, 4, 9, 1), 2) )
645 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 'a', 1), 2) )
647 def test_explicit_from_list(self):
648 Decimal = self.decimal.Decimal
651 self.assertEqual(str(d), '0')
654 self.assertEqual(str(d), '-4.34913534E-17')
657 self.assertEqual(str(d), '-4.34913534E-17')
660 self.assertEqual(str(d), '-4.34913534E-17')
662 def test_explicit_from_bool(self):
663 Decimal = self.decimal.Decimal
665 self.assertIs(bool(Decimal(0)), False)
666 self.assertIs(bool(Decimal(1)), True)
667 self.assertEqual(Decimal(False), Decimal(0))
668 self.assertEqual(Decimal(True), Decimal(1))
670 def test_explicit_from_Decimal(self):
671 Decimal = self.decimal.Decimal
676 self.assertEqual(str(e), '45')
681 self.assertEqual(str(e), '500000123')
686 self.assertEqual(str(e), '-45')
691 self.assertEqual(str(e), '0')
694 def test_explicit_from_float(self):
696 Decimal = self.decimal.Decimal
699 self.assertEqual(type(r), Decimal)
700 self.assertEqual(str(r),
702 self.assertTrue(Decimal(float('nan')).is_qnan())
703 self.assertTrue(Decimal(float('inf')).is_infinite())
704 self.assertTrue(Decimal(float('-inf')).is_infinite())
705 self.assertEqual(str(Decimal(float('nan'))),
707 self.assertEqual(str(Decimal(float('inf'))),
709 self.assertEqual(str(Decimal(float('-inf'))),
711 self.assertEqual(str(Decimal(float('-0.0'))),
715 self.assertEqual(x, float(Decimal(x))) # roundtrip
717 def test_explicit_context_create_decimal(self):
718 Decimal = self.decimal.Decimal
719 InvalidOperation = self.decimal.InvalidOperation
720 Rounded = self.decimal.Rounded
722 nc = copy.copy(self.decimal.getcontext())
727 self.assertEqual(str(d), '0')
729 self.assertEqual(str(d), '0')
732 self.assertRaises(TypeError, nc.create_decimal, None)
736 self.assertIsInstance(d, Decimal)
737 self.assertEqual(nc.create_decimal(45678),
742 self.assertEqual(str(d), '456789')
744 self.assertEqual(str(d), '4.57E+5')
748 self.assertEqual(str(nc.create_decimal('3.14\n')), 'NaN')
752 self.assertEqual(str(d), '-4.34913534E-17')
754 self.assertEqual(str(d), '-4.35E-17')
759 self.assertEqual(str(d), '500000123')
761 self.assertEqual(str(d), '5.00E+8')
770 self.assertTrue(isinstance(d, Decimal))
771 self.assertEqual(int(d), v)
775 self.assertRaises(Rounded, nc.create_decimal, 1234)
779 self.assertEqual(str(nc.create_decimal('0E-017')), '0E-17')
780 self.assertEqual(str(nc.create_decimal('45')), '45')
781 self.assertEqual(str(nc.create_decimal('-Inf')), '-Infinity')
782 self.assertEqual(str(nc.create_decimal('NaN123')), 'NaN123')
785 self.assertRaises(InvalidOperation, nc.create_decimal, "xyz")
786 self.assertRaises(ValueError, nc.create_decimal, (1, "xyz", -25))
787 self.assertRaises(TypeError, nc.create_decimal, "1234", "5678")
789 self.assertRaises(InvalidOperation, nc.create_decimal, " 1234")
790 self.assertRaises(InvalidOperation, nc.create_decimal, "12_34")
794 self.assertRaises(InvalidOperation, nc.create_decimal, 'NaN12345')
795 self.assertRaises(InvalidOperation, nc.create_decimal,
799 self.assertEqual(str(nc.create_decimal('NaN12345')), 'NaN')
800 self.assertTrue(nc.flags[InvalidOperation])
803 self.assertEqual(str(nc.create_decimal(Decimal('NaN12345'))), 'NaN')
804 self.assertTrue(nc.flags[InvalidOperation])
806 def test_explicit_context_create_from_float(self):
808 Decimal = self.decimal.Decimal
810 nc = self.decimal.Context()
812 self.assertEqual(type(r), Decimal)
813 self.assertEqual(str(r), '0.1000000000000000055511151231')
814 self.assertTrue(nc.create_decimal(float('nan')).is_qnan())
815 self.assertTrue(nc.create_decimal(float('inf')).is_infinite())
816 self.assertTrue(nc.create_decimal(float('-inf')).is_infinite())
817 self.assertEqual(str(nc.create_decimal(float('nan'))),
819 self.assertEqual(str(nc.create_decimal(float('inf'))),
821 self.assertEqual(str(nc.create_decimal(float('-inf'))),
823 self.assertEqual(str(nc.create_decimal(float('-0.0'))),
828 self.assertEqual(x, float(nc.create_decimal(x))) # roundtrip
830 def test_unicode_digits(self):
831 Decimal = self.decimal.Decimal
839 self.assertEqual(str(Decimal(input)), expected)
849 def test_implicit_from_None(self):
850 Decimal = self.decimal.Decimal
851 self.assertRaises(TypeError, eval, 'Decimal(5) + None', locals())
853 def test_implicit_from_int(self):
854 Decimal = self.decimal.Decimal
857 self.assertEqual(str(Decimal(5) + 45), '50')
859 self.assertEqual(Decimal(5) + 123456789000, Decimal(123456789000))
861 def test_implicit_from_string(self):
862 Decimal = self.decimal.Decimal
863 self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', locals())
865 def test_implicit_from_float(self):
866 Decimal = self.decimal.Decimal
867 self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', locals())
869 def test_implicit_from_Decimal(self):
870 Decimal = self.decimal.Decimal
871 self.assertEqual(Decimal(5) + Decimal(45), Decimal(50))
873 def test_rop(self):
874 Decimal = self.decimal.Decimal
878 def __divmod__(self, other):
880 def __rdivmod__(self, other):
882 def __lt__(self, other):
884 def __gt__(self, other):
886 def __le__(self, other):
888 def __ge__(self, other):
890 def __eq__(self, other):
892 def __ne__(self, other):
895 self.assertEqual(divmod(E(), Decimal(10)), 'divmod 10')
896 self.assertEqual(divmod(Decimal(10), E()), '10 rdivmod')
897 self.assertEqual(eval('Decimal(10) < E()'), 'gt 10')
898 self.assertEqual(eval('Decimal(10) > E()'), 'lt 10')
899 self.assertEqual(eval('Decimal(10) <= E()'), 'ge 10')
900 self.assertEqual(eval('Decimal(10) >= E()'), 'le 10')
901 self.assertEqual(eval('Decimal(10) == E()'), 'eq 10')
902 self.assertEqual(eval('Decimal(10) != E()'), 'ne 10')
916 setattr(E, lop, lambda self, other: 'str' + lop + str(other))
917 setattr(E, rop, lambda self, other: str(other) + rop + 'str')
918 self.assertEqual(eval('E()' + sym + 'Decimal(10)'),
920 self.assertEqual(eval('Decimal(10)' + sym + 'E()'),
930 def test_formatting(self):
931 Decimal = self.decimal.Decimal
1135 self.assertEqual(format(Decimal(d), fmt), result)
1138 self.assertRaises(TypeError, Decimal(1).__format__, b'-020')
1140 def test_negative_zero_format_directed_rounding(self):
1141 with self.decimal.localcontext() as ctx:
1143 self.assertEqual(format(self.decimal.Decimal('-0.001'), 'z.2f'),
1146 def test_negative_zero_bad_format(self):
1147 self.assertRaises(ValueError, format, self.decimal.Decimal('1.23'), 'fz')
1149 def test_n_format(self):
1150 Decimal = self.decimal.Decimal
1155 self.skipTest('locale.CHAR_MAX not available')
1158 return ''.join([chr(x) for x in lst]) if self.decimal == C else lst
1161 if self.decimal == C:
1197 self.assertEqual(get_fmt(Decimal('12.7'), en_US), '12.7')
1198 self.assertEqual(get_fmt(Decimal('12.7'), fr_FR), '12,7')
1199 self.assertEqual(get_fmt(Decimal('12.7'), ru_RU), '12,7')
1200 self.assertEqual(get_fmt(Decimal('12.7'), crazy), '1-2&7')
1202 self.assertEqual(get_fmt(123456789, en_US), '123,456,789')
1203 self.assertEqual(get_fmt(123456789, fr_FR), '123456789')
1204 self.assertEqual(get_fmt(123456789, ru_RU), '123 456 789')
1205 self.assertEqual(get_fmt(1234567890123, crazy), '123456-78-9012-3')
1207 self.assertEqual(get_fmt(123456789, en_US, '.6n'), '1.23457e+8')
1208 self.assertEqual(get_fmt(123456789, fr_FR, '.6n'), '1,23457e+8')
1209 self.assertEqual(get_fmt(123456789, ru_RU, '.6n'), '1,23457e+8')
1210 self.assertEqual(get_fmt(123456789, crazy, '.6n'), '1&23457e+8')
1213 self.assertEqual(get_fmt(1234, fr_FR, '03n'), '1234')
1214 self.assertEqual(get_fmt(1234, fr_FR, '04n'), '1234')
1215 self.assertEqual(get_fmt(1234, fr_FR, '05n'), '01234')
1216 self.assertEqual(get_fmt(1234, fr_FR, '06n'), '001234')
1218 self.assertEqual(get_fmt(12345, en_US, '05n'), '12,345')
1219 self.assertEqual(get_fmt(12345, en_US, '06n'), '12,345')
1220 self.assertEqual(get_fmt(12345, en_US, '07n'), '012,345')
1221 self.assertEqual(get_fmt(12345, en_US, '08n'), '0,012,345')
1222 self.assertEqual(get_fmt(12345, en_US, '09n'), '0,012,345')
1223 self.assertEqual(get_fmt(12345, en_US, '010n'), '00,012,345')
1225 self.assertEqual(get_fmt(123456, crazy, '06n'), '1-2345-6')
1226 self.assertEqual(get_fmt(123456, crazy, '07n'), '1-2345-6')
1227 self.assertEqual(get_fmt(123456, crazy, '08n'), '1-2345-6')
1228 self.assertEqual(get_fmt(123456, crazy, '09n'), '01-2345-6')
1229 self.assertEqual(get_fmt(123456, crazy, '010n'), '0-01-2345-6')
1230 self.assertEqual(get_fmt(123456, crazy, '011n'), '0-01-2345-6')
1231 self.assertEqual(get_fmt(123456, crazy, '012n'), '00-01-2345-6')
1232 self.assertEqual(get_fmt(123456, crazy, '013n'), '000-01-2345-6')
1235 self.assertEqual(get_fmt(Decimal('-1.5'), dotsep_wide, '020n'),
1239 def test_wide_char_separator_decimal_point(self):
1241 Decimal = self.decimal.Decimal
1246 self.skipTest('inappropriate decimal point separator '
1249 self.skipTest('inappropriate thousands separator '
1252 self.assertEqual(format(Decimal('100000000.123'), 'n'),
1255 def test_decimal_from_float_argument_type(self):
1256 class A(self.decimal.Decimal):
1257 def __init__(self, a):
1258 self.a_type = type(a)
1260 self.assertEqual(self.decimal.Decimal, a.a_type)
1263 self.assertEqual(self.decimal.Decimal, a.a_type)
1273 def test_addition(self):
1274 Decimal = self.decimal.Decimal
1280 self.assertEqual(d1+d2, Decimal('11.1'))
1281 self.assertEqual(d2+d1, Decimal('11.1'))
1285 self.assertEqual(c, Decimal('-6.1'))
1286 self.assertEqual(type(c), type(d1))
1290 self.assertEqual(c, Decimal('-6.1'))
1291 self.assertEqual(type(c), type(d1))
1295 self.assertEqual(d1, Decimal('11.1'))
1299 self.assertEqual(d1, Decimal('16.1'))
1301 def test_subtraction(self):
1302 Decimal = self.decimal.Decimal
1308 self.assertEqual(d1-d2, Decimal('-33.3'))
1309 self.assertEqual(d2-d1, Decimal('33.3'))
1313 self.assertEqual(c, Decimal('-16.1'))
1314 self.assertEqual(type(c), type(d1))
1318 self.assertEqual(c, Decimal('16.1'))
1319 self.assertEqual(type(c), type(d1))
1323 self.assertEqual(d1, Decimal('-33.3'))
1327 self.assertEqual(d1, Decimal('-38.3'))
1329 def test_multiplication(self):
1330 Decimal = self.decimal.Decimal
1336 self.assertEqual(d1*d2, Decimal('-15'))
1337 self.assertEqual(d2*d1, Decimal('-15'))
1341 self.assertEqual(c, Decimal('-25'))
1342 self.assertEqual(type(c), type(d1))
1346 self.assertEqual(c, Decimal('-25'))
1347 self.assertEqual(type(c), type(d1))
1351 self.assertEqual(d1, Decimal('-15'))
1355 self.assertEqual(d1, Decimal('-75'))
1357 def test_division(self):
1358 Decimal = self.decimal.Decimal
1364 self.assertEqual(d1/d2, Decimal('-2.5'))
1365 self.assertEqual(d2/d1, Decimal('-0.4'))
1369 self.assertEqual(c, Decimal('-1.25'))
1370 self.assertEqual(type(c), type(d1))
1374 self.assertEqual(c, Decimal('-0.8'))
1375 self.assertEqual(type(c), type(d1))
1379 self.assertEqual(d1, Decimal('-2.5'))
1383 self.assertEqual(d1, Decimal('-0.625'))
1385 def test_floor_division(self):
1386 Decimal = self.decimal.Decimal
1392 self.assertEqual(d1//d2, Decimal('2'))
1393 self.assertEqual(d2//d1, Decimal('0'))
1397 self.assertEqual(c, Decimal('1'))
1398 self.assertEqual(type(c), type(d1))
1402 self.assertEqual(c, Decimal('1'))
1403 self.assertEqual(type(c), type(d1))
1407 self.assertEqual(d1, Decimal('2'))
1411 self.assertEqual(d1, Decimal('1'))
1413 def test_powering(self):
1414 Decimal = self.decimal.Decimal
1420 self.assertEqual(d1**d2, Decimal('25'))
1421 self.assertEqual(d2**d1, Decimal('32'))
1425 self.assertEqual(c, Decimal('625'))
1426 self.assertEqual(type(c), type(d1))
1430 self.assertEqual(c, Decimal('16807'))
1431 self.assertEqual(type(c), type(d1))
1435 self.assertEqual(d1, Decimal('25'))
1439 self.assertEqual(d1, Decimal('390625'))
1441 def test_module(self):
1442 Decimal = self.decimal.Decimal
1448 self.assertEqual(d1%d2, Decimal('1'))
1449 self.assertEqual(d2%d1, Decimal('2'))
1453 self.assertEqual(c, Decimal('1'))
1454 self.assertEqual(type(c), type(d1))
1458 self.assertEqual(c, Decimal('2'))
1459 self.assertEqual(type(c), type(d1))
1463 self.assertEqual(d1, Decimal('1'))
1467 self.assertEqual(d1, Decimal('1'))
1469 def test_floor_div_module(self):
1470 Decimal = self.decimal.Decimal
1477 self.assertEqual(p, Decimal('2'))
1478 self.assertEqual(q, Decimal('1'))
1479 self.assertEqual(type(p), type(d1))
1480 self.assertEqual(type(q), type(d1))
1484 self.assertEqual(p, Decimal('1'))
1485 self.assertEqual(q, Decimal('1'))
1486 self.assertEqual(type(p), type(d1))
1487 self.assertEqual(type(q), type(d1))
1491 self.assertEqual(p, Decimal('1'))
1492 self.assertEqual(q, Decimal('2'))
1493 self.assertEqual(type(p), type(d1))
1494 self.assertEqual(type(q), type(d1))
1496 def test_unary_operators(self):
1497 Decimal = self.decimal.Decimal
1499 self.assertEqual(+Decimal(45), Decimal(+45)) # +
1500 self.assertEqual(-Decimal(45), Decimal(-45)) # -
1501 self.assertEqual(abs(Decimal(45)), abs(Decimal(-45))) # abs
1503 def test_nan_comparisons(self):
1511 Decimal = self.decimal.Decimal
1512 InvalidOperation = self.decimal.InvalidOperation
1513 localcontext = self.decimal.localcontext
1530 self.assertIs(expected, got,
1543 self.assertIs(expected, got,
1551 self.assertRaises(InvalidOperation, operator.eq, x, y)
1552 self.assertRaises(InvalidOperation, operator.ne, x, y)
1556 self.assertRaises(InvalidOperation, op, x, y)
1558 def test_copy_sign(self):
1559 Decimal = self.decimal.Decimal
1562 self.assertEqual(Decimal(1).copy_sign(-2), d)
1563 self.assertRaises(TypeError, Decimal(1).copy_sign, '-2')
1663 def test_threading(self):
1664 DefaultContext = self.decimal.DefaultContext
1666 if self.decimal == C and not self.decimal.HAVE_THREADS:
1667 self.skipTest("compiled without threading")
1678 self.synchro = threading.Event()
1679 self.finish1 = threading.Event()
1680 self.finish2 = threading.Event()
1682 th1 = threading.Thread(target=thfunc1, args=(self,))
1683 th2 = threading.Thread(target=thfunc2, args=(self,))
1688 self.finish1.wait()
1689 self.finish2.wait()
1691 for sig in Signals[self.decimal]:
1692 self.assertFalse(DefaultContext.flags[sig])
1711 def test_comparison_operators(self):
1713 Decimal = self.decimal.Decimal
1720 self.assertGreater(dc, da)
1721 self.assertGreaterEqual(dc, da)
1722 self.assertLess(da, dc)
1723 self.assertLessEqual(da, dc)
1724 self.assertEqual(da, db)
1725 self.assertNotEqual(da, dc)
1726 self.assertLessEqual(da, db)
1727 self.assertGreaterEqual(da, db)
1730 self.assertGreater(dc, 23)
1731 self.assertLess(23, dc)
1732 self.assertEqual(dc, 45)
1735 self.assertNotEqual(da, 'ugly')
1736 self.assertNotEqual(da, 32.7)
1737 self.assertNotEqual(da, object())
1738 self.assertNotEqual(da, object)
1745 self.assertEqual(a, b)
1747 def test_decimal_float_comparison(self):
1748 Decimal = self.decimal.Decimal
1752 self.assertLess(da, 3.0)
1753 self.assertLessEqual(da, 3.0)
1754 self.assertGreater(db, 0.25)
1755 self.assertGreaterEqual(db, 0.25)
1756 self.assertNotEqual(da, 1.5)
1757 self.assertEqual(da, 0.25)
1758 self.assertGreater(3.0, da)
1759 self.assertGreaterEqual(3.0, da)
1760 self.assertLess(0.25, db)
1761 self.assertLessEqual(0.25, db)
1762 self.assertNotEqual(0.25, db)
1763 self.assertEqual(3.0, db)
1764 self.assertNotEqual(0.1, Decimal('0.1'))
1766 def test_decimal_complex_comparison(self):
1767 Decimal = self.decimal.Decimal
1771 self.assertNotEqual(da, (1.5+0j))
1772 self.assertNotEqual((1.5+0j), da)
1773 self.assertEqual(da, (0.25+0j))
1774 self.assertEqual((0.25+0j), da)
1775 self.assertEqual((3.0+0j), db)
1776 self.assertEqual(db, (3.0+0j))
1778 self.assertNotEqual(db, (3.0+1j))
1779 self.assertNotEqual((3.0+1j), db)
1781 self.assertIs(db.__lt__(3.0+0j), NotImplemented)
1782 self.assertIs(db.__le__(3.0+0j), NotImplemented)
1783 self.assertIs(db.__gt__(3.0+0j), NotImplemented)
1784 self.assertIs(db.__le__(3.0+0j), NotImplemented)
1786 def test_decimal_fraction_comparison(self):
1787 D = self.decimal.Decimal
1788 F = fractions[self.decimal].Fraction
1789 Context = self.decimal.Context
1790 localcontext = self.decimal.localcontext
1791 InvalidOperation = self.decimal.InvalidOperation
1801 self.assertLess(D(0), F(1,9999999999999999999999999999999999999))
1802 self.assertLess(F(-1,9999999999999999999999999999999999999), D(0))
1803 self.assertLess(F(0,1), D("1e" + str(etiny)))
1804 self.assertLess(D("-1e" + str(etiny)), F(0,1))
1805 self.assertLess(F(0,9999999999999999999999999), D("1e" + str(etiny)))
1806 self.assertLess(D("-1e" + str(etiny)), F(0,9999999999999999999999999))
1808 self.assertEqual(D("0.1"), F(1,10))
1809 self.assertEqual(F(1,10), D("0.1"))
1812 self.assertNotEqual(D(1)/3, F(1,3))
1813 self.assertNotEqual(F(1,3), D(1)/3)
1815 self.assertLessEqual(F(120984237, 9999999999), D("9e" + str(emax)))
1816 self.assertGreaterEqual(D("9e" + str(emax)), F(120984237, 9999999999))
1818 self.assertGreater(D('inf'), F(99999999999,123))
1819 self.assertGreater(D('inf'), F(-99999999999,123))
1820 self.assertLess(D('-inf'), F(99999999999,123))
1821 self.assertLess(D('-inf'), F(-99999999999,123))
1823 self.assertRaises(InvalidOperation, D('nan').__gt__, F(-9,123))
1824 self.assertIs(NotImplemented, F(-9,123).__lt__(D('nan')))
1825 self.assertNotEqual(D('nan'), F(-9,123))
1826 self.assertNotEqual(F(-9,123), D('nan'))
1828 def test_copy_and_deepcopy_methods(self):
1829 Decimal = self.decimal.Decimal
1833 self.assertEqual(id(c), id(d))
1835 self.assertEqual(id(dc), id(d))
1837 def test_hash_method(self):
1839 Decimal = self.decimal.Decimal
1840 localcontext = self.decimal.localcontext
1845 self.assertEqual(a, b)
1885 self.assertEqual(hashit(value), hash(int(value)))
1894 self.assertEqual(hashit(d), hash(f))
1908 self.assertEqual(h1, h2)
1909 self.assertEqual(h1, h3)
1913 self.assertEqual(hashit(Decimal(x)), hashit(x))
1915 def test_hash_method_nan(self):
1916 Decimal = self.decimal.Decimal
1917 self.assertRaises(TypeError, hash, Decimal('sNaN'))
1919 self.assertEqual(hash(value), object.__hash__(value))
1921 def __hash__(self):
1926 self.assertEqual(hash(value), object.__hash__(value))
1928 def test_min_and_max_methods(self):
1929 Decimal = self.decimal.Decimal
1937 self.assertIs(min(d1,d2), d1)
1938 self.assertIs(min(d2,d1), d1)
1939 self.assertIs(max(d1,d2), d2)
1940 self.assertIs(max(d2,d1), d2)
1943 self.assertIs(min(d1,l2), d1)
1944 self.assertIs(min(l2,d1), d1)
1945 self.assertIs(max(l1,d2), d2)
1946 self.assertIs(max(d2,l1), d2)
1948 def test_as_nonzero(self):
1949 Decimal = self.decimal.Decimal
1952 self.assertFalse(Decimal(0))
1954 self.assertTrue(Decimal('0.372'))
1956 def test_tostring_methods(self):
1958 Decimal = self.decimal.Decimal
1961 self.assertEqual(str(d), '15.32') # str
1962 self.assertEqual(repr(d), "Decimal('15.32')") # repr
1964 def test_tonum_methods(self):
1966 Decimal = self.decimal.Decimal
1972 self.assertEqual(int(d1), 66)
1973 self.assertEqual(int(d2), 15)
1976 self.assertEqual(float(d1), 66)
1977 self.assertEqual(float(d2), 15.32)
1992 self.assertEqual(math.floor(Decimal(d)), i)
1993 self.assertRaises(ValueError, math.floor, Decimal('-NaN'))
1994 self.assertRaises(ValueError, math.floor, Decimal('sNaN'))
1995 self.assertRaises(ValueError, math.floor, Decimal('NaN123'))
1996 self.assertRaises(OverflowError, math.floor, Decimal('Inf'))
1997 self.assertRaises(OverflowError, math.floor, Decimal('-Inf'))
2012 self.assertEqual(math.ceil(Decimal(d)), i)
2013 self.assertRaises(ValueError, math.ceil, Decimal('-NaN'))
2014 self.assertRaises(ValueError, math.ceil, Decimal('sNaN'))
2015 self.assertRaises(ValueError, math.ceil, Decimal('NaN123'))
2016 self.assertRaises(OverflowError, math.ceil, Decimal('Inf'))
2017 self.assertRaises(OverflowError, math.ceil, Decimal('-Inf'))
2039 self.assertEqual(round(Decimal(d)), i)
2040 self.assertRaises(ValueError, round, Decimal('-NaN'))
2041 self.assertRaises(ValueError, round, Decimal('sNaN'))
2042 self.assertRaises(ValueError, round, Decimal('NaN123'))
2043 self.assertRaises(OverflowError, round, Decimal('Inf'))
2044 self.assertRaises(OverflowError, round, Decimal('-Inf'))
2065 self.assertEqual(str(round(Decimal(d), n)), r)
2067 def test_nan_to_float(self):
2070 Decimal = self.decimal.Decimal
2073 self.assertTrue(math.isnan(f))
2075 self.assertEqual(sign, -1.0 if s.startswith('-') else 1.0)
2077 def test_snan_to_float(self):
2078 Decimal = self.decimal.Decimal
2081 self.assertRaises(ValueError, float, d)
2083 def test_eval_round_trip(self):
2084 Decimal = self.decimal.Decimal
2088 self.assertEqual(d, eval(repr(d)))
2092 self.assertEqual(d, eval(repr(d)))
2096 self.assertEqual(d, eval(repr(d)))
2100 self.assertEqual(d, eval(repr(d)))
2102 def test_as_tuple(self):
2103 Decimal = self.decimal.Decimal
2107 self.assertEqual(d.as_tuple(), (0, (0,), 0) )
2111 self.assertEqual(d.as_tuple(), (1, (4, 5), 0) )
2115 self.assertEqual(d.as_tuple(), (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
2120 self.assertEqual(d.as_tuple(), (0, (0,), 'F') )
2124 self.assertEqual(d.as_tuple(), (0, (4, 0, 5, 3, 4), -2) )
2126 self.assertEqual(d.as_tuple(), (1, (0,), 37))
2128 self.assertEqual(d.as_tuple(), (1, (0,), 37))
2132 self.assertEqual(d.as_tuple(), (0, (4, 0, 5, 3, 4), 'n') )
2134 self.assertEqual(d.as_tuple(), (1, (), 'N') )
2136 self.assertEqual(d.as_tuple(), (1, (), 'n') )
2141 self.assertEqual(d.as_tuple(), (0, (0,), 'F'))
2143 self.assertEqual(d.as_tuple(), (0, (0,), 'F'))
2145 self.assertEqual(d.as_tuple(), (1, (0,), 'F'))
2147 def test_as_integer_ratio(self):
2148 Decimal = self.decimal.Decimal
2151 self.assertRaises(OverflowError,
2153 self.assertRaises(OverflowError,
2155 self.assertRaises(ValueError,
2157 self.assertRaises(ValueError,
2168 self.assertIsInstance(pq, tuple)
2169 self.assertIsInstance(p, int)
2170 self.assertIsInstance(q, int)
2174 self.assertGreater(q, 0)
2175 self.assertEqual(math.gcd(p, q), 1)
2178 self.assertEqual(Decimal(p) / Decimal(q), d)
2180 def test_subclassing(self):
2182 Decimal = self.decimal.Decimal
2190 self.assertIs(type(d), Decimal)
2193 self.assertIs(type(d), Decimal)
2196 self.assertIs(type(d), MyDecimal)
2197 self.assertEqual(d, d1)
2200 self.assertIs(type(d), MyDecimal)
2201 self.assertEqual(d, d1)
2206 self.assertIs(type(x), Decimal)
2207 self.assertEqual(x, d)
2211 self.assertIs(type(m), MyDecimal)
2212 self.assertEqual(m, d)
2213 self.assertIs(m.y, None)
2217 self.assertIs(type(x), Decimal)
2218 self.assertEqual(x, d)
2223 self.assertIs(type(x), MyDecimal)
2224 self.assertEqual(x, d)
2225 self.assertIs(x.y, None)
2227 def test_implicit_context(self):
2228 Decimal = self.decimal.Decimal
2229 getcontext = self.decimal.getcontext
2233 self.assertEqual(str(Decimal(0).sqrt()),
2236 def test_none_args(self):
2237 Decimal = self.decimal.Decimal
2238 Context = self.decimal.Context
2239 localcontext = self.decimal.localcontext
2240 InvalidOperation = self.decimal.InvalidOperation
2241 DivisionByZero = self.decimal.DivisionByZero
2242 Overflow = self.decimal.Overflow
2243 Underflow = self.decimal.Underflow
2244 Subnormal = self.decimal.Subnormal
2245 Inexact = self.decimal.Inexact
2246 Rounded = self.decimal.Rounded
2247 Clamped = self.decimal.Clamped
2260 self.assertEqual(str(x.exp(context=None)), '1.609487E+48')
2261 self.assertTrue(c.flags[Inexact])
2262 self.assertTrue(c.flags[Rounded])
2264 self.assertRaises(Overflow, y.exp, context=None)
2265 self.assertTrue(c.flags[Overflow])
2267 self.assertIs(z.is_normal(context=None), False)
2268 self.assertIs(z.is_subnormal(context=None), True)
2271 self.assertEqual(str(x.ln(context=None)), '4.709530')
2272 self.assertTrue(c.flags[Inexact])
2273 self.assertTrue(c.flags[Rounded])
2275 self.assertRaises(InvalidOperation, Decimal(-1).ln, context=None)
2276 self.assertTrue(c.flags[InvalidOperation])
2279 self.assertEqual(str(x.log10(context=None)), '2.045323')
2280 self.assertTrue(c.flags[Inexact])
2281 self.assertTrue(c.flags[Rounded])
2283 self.assertRaises(InvalidOperation, Decimal(-1).log10, context=None)
2284 self.assertTrue(c.flags[InvalidOperation])
2287 self.assertEqual(str(x.logb(context=None)), '2')
2288 self.assertRaises(DivisionByZero, Decimal(0).logb, context=None)
2289 self.assertTrue(c.flags[DivisionByZero])
2292 self.assertEqual(str(x.logical_invert(context=None)), '1111000')
2293 self.assertRaises(InvalidOperation, y.logical_invert, context=None)
2294 self.assertTrue(c.flags[InvalidOperation])
2297 self.assertEqual(str(y.next_minus(context=None)), '9.999999E+999')
2298 self.assertRaises(InvalidOperation, Decimal('sNaN').next_minus, context=None)
2299 self.assertTrue(c.flags[InvalidOperation])
2302 self.assertEqual(str(y.next_plus(context=None)), 'Infinity')
2303 self.assertRaises(InvalidOperation, Decimal('sNaN').next_plus, context=None)
2304 self.assertTrue(c.flags[InvalidOperation])
2307 self.assertEqual(str(z.normalize(context=None)), '0')
2308 self.assertRaises(Overflow, y.normalize, context=None)
2309 self.assertTrue(c.flags[Overflow])
2311 self.assertEqual(str(z.number_class(context=None)), '+Subnormal')
2314 self.assertEqual(str(z.sqrt(context=None)), '0E-1005')
2315 self.assertTrue(c.flags[Clamped])
2316 self.assertTrue(c.flags[Inexact])
2317 self.assertTrue(c.flags[Rounded])
2318 self.assertTrue(c.flags[Subnormal])
2319 self.assertTrue(c.flags[Underflow])
2321 self.assertRaises(Overflow, y.sqrt, context=None)
2322 self.assertTrue(c.flags[Overflow])
2325 self.assertEqual(str(z.to_eng_string(context=None)), '1e-9999')
2332 self.assertEqual(ans, 'NaN1287828')
2333 self.assertRaises(InvalidOperation, x.compare, Decimal('sNaN'), context=None)
2334 self.assertTrue(c.flags[InvalidOperation])
2338 self.assertEqual(ans, '-1')
2339 self.assertRaises(InvalidOperation, x.compare_signal, Decimal('NaN'), context=None)
2340 self.assertTrue(c.flags[InvalidOperation])
2344 self.assertEqual(ans, '101')
2345 self.assertRaises(InvalidOperation, x.logical_and, 123, context=None)
2346 self.assertTrue(c.flags[InvalidOperation])
2350 self.assertEqual(ans, '111')
2351 self.assertRaises(InvalidOperation, x.logical_or, 123, context=None)
2352 self.assertTrue(c.flags[InvalidOperation])
2356 self.assertEqual(ans, '10')
2357 self.assertRaises(InvalidOperation, x.logical_xor, 123, context=None)
2358 self.assertTrue(c.flags[InvalidOperation])
2362 self.assertEqual(ans, '111')
2363 self.assertRaises(InvalidOperation, x.max, Decimal('sNaN'), context=None)
2364 self.assertTrue(c.flags[InvalidOperation])
2368 self.assertEqual(ans, '111')
2369 self.assertRaises(InvalidOperation, x.max_mag, Decimal('sNaN'), context=None)
2370 self.assertTrue(c.flags[InvalidOperation])
2374 self.assertEqual(ans, '101')
2375 self.assertRaises(InvalidOperation, x.min, Decimal('sNaN'), context=None)
2376 self.assertTrue(c.flags[InvalidOperation])
2380 self.assertEqual(ans, '101')
2381 self.assertRaises(InvalidOperation, x.min_mag, Decimal('sNaN'), context=None)
2382 self.assertTrue(c.flags[InvalidOperation])
2386 self.assertEqual(ans, '10')
2387 self.assertRaises(InvalidOperation, y.remainder_near, 101, context=None)
2388 self.assertTrue(c.flags[InvalidOperation])
2392 self.assertEqual(ans, '11100')
2393 self.assertRaises(InvalidOperation, x.rotate, 101, context=None)
2394 self.assertTrue(c.flags[InvalidOperation])
2398 self.assertEqual(ans, '1.11E+9')
2399 self.assertRaises(InvalidOperation, x.scaleb, 10000, context=None)
2400 self.assertTrue(c.flags[InvalidOperation])
2404 self.assertEqual(ans, '11100')
2405 self.assertRaises(InvalidOperation, x.shift, 10000, context=None)
2406 self.assertTrue(c.flags[InvalidOperation])
2412 self.assertEqual(ans, '225')
2413 self.assertRaises(Overflow, x.fma, Decimal('1e9999'), 3, context=None)
2414 self.assertTrue(c.flags[Overflow])
2420 self.assertEqual(ans, '2')
2423 self.assertEqual(ans, '1')
2425 self.assertEqual(ans, '2')
2427 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral, context=None)
2428 self.assertTrue(c.flags[InvalidOperation])
2432 self.assertEqual(ans, '2')
2435 self.assertEqual(ans, '1')
2437 self.assertEqual(ans, '2')
2439 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_value, context=None)
2440 self.assertTrue(c.flags[InvalidOperation])
2444 self.assertEqual(ans, '2')
2447 self.assertEqual(ans, '1')
2449 self.assertEqual(ans, '2')
2451 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_exact, context=None)
2452 self.assertTrue(c.flags[InvalidOperation])
2456 self.assertEqual(ans, '1.501')
2459 self.assertEqual(ans, '1.500')
2461 self.assertEqual(ans, '1.501')
2463 self.assertRaises(InvalidOperation, y.quantize, Decimal('1e-10'), rounding=ROUND_UP, context=None)
2464 self.assertTrue(c.flags[InvalidOperation])
2471 self.assertEqual(c.prec, 7)
2472 self.assertEqual(c.Emax, 999)
2473 self.assertEqual(c.Emin, -999)
2475 def test_conversions_from_int(self):
2478 Decimal = self.decimal.Decimal
2480 self.assertEqual(Decimal(4).compare(3),
2482 self.assertEqual(Decimal(4).compare_signal(3),
2484 self.assertEqual(Decimal(4).compare_total(3),
2486 self.assertEqual(Decimal(4).compare_total_mag(3),
2488 self.assertEqual(Decimal(10101).logical_and(1001),
2490 self.assertEqual(Decimal(10101).logical_or(1001),
2492 self.assertEqual(Decimal(10101).logical_xor(1001),
2494 self.assertEqual(Decimal(567).max(123),
2496 self.assertEqual(Decimal(567).max_mag(123),
2498 self.assertEqual(Decimal(567).min(123),
2500 self.assertEqual(Decimal(567).min_mag(123),
2502 self.assertEqual(Decimal(567).next_toward(123),
2504 self.assertEqual(Decimal(1234).quantize(100),
2506 self.assertEqual(Decimal(768).remainder_near(1234),
2508 self.assertEqual(Decimal(123).rotate(1),
2510 self.assertEqual(Decimal(1234).same_quantum(1000),
2512 self.assertEqual(Decimal('9.123').scaleb(-100),
2514 self.assertEqual(Decimal(456).shift(-1),
2517 self.assertEqual(Decimal(-12).fma(Decimal(45), 67),
2519 self.assertEqual(Decimal(-12).fma(45, 67),
2521 self.assertEqual(Decimal(-12).fma(45, Decimal(67)),
2529 def setUp(self):
2531 self._previous_int_limit = sys.get_int_max_str_digits()
2534 def tearDown(self):
2535 sys.set_int_max_str_digits(self._previous_int_limit)
2540 def test_abc(self):
2541 Decimal = self.decimal.Decimal
2543 self.assertTrue(issubclass(Decimal, numbers.Number))
2544 self.assertFalse(issubclass(Decimal, numbers.Real))
2545 self.assertIsInstance(Decimal(0), numbers.Number)
2546 self.assertNotIsInstance(Decimal(0), numbers.Real)
2548 def test_pickle(self):
2550 Decimal = self.decimal.Decimal
2555 sys.modules['decimal'] = self.decimal
2559 self.assertEqual(d, e)
2570 self.assertIsInstance(r, P.Decimal)
2571 self.assertEqual(r, y)
2577 self.assertIsInstance(r, C.Decimal)
2578 self.assertEqual(r, x)
2587 self.assertIsInstance(r, P.DecimalTuple)
2588 self.assertEqual(r, y)
2594 self.assertIsInstance(r, C.DecimalTuple)
2595 self.assertEqual(r, x)
2599 def test_int(self):
2600 Decimal = self.decimal.Decimal
2605 self.assertEqual(int(Decimal(s)), int(float(s)))
2609 self.assertEqual(Decimal(int(d)), r)
2611 self.assertRaises(ValueError, int, Decimal('-nan'))
2612 self.assertRaises(ValueError, int, Decimal('snan'))
2613 self.assertRaises(OverflowError, int, Decimal('inf'))
2614 self.assertRaises(OverflowError, int, Decimal('-inf'))
2617 def test_small_ints(self):
2618 Decimal = self.decimal.Decimal
2621 self.assertIs(int(Decimal(x)), x)
2623 def test_trunc(self):
2624 Decimal = self.decimal.Decimal
2629 self.assertEqual(int(Decimal(s)), int(float(s)))
2633 self.assertEqual(Decimal(math.trunc(d)), r)
2635 def test_from_float(self):
2637 Decimal = self.decimal.Decimal
2640 def __init__(self, _):
2641 self.x = 'y'
2643 self.assertTrue(issubclass(MyDecimal, Decimal))
2646 self.assertEqual(type(r), MyDecimal)
2647 self.assertEqual(str(r),
2649 self.assertEqual(r.x, 'y')
2652 self.assertEqual(MyDecimal.from_float(bigint), MyDecimal(bigint))
2653 self.assertTrue(MyDecimal.from_float(float('nan')).is_qnan())
2654 self.assertTrue(MyDecimal.from_float(float('inf')).is_infinite())
2655 self.assertTrue(MyDecimal.from_float(float('-inf')).is_infinite())
2656 self.assertEqual(str(MyDecimal.from_float(float('nan'))),
2658 self.assertEqual(str(MyDecimal.from_float(float('inf'))),
2660 self.assertEqual(str(MyDecimal.from_float(float('-inf'))),
2662 self.assertRaises(TypeError, MyDecimal.from_float, 'abc')
2665 self.assertEqual(x, float(MyDecimal.from_float(x))) # roundtrip
2667 def test_create_decimal_from_float(self):
2668 Decimal = self.decimal.Decimal
2669 Context = self.decimal.Context
2670 Inexact = self.decimal.Inexact
2673 self.assertEqual(
2678 self.assertEqual(
2683 self.assertRaises(
2688 self.assertEqual(repr(context.create_decimal_from_float(-0.0)),
2690 self.assertEqual(repr(context.create_decimal_from_float(1.0)),
2692 self.assertEqual(repr(context.create_decimal_from_float(10)),
2695 def test_quantize(self):
2696 Decimal = self.decimal.Decimal
2697 Context = self.decimal.Context
2698 InvalidOperation = self.decimal.InvalidOperation
2701 self.assertEqual(
2705 self.assertEqual(
2709 self.assertRaises(
2717 self.assertEqual(x, Decimal('8.71E+799'))
2719 def test_complex(self):
2720 Decimal = self.decimal.Decimal
2723 self.assertEqual(x.real, x)
2724 self.assertEqual(x.imag, 0)
2725 self.assertEqual(x.conjugate(), x)
2728 self.assertEqual(complex(x), complex(float(1)))
2730 self.assertRaises(AttributeError, setattr, x, 'real', 100)
2731 self.assertRaises(AttributeError, setattr, x, 'imag', 100)
2732 self.assertRaises(AttributeError, setattr, x, 'conjugate', 100)
2733 self.assertRaises(AttributeError, setattr, x, '__complex__', 100)
2735 def test_named_parameters(self):
2736 D = self.decimal.Decimal
2737 Context = self.decimal.Context
2738 localcontext = self.decimal.localcontext
2739 InvalidOperation = self.decimal.InvalidOperation
2740 Overflow = self.decimal.Overflow
2750 self.assertEqual(D(9, xc), 9)
2751 self.assertEqual(D(9, context=xc), 9)
2752 self.assertEqual(D(context=xc, value=9), 9)
2753 self.assertEqual(D(context=xc), 0)
2755 self.assertRaises(InvalidOperation, D, "xyz", context=xc)
2756 self.assertTrue(xc.flags[InvalidOperation])
2757 self.assertFalse(c.flags[InvalidOperation])
2760 self.assertEqual(D(2).exp(context=xc), 7)
2761 self.assertRaises(Overflow, D(8).exp, context=xc)
2762 self.assertTrue(xc.flags[Overflow])
2763 self.assertFalse(c.flags[Overflow])
2766 self.assertEqual(D(2).ln(context=xc), D('0.7'))
2767 self.assertRaises(InvalidOperation, D(-1).ln, context=xc)
2768 self.assertTrue(xc.flags[InvalidOperation])
2769 self.assertFalse(c.flags[InvalidOperation])
2771 self.assertEqual(D(0).log10(context=xc), D('-inf'))
2772 self.assertEqual(D(-1).next_minus(context=xc), -2)
2773 self.assertEqual(D(-1).next_plus(context=xc), D('-0.9'))
2774 self.assertEqual(D("9.73").normalize(context=xc), D('1E+1'))
2775 self.assertEqual(D("9999").to_integral(context=xc), 9999)
2776 self.assertEqual(D("-2000").to_integral_exact(context=xc), -2000)
2777 self.assertEqual(D("123").to_integral_value(context=xc), 123)
2778 self.assertEqual(D("0.0625").sqrt(context=xc), D('0.2'))
2780 self.assertEqual(D("0.0625").compare(context=xc, other=3), -1)
2782 self.assertRaises(InvalidOperation,
2784 self.assertTrue(xc.flags[InvalidOperation])
2785 self.assertFalse(c.flags[InvalidOperation])
2786 self.assertEqual(D("0.01").max(D('0.0101'), context=xc), D('0.0'))
2787 self.assertEqual(D("0.01").max(D('0.0101'), context=xc), D('0.0'))
2788 self.assertEqual(D("0.2").max_mag(D('-0.3'), context=xc),
2790 self.assertEqual(D("0.02").min(D('-0.03'), context=xc), D('-0.0'))
2791 self.assertEqual(D("0.02").min_mag(D('-0.03'), context=xc),
2793 self.assertEqual(D("0.2").next_toward(D('-1'), context=xc), D('0.1'))
2795 self.assertRaises(InvalidOperation,
2797 self.assertTrue(xc.flags[InvalidOperation])
2798 self.assertFalse(c.flags[InvalidOperation])
2799 self.assertEqual(D("9.99").remainder_near(D('1.5'), context=xc),
2802 self.assertEqual(D("9.9").fma(third=D('0.9'), context=xc, other=7),
2805 self.assertRaises(TypeError, D(1).is_canonical, context=xc)
2806 self.assertRaises(TypeError, D(1).is_finite, context=xc)
2807 self.assertRaises(TypeError, D(1).is_infinite, context=xc)
2808 self.assertRaises(TypeError, D(1).is_nan, context=xc)
2809 self.assertRaises(TypeError, D(1).is_qnan, context=xc)
2810 self.assertRaises(TypeError, D(1).is_snan, context=xc)
2811 self.assertRaises(TypeError, D(1).is_signed, context=xc)
2812 self.assertRaises(TypeError, D(1).is_zero, context=xc)
2814 self.assertFalse(D("0.01").is_normal(context=xc))
2815 self.assertTrue(D("0.01").is_subnormal(context=xc))
2817 self.assertRaises(TypeError, D(1).adjusted, context=xc)
2818 self.assertRaises(TypeError, D(1).conjugate, context=xc)
2819 self.assertRaises(TypeError, D(1).radix, context=xc)
2821 self.assertEqual(D(-111).logb(context=xc), 2)
2822 self.assertEqual(D(0).logical_invert(context=xc), 1)
2823 self.assertEqual(D('0.01').number_class(context=xc), '+Subnormal')
2824 self.assertEqual(D('0.21').to_eng_string(context=xc), '0.21')
2826 self.assertEqual(D('11').logical_and(D('10'), context=xc), 0)
2827 self.assertEqual(D('11').logical_or(D('10'), context=xc), 1)
2828 self.assertEqual(D('01').logical_xor(D('10'), context=xc), 1)
2829 self.assertEqual(D('23').rotate(1, context=xc), 3)
2830 self.assertEqual(D('23').rotate(1, context=xc), 3)
2832 self.assertRaises(Overflow,
2834 self.assertTrue(xc.flags[Overflow])
2835 self.assertFalse(c.flags[Overflow])
2836 self.assertEqual(D('23').shift(-1, context=xc), 0)
2838 self.assertRaises(TypeError, D.from_float, 1.1, context=xc)
2839 self.assertRaises(TypeError, D(0).as_tuple, context=xc)
2841 self.assertEqual(D(1).canonical(), 1)
2842 self.assertRaises(TypeError, D("-1").copy_abs, context=xc)
2843 self.assertRaises(TypeError, D("-1").copy_negate, context=xc)
2844 self.assertRaises(TypeError, D(1).canonical, context="x")
2845 self.assertRaises(TypeError, D(1).canonical, xyz="x")
2847 def test_exception_hierarchy(self):
2849 decimal = self.decimal
2861 self.assertTrue(issubclass(DecimalException, ArithmeticError))
2863 self.assertTrue(issubclass(InvalidOperation, DecimalException))
2864 self.assertTrue(issubclass(FloatOperation, DecimalException))
2865 self.assertTrue(issubclass(FloatOperation, TypeError))
2866 self.assertTrue(issubclass(DivisionByZero, DecimalException))
2867 self.assertTrue(issubclass(DivisionByZero, ZeroDivisionError))
2868 self.assertTrue(issubclass(Overflow, Rounded))
2869 self.assertTrue(issubclass(Overflow, Inexact))
2870 self.assertTrue(issubclass(Overflow, DecimalException))
2871 self.assertTrue(issubclass(Underflow, Inexact))
2872 self.assertTrue(issubclass(Underflow, Rounded))
2873 self.assertTrue(issubclass(Underflow, Subnormal))
2874 self.assertTrue(issubclass(Underflow, DecimalException))
2876 self.assertTrue(issubclass(Subnormal, DecimalException))
2877 self.assertTrue(issubclass(Inexact, DecimalException))
2878 self.assertTrue(issubclass(Rounded, DecimalException))
2879 self.assertTrue(issubclass(Clamped, DecimalException))
2881 self.assertTrue(issubclass(decimal.ConversionSyntax, InvalidOperation))
2882 self.assertTrue(issubclass(decimal.DivisionImpossible, InvalidOperation))
2883 self.assertTrue(issubclass(decimal.DivisionUndefined, InvalidOperation))
2884 self.assertTrue(issubclass(decimal.DivisionUndefined, ZeroDivisionError))
2885 self.assertTrue(issubclass(decimal.InvalidContext, InvalidOperation))
2894 def test_none_args(self):
2895 Context = self.decimal.Context
2896 InvalidOperation = self.decimal.InvalidOperation
2897 DivisionByZero = self.decimal.DivisionByZero
2898 Overflow = self.decimal.Overflow
2904 self.assertEqual(c.prec, 28)
2905 self.assertEqual(c.rounding, ROUND_HALF_EVEN)
2906 self.assertEqual(c.Emax, 999999)
2907 self.assertEqual(c.Emin, -999999)
2908 self.assertEqual(c.capitals, 1)
2909 self.assertEqual(c.clamp, 0)
2910 assert_signals(self, c, 'flags', [])
2911 assert_signals(self, c, 'traps', [InvalidOperation, DivisionByZero,
2917 def test_from_legacy_strings(self):
2919 c = self.decimal.Context()
2923 self.assertEqual(c.rounding, rnd)
2926 self.assertRaises(TypeError, setattr, c, 'rounding', s)
2929 self.assertRaises(TypeError, setattr, c, 'rounding', s)
2931 def test_pickle(self):
2934 Context = self.decimal.Context
2939 sys.modules['decimal'] = self.decimal
2943 self.assertEqual(c.prec, e.prec)
2944 self.assertEqual(c.Emin, e.Emin)
2945 self.assertEqual(c.Emax, e.Emax)
2946 self.assertEqual(c.rounding, e.rounding)
2947 self.assertEqual(c.capitals, e.capitals)
2948 self.assertEqual(c.clamp, e.clamp)
2949 self.assertEqual(c.flags, e.flags)
2950 self.assertEqual(c.traps, e.traps)
2979 self.assertIsInstance(d, loader.Context)
2981 self.assertEqual(d.prec, prec)
2982 self.assertEqual(d.Emin, emin)
2983 self.assertEqual(d.Emax, emax)
2984 self.assertEqual(d.rounding, RoundingModes[ri])
2985 self.assertEqual(d.capitals, caps)
2986 self.assertEqual(d.clamp, clamp)
2987 assert_signals(self, d, 'flags', OrderedSignals[loader][:fi])
2988 assert_signals(self, d, 'traps', OrderedSignals[loader][:ti])
2992 def test_equality_with_other_types(self):
2993 Decimal = self.decimal.Decimal
2995 self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}])
2996 self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}])
2998 def test_copy(self):
3000 Decimal = self.decimal.Decimal
3001 Context = self.decimal.Context
3005 self.assertNotEqual(id(c), id(d))
3006 self.assertNotEqual(id(c.flags), id(d.flags))
3007 self.assertNotEqual(id(c.traps), id(d.traps))
3010 self.assertEqual(k1, k2)
3011 self.assertEqual(c.flags, d.flags)
3013 def test__clamp(self):
3020 Context = self.decimal.Context
3022 self.assertRaises(AttributeError, getattr, c, '_clamp')
3024 def test_abs(self):
3025 Decimal = self.decimal.Decimal
3026 Context = self.decimal.Context
3030 self.assertEqual(c.abs(-1), d)
3031 self.assertRaises(TypeError, c.abs, '-1')
3033 def test_add(self):
3034 Decimal = self.decimal.Decimal
3035 Context = self.decimal.Context
3039 self.assertEqual(c.add(1, 1), d)
3040 self.assertEqual(c.add(Decimal(1), 1), d)
3041 self.assertEqual(c.add(1, Decimal(1)), d)
3042 self.assertRaises(TypeError, c.add, '1', 1)
3043 self.assertRaises(TypeError, c.add, 1, '1')
3045 def test_compare(self):
3046 Decimal = self.decimal.Decimal
3047 Context = self.decimal.Context
3051 self.assertEqual(c.compare(1, 1), d)
3052 self.assertEqual(c.compare(Decimal(1), 1), d)
3053 self.assertEqual(c.compare(1, Decimal(1)), d)
3054 self.assertRaises(TypeError, c.compare, '1', 1)
3055 self.assertRaises(TypeError, c.compare, 1, '1')
3057 def test_compare_signal(self):
3058 Decimal = self.decimal.Decimal
3059 Context = self.decimal.Context
3063 self.assertEqual(c.compare_signal(1, 1), d)
3064 self.assertEqual(c.compare_signal(Decimal(1), 1), d)
3065 self.assertEqual(c.compare_signal(1, Decimal(1)), d)
3066 self.assertRaises(TypeError, c.compare_signal, '1', 1)
3067 self.assertRaises(TypeError, c.compare_signal, 1, '1')
3069 def test_compare_total(self):
3070 Decimal = self.decimal.Decimal
3071 Context = self.decimal.Context
3075 self.assertEqual(c.compare_total(1, 1), d)
3076 self.assertEqual(c.compare_total(Decimal(1), 1), d)
3077 self.assertEqual(c.compare_total(1, Decimal(1)), d)
3078 self.assertRaises(TypeError, c.compare_total, '1', 1)
3079 self.assertRaises(TypeError, c.compare_total, 1, '1')
3081 def test_compare_total_mag(self):
3082 Decimal = self.decimal.Decimal
3083 Context = self.decimal.Context
3087 self.assertEqual(c.compare_total_mag(1, 1), d)
3088 self.assertEqual(c.compare_total_mag(Decimal(1), 1), d)
3089 self.assertEqual(c.compare_total_mag(1, Decimal(1)), d)
3090 self.assertRaises(TypeError, c.compare_total_mag, '1', 1)
3091 self.assertRaises(TypeError, c.compare_total_mag, 1, '1')
3093 def test_copy_abs(self):
3094 Decimal = self.decimal.Decimal
3095 Context = self.decimal.Context
3099 self.assertEqual(c.copy_abs(-1), d)
3100 self.assertRaises(TypeError, c.copy_abs, '-1')
3102 def test_copy_decimal(self):
3103 Decimal = self.decimal.Decimal
3104 Context = self.decimal.Context
3108 self.assertEqual(c.copy_decimal(-1), d)
3109 self.assertRaises(TypeError, c.copy_decimal, '-1')
3111 def test_copy_negate(self):
3112 Decimal = self.decimal.Decimal
3113 Context = self.decimal.Context
3117 self.assertEqual(c.copy_negate(-1), d)
3118 self.assertRaises(TypeError, c.copy_negate, '-1')
3120 def test_copy_sign(self):
3121 Decimal = self.decimal.Decimal
3122 Context = self.decimal.Context
3126 self.assertEqual(c.copy_sign(1, -2), d)
3127 self.assertEqual(c.copy_sign(Decimal(1), -2), d)
3128 self.assertEqual(c.copy_sign(1, Decimal(-2)), d)
3129 self.assertRaises(TypeError, c.copy_sign, '1', -2)
3130 self.assertRaises(TypeError, c.copy_sign, 1, '-2')
3132 def test_divide(self):
3133 Decimal = self.decimal.Decimal
3134 Context = self.decimal.Context
3138 self.assertEqual(c.divide(1, 2), d)
3139 self.assertEqual(c.divide(Decimal(1), 2), d)
3140 self.assertEqual(c.divide(1, Decimal(2)), d)
3141 self.assertRaises(TypeError, c.divide, '1', 2)
3142 self.assertRaises(TypeError, c.divide, 1, '2')
3144 def test_divide_int(self):
3145 Decimal = self.decimal.Decimal
3146 Context = self.decimal.Context
3150 self.assertEqual(c.divide_int(1, 2), d)
3151 self.assertEqual(c.divide_int(Decimal(1), 2), d)
3152 self.assertEqual(c.divide_int(1, Decimal(2)), d)
3153 self.assertRaises(TypeError, c.divide_int, '1', 2)
3154 self.assertRaises(TypeError, c.divide_int, 1, '2')
3156 def test_divmod(self):
3157 Decimal = self.decimal.Decimal
3158 Context = self.decimal.Context
3162 self.assertEqual(c.divmod(1, 2), d)
3163 self.assertEqual(c.divmod(Decimal(1), 2), d)
3164 self.assertEqual(c.divmod(1, Decimal(2)), d)
3165 self.assertRaises(TypeError, c.divmod, '1', 2)
3166 self.assertRaises(TypeError, c.divmod, 1, '2')
3168 def test_exp(self):
3169 Decimal = self.decimal.Decimal
3170 Context = self.decimal.Context
3174 self.assertEqual(c.exp(10), d)
3175 self.assertRaises(TypeError, c.exp, '10')
3177 def test_fma(self):
3178 Decimal = self.decimal.Decimal
3179 Context = self.decimal.Context
3183 self.assertEqual(c.fma(2, 3, 4), d)
3184 self.assertEqual(c.fma(Decimal(2), 3, 4), d)
3185 self.assertEqual(c.fma(2, Decimal(3), 4), d)
3186 self.assertEqual(c.fma(2, 3, Decimal(4)), d)
3187 self.assertEqual(c.fma(Decimal(2), Decimal(3), 4), d)
3188 self.assertRaises(TypeError, c.fma, '2', 3, 4)
3189 self.assertRaises(TypeError, c.fma, 2, '3', 4)
3190 self.assertRaises(TypeError, c.fma, 2, 3, '4')
3193 self.assertRaises(TypeError, c.fma,
3195 self.assertRaises(TypeError, c.fma,
3198 self.assertRaises(TypeError, Decimal('Infinity').fma,
3200 self.assertRaises(TypeError, Decimal(1).fma,
3203 def test_is_finite(self):
3204 Decimal = self.decimal.Decimal
3205 Context = self.decimal.Context
3209 self.assertEqual(c.is_finite(10), d)
3210 self.assertRaises(TypeError, c.is_finite, '10')
3212 def test_is_infinite(self):
3213 Decimal = self.decimal.Decimal
3214 Context = self.decimal.Context
3218 self.assertEqual(c.is_infinite(10), d)
3219 self.assertRaises(TypeError, c.is_infinite, '10')
3221 def test_is_nan(self):
3222 Decimal = self.decimal.Decimal
3223 Context = self.decimal.Context
3227 self.assertEqual(c.is_nan(10), d)
3228 self.assertRaises(TypeError, c.is_nan, '10')
3230 def test_is_normal(self):
3231 Decimal = self.decimal.Decimal
3232 Context = self.decimal.Context
3236 self.assertEqual(c.is_normal(10), d)
3237 self.assertRaises(TypeError, c.is_normal, '10')
3239 def test_is_qnan(self):
3240 Decimal = self.decimal.Decimal
3241 Context = self.decimal.Context
3245 self.assertEqual(c.is_qnan(10), d)
3246 self.assertRaises(TypeError, c.is_qnan, '10')
3248 def test_is_signed(self):
3249 Decimal = self.decimal.Decimal
3250 Context = self.decimal.Context
3254 self.assertEqual(c.is_signed(10), d)
3255 self.assertRaises(TypeError, c.is_signed, '10')
3257 def test_is_snan(self):
3258 Decimal = self.decimal.Decimal
3259 Context = self.decimal.Context
3263 self.assertEqual(c.is_snan(10), d)
3264 self.assertRaises(TypeError, c.is_snan, '10')
3266 def test_is_subnormal(self):
3267 Decimal = self.decimal.Decimal
3268 Context = self.decimal.Context
3272 self.assertEqual(c.is_subnormal(10), d)
3273 self.assertRaises(TypeError, c.is_subnormal, '10')
3275 def test_is_zero(self):
3276 Decimal = self.decimal.Decimal
3277 Context = self.decimal.Context
3281 self.assertEqual(c.is_zero(10), d)
3282 self.assertRaises(TypeError, c.is_zero, '10')
3284 def test_ln(self):
3285 Decimal = self.decimal.Decimal
3286 Context = self.decimal.Context
3290 self.assertEqual(c.ln(10), d)
3291 self.assertRaises(TypeError, c.ln, '10')
3293 def test_log10(self):
3294 Decimal = self.decimal.Decimal
3295 Context = self.decimal.Context
3299 self.assertEqual(c.log10(10), d)
3300 self.assertRaises(TypeError, c.log10, '10')
3302 def test_logb(self):
3303 Decimal = self.decimal.Decimal
3304 Context = self.decimal.Context
3308 self.assertEqual(c.logb(10), d)
3309 self.assertRaises(TypeError, c.logb, '10')
3311 def test_logical_and(self):
3312 Decimal = self.decimal.Decimal
3313 Context = self.decimal.Context
3317 self.assertEqual(c.logical_and(1, 1), d)
3318 self.assertEqual(c.logical_and(Decimal(1), 1), d)
3319 self.assertEqual(c.logical_and(1, Decimal(1)), d)
3320 self.assertRaises(TypeError, c.logical_and, '1', 1)
3321 self.assertRaises(TypeError, c.logical_and, 1, '1')
3323 def test_logical_invert(self):
3324 Decimal = self.decimal.Decimal
3325 Context = self.decimal.Context
3329 self.assertEqual(c.logical_invert(1000), d)
3330 self.assertRaises(TypeError, c.logical_invert, '1000')
3332 def test_logical_or(self):
3333 Decimal = self.decimal.Decimal
3334 Context = self.decimal.Context
3338 self.assertEqual(c.logical_or(1, 1), d)
3339 self.assertEqual(c.logical_or(Decimal(1), 1), d)
3340 self.assertEqual(c.logical_or(1, Decimal(1)), d)
3341 self.assertRaises(TypeError, c.logical_or, '1', 1)
3342 self.assertRaises(TypeError, c.logical_or, 1, '1')
3344 def test_logical_xor(self):
3345 Decimal = self.decimal.Decimal
3346 Context = self.decimal.Context
3350 self.assertEqual(c.logical_xor(1, 1), d)
3351 self.assertEqual(c.logical_xor(Decimal(1), 1), d)
3352 self.assertEqual(c.logical_xor(1, Decimal(1)), d)
3353 self.assertRaises(TypeError, c.logical_xor, '1', 1)
3354 self.assertRaises(TypeError, c.logical_xor, 1, '1')
3356 def test_max(self):
3357 Decimal = self.decimal.Decimal
3358 Context = self.decimal.Context
3362 self.assertEqual(c.max(1, 2), d)
3363 self.assertEqual(c.max(Decimal(1), 2), d)
3364 self.assertEqual(c.max(1, Decimal(2)), d)
3365 self.assertRaises(TypeError, c.max, '1', 2)
3366 self.assertRaises(TypeError, c.max, 1, '2')
3368 def test_max_mag(self):
3369 Decimal = self.decimal.Decimal
3370 Context = self.decimal.Context
3374 self.assertEqual(c.max_mag(1, 2), d)
3375 self.assertEqual(c.max_mag(Decimal(1), 2), d)
3376 self.assertEqual(c.max_mag(1, Decimal(2)), d)
3377 self.assertRaises(TypeError, c.max_mag, '1', 2)
3378 self.assertRaises(TypeError, c.max_mag, 1, '2')
3380 def test_min(self):
3381 Decimal = self.decimal.Decimal
3382 Context = self.decimal.Context
3386 self.assertEqual(c.min(1, 2), d)
3387 self.assertEqual(c.min(Decimal(1), 2), d)
3388 self.assertEqual(c.min(1, Decimal(2)), d)
3389 self.assertRaises(TypeError, c.min, '1', 2)
3390 self.assertRaises(TypeError, c.min, 1, '2')
3392 def test_min_mag(self):
3393 Decimal = self.decimal.Decimal
3394 Context = self.decimal.Context
3398 self.assertEqual(c.min_mag(1, 2), d)
3399 self.assertEqual(c.min_mag(Decimal(1), 2), d)
3400 self.assertEqual(c.min_mag(1, Decimal(2)), d)
3401 self.assertRaises(TypeError, c.min_mag, '1', 2)
3402 self.assertRaises(TypeError, c.min_mag, 1, '2')
3404 def test_minus(self):
3405 Decimal = self.decimal.Decimal
3406 Context = self.decimal.Context
3410 self.assertEqual(c.minus(10), d)
3411 self.assertRaises(TypeError, c.minus, '10')
3413 def test_multiply(self):
3414 Decimal = self.decimal.Decimal
3415 Context = self.decimal.Context
3419 self.assertEqual(c.multiply(1, 2), d)
3420 self.assertEqual(c.multiply(Decimal(1), 2), d)
3421 self.assertEqual(c.multiply(1, Decimal(2)), d)
3422 self.assertRaises(TypeError, c.multiply, '1', 2)
3423 self.assertRaises(TypeError, c.multiply, 1, '2')
3425 def test_next_minus(self):
3426 Decimal = self.decimal.Decimal
3427 Context = self.decimal.Context
3431 self.assertEqual(c.next_minus(10), d)
3432 self.assertRaises(TypeError, c.next_minus, '10')
3434 def test_next_plus(self):
3435 Decimal = self.decimal.Decimal
3436 Context = self.decimal.Context
3440 self.assertEqual(c.next_plus(10), d)
3441 self.assertRaises(TypeError, c.next_plus, '10')
3443 def test_next_toward(self):
3444 Decimal = self.decimal.Decimal
3445 Context = self.decimal.Context
3449 self.assertEqual(c.next_toward(1, 2), d)
3450 self.assertEqual(c.next_toward(Decimal(1), 2), d)
3451 self.assertEqual(c.next_toward(1, Decimal(2)), d)
3452 self.assertRaises(TypeError, c.next_toward, '1', 2)
3453 self.assertRaises(TypeError, c.next_toward, 1, '2')
3455 def test_normalize(self):
3456 Decimal = self.decimal.Decimal
3457 Context = self.decimal.Context
3461 self.assertEqual(c.normalize(10), d)
3462 self.assertRaises(TypeError, c.normalize, '10')
3464 def test_number_class(self):
3465 Decimal = self.decimal.Decimal
3466 Context = self.decimal.Context
3469 self.assertEqual(c.number_class(123), c.number_class(Decimal(123)))
3470 self.assertEqual(c.number_class(0), c.number_class(Decimal(0)))
3471 self.assertEqual(c.number_class(-45), c.number_class(Decimal(-45)))
3473 def test_plus(self):
3474 Decimal = self.decimal.Decimal
3475 Context = self.decimal.Context
3479 self.assertEqual(c.plus(10), d)
3480 self.assertRaises(TypeError, c.plus, '10')
3482 def test_power(self):
3483 Decimal = self.decimal.Decimal
3484 Context = self.decimal.Context
3488 self.assertEqual(c.power(1, 4), d)
3489 self.assertEqual(c.power(Decimal(1), 4), d)
3490 self.assertEqual(c.power(1, Decimal(4)), d)
3491 self.assertEqual(c.power(Decimal(1), Decimal(4)), d)
3492 self.assertRaises(TypeError, c.power, '1', 4)
3493 self.assertRaises(TypeError, c.power, 1, '4')
3494 self.assertEqual(c.power(modulo=5, b=8, a=2), 1)
3496 def test_quantize(self):
3497 Decimal = self.decimal.Decimal
3498 Context = self.decimal.Context
3502 self.assertEqual(c.quantize(1, 2), d)
3503 self.assertEqual(c.quantize(Decimal(1), 2), d)
3504 self.assertEqual(c.quantize(1, Decimal(2)), d)
3505 self.assertRaises(TypeError, c.quantize, '1', 2)
3506 self.assertRaises(TypeError, c.quantize, 1, '2')
3508 def test_remainder(self):
3509 Decimal = self.decimal.Decimal
3510 Context = self.decimal.Context
3514 self.assertEqual(c.remainder(1, 2), d)
3515 self.assertEqual(c.remainder(Decimal(1), 2), d)
3516 self.assertEqual(c.remainder(1, Decimal(2)), d)
3517 self.assertRaises(TypeError, c.remainder, '1', 2)
3518 self.assertRaises(TypeError, c.remainder, 1, '2')
3520 def test_remainder_near(self):
3521 Decimal = self.decimal.Decimal
3522 Context = self.decimal.Context
3526 self.assertEqual(c.remainder_near(1, 2), d)
3527 self.assertEqual(c.remainder_near(Decimal(1), 2), d)
3528 self.assertEqual(c.remainder_near(1, Decimal(2)), d)
3529 self.assertRaises(TypeError, c.remainder_near, '1', 2)
3530 self.assertRaises(TypeError, c.remainder_near, 1, '2')
3532 def test_rotate(self):
3533 Decimal = self.decimal.Decimal
3534 Context = self.decimal.Context
3538 self.assertEqual(c.rotate(1, 2), d)
3539 self.assertEqual(c.rotate(Decimal(1), 2), d)
3540 self.assertEqual(c.rotate(1, Decimal(2)), d)
3541 self.assertRaises(TypeError, c.rotate, '1', 2)
3542 self.assertRaises(TypeError, c.rotate, 1, '2')
3544 def test_sqrt(self):
3545 Decimal = self.decimal.Decimal
3546 Context = self.decimal.Context
3550 self.assertEqual(c.sqrt(10), d)
3551 self.assertRaises(TypeError, c.sqrt, '10')
3553 def test_same_quantum(self):
3554 Decimal = self.decimal.Decimal
3555 Context = self.decimal.Context
3559 self.assertEqual(c.same_quantum(1, 2), d)
3560 self.assertEqual(c.same_quantum(Decimal(1), 2), d)
3561 self.assertEqual(c.same_quantum(1, Decimal(2)), d)
3562 self.assertRaises(TypeError, c.same_quantum, '1', 2)
3563 self.assertRaises(TypeError, c.same_quantum, 1, '2')
3565 def test_scaleb(self):
3566 Decimal = self.decimal.Decimal
3567 Context = self.decimal.Context
3571 self.assertEqual(c.scaleb(1, 2), d)
3572 self.assertEqual(c.scaleb(Decimal(1), 2), d)
3573 self.assertEqual(c.scaleb(1, Decimal(2)), d)
3574 self.assertRaises(TypeError, c.scaleb, '1', 2)
3575 self.assertRaises(TypeError, c.scaleb, 1, '2')
3577 def test_shift(self):
3578 Decimal = self.decimal.Decimal
3579 Context = self.decimal.Context
3583 self.assertEqual(c.shift(1, 2), d)
3584 self.assertEqual(c.shift(Decimal(1), 2), d)
3585 self.assertEqual(c.shift(1, Decimal(2)), d)
3586 self.assertRaises(TypeError, c.shift, '1', 2)
3587 self.assertRaises(TypeError, c.shift, 1, '2')
3589 def test_subtract(self):
3590 Decimal = self.decimal.Decimal
3591 Context = self.decimal.Context
3595 self.assertEqual(c.subtract(1, 2), d)
3596 self.assertEqual(c.subtract(Decimal(1), 2), d)
3597 self.assertEqual(c.subtract(1, Decimal(2)), d)
3598 self.assertRaises(TypeError, c.subtract, '1', 2)
3599 self.assertRaises(TypeError, c.subtract, 1, '2')
3601 def test_to_eng_string(self):
3602 Decimal = self.decimal.Decimal
3603 Context = self.decimal.Context
3607 self.assertEqual(c.to_eng_string(10), d)
3608 self.assertRaises(TypeError, c.to_eng_string, '10')
3610 def test_to_sci_string(self):
3611 Decimal = self.decimal.Decimal
3612 Context = self.decimal.Context
3616 self.assertEqual(c.to_sci_string(10), d)
3617 self.assertRaises(TypeError, c.to_sci_string, '10')
3619 def test_to_integral_exact(self):
3620 Decimal = self.decimal.Decimal
3621 Context = self.decimal.Context
3625 self.assertEqual(c.to_integral_exact(10), d)
3626 self.assertRaises(TypeError, c.to_integral_exact, '10')
3628 def test_to_integral_value(self):
3629 Decimal = self.decimal.Decimal
3630 Context = self.decimal.Context
3634 self.assertEqual(c.to_integral_value(10), d)
3635 self.assertRaises(TypeError, c.to_integral_value, '10')
3636 self.assertRaises(TypeError, c.to_integral_value, 10, 'x')
3647 def test_localcontext(self):
3649 getcontext = self.decimal.getcontext
3650 localcontext = self.decimal.localcontext
3656 self.assertIs(orig_ctx, final_ctx, 'did not restore context correctly')
3657 self.assertIsNot(orig_ctx, set_ctx, 'did not copy the context')
3658 self.assertIs(set_ctx, enter_ctx, '__enter__ returned wrong context')
3660 def test_localcontextarg(self):
3662 Context = self.decimal.Context
3663 getcontext = self.decimal.getcontext
3664 localcontext = self.decimal.localcontext
3666 localcontext = self.decimal.localcontext
3672 self.assertIs(orig_ctx, final_ctx, 'did not restore context correctly')
3673 self.assertEqual(set_ctx.prec, new_ctx.prec, 'did not set correct context')
3674 self.assertIsNot(new_ctx, set_ctx, 'did not copy the context')
3675 self.assertIs(set_ctx, enter_ctx, '__enter__ returned wrong context')
3677 def test_localcontext_kwargs(self):
3678 with self.decimal.localcontext(
3683 self.assertEqual(ctx.prec, 10)
3684 self.assertEqual(ctx.rounding, self.decimal.ROUND_HALF_DOWN)
3685 self.assertEqual(ctx.Emin, -20)
3686 self.assertEqual(ctx.Emax, 20)
3687 self.assertEqual(ctx.capitals, 0)
3688 self.assertEqual(ctx.clamp, 1)
3690 self.assertRaises(TypeError, self.decimal.localcontext, precision=10)
3692 self.assertRaises(ValueError, self.decimal.localcontext, Emin=1)
3693 self.assertRaises(ValueError, self.decimal.localcontext, Emax=-1)
3694 self.assertRaises(ValueError, self.decimal.localcontext, capitals=2)
3695 self.assertRaises(ValueError, self.decimal.localcontext, clamp=2)
3697 self.assertRaises(TypeError, self.decimal.localcontext, rounding="")
3698 self.assertRaises(TypeError, self.decimal.localcontext, rounding=1)
3700 self.assertRaises(TypeError, self.decimal.localcontext, flags="")
3701 self.assertRaises(TypeError, self.decimal.localcontext, traps="")
3702 self.assertRaises(TypeError, self.decimal.localcontext, Emin="")
3703 self.assertRaises(TypeError, self.decimal.localcontext, Emax="")
3705 def test_local_context_kwargs_does_not_overwrite_existing_argument(self):
3706 ctx = self.decimal.getcontext()
3708 with self.decimal.localcontext(prec=10) as ctx2:
3709 self.assertEqual(ctx.prec, 28)
3711 def test_nested_with_statements(self):
3713 Decimal = self.decimal.Decimal
3714 Context = self.decimal.Context
3715 getcontext = self.decimal.getcontext
3716 localcontext = self.decimal.localcontext
3717 Clamped = self.decimal.Clamped
3718 Overflow = self.decimal.Overflow
3724 self.assertEqual(c1.flags, orig_ctx.flags)
3725 self.assertEqual(c1.traps, orig_ctx.traps)
3728 self.assertNotEqual(orig_ctx.Emin, -383)
3729 self.assertRaises(Clamped, c1.create_decimal, '0e-999')
3730 self.assertTrue(c1.flags[Clamped])
3732 self.assertEqual(c2.flags, new_ctx.flags)
3733 self.assertEqual(c2.traps, new_ctx.traps)
3734 self.assertRaises(Overflow, c2.power, Decimal('3.4e200'), 2)
3735 self.assertFalse(c2.flags[Clamped])
3736 self.assertTrue(c2.flags[Overflow])
3738 self.assertFalse(c1.flags[Overflow])
3740 self.assertNotEqual(orig_ctx.Emin, -383)
3741 self.assertFalse(orig_ctx.flags[Clamped])
3742 self.assertFalse(orig_ctx.flags[Overflow])
3743 self.assertFalse(new_ctx.flags[Clamped])
3744 self.assertFalse(new_ctx.flags[Overflow])
3746 def test_with_statements_gc1(self):
3747 localcontext = self.decimal.localcontext
3758 def test_with_statements_gc2(self):
3759 localcontext = self.decimal.localcontext
3770 def test_with_statements_gc3(self):
3771 Context = self.decimal.Context
3772 localcontext = self.decimal.localcontext
3773 getcontext = self.decimal.getcontext
3774 setcontext = self.decimal.setcontext
3782 self.assertEqual(c2.prec, 1)
3787 self.assertEqual(getcontext().prec, 2)
3790 self.assertEqual(getcontext().prec, 3)
3793 self.assertEqual(c3.prec, 3)
3798 self.assertEqual(getcontext().prec, 4)
3800 self.assertEqual(c4.prec, 4)
3810 def test_flags_irrelevant(self):
3813 Decimal = self.decimal.Decimal
3814 Context = self.decimal.Context
3815 Inexact = self.decimal.Inexact
3816 Rounded = self.decimal.Rounded
3817 Underflow = self.decimal.Underflow
3818 Clamped = self.decimal.Clamped
3819 Subnormal = self.decimal.Subnormal
3822 if self.decimal == C:
3869 self.assertEqual(ans, new_ans,
3872 self.assertEqual(new_flags, expected_flags,
3876 def test_flag_comparisons(self):
3877 Context = self.decimal.Context
3878 Inexact = self.decimal.Inexact
3879 Rounded = self.decimal.Rounded
3884 self.assertNotEqual(c.flags, c.traps)
3885 self.assertNotEqual(c.traps, c.flags)
3888 self.assertEqual(c.flags, c.traps)
3889 self.assertEqual(c.traps, c.flags)
3893 self.assertEqual(c.flags, c.traps)
3894 self.assertEqual(c.traps, c.flags)
3898 self.assertEqual(d, c.flags)
3899 self.assertEqual(c.flags, d)
3902 self.assertNotEqual(d, c.flags)
3903 self.assertNotEqual(c.flags, d)
3907 self.assertNotEqual(d, c.flags)
3908 self.assertNotEqual(c.flags, d)
3911 self.assertNotEqual(d, c.flags)
3912 self.assertNotEqual(c.flags, d)
3915 def test_float_operation(self):
3916 Decimal = self.decimal.Decimal
3917 FloatOperation = self.decimal.FloatOperation
3918 localcontext = self.decimal.localcontext
3922 self.assertFalse(c.traps[FloatOperation])
3926 self.assertEqual(Decimal(7.5), 7.5)
3927 self.assertTrue(c.flags[FloatOperation])
3930 self.assertEqual(c.create_decimal(7.5), 7.5)
3931 self.assertTrue(c.flags[FloatOperation])
3936 self.assertFalse(c.flags[FloatOperation])
3938 self.assertEqual(x, 7.5)
3939 self.assertTrue(c.flags[FloatOperation])
3943 self.assertFalse(c.flags[FloatOperation])
3944 self.assertEqual(x, 7.5)
3945 self.assertTrue(c.flags[FloatOperation])
3952 self.assertRaises(FloatOperation, Decimal, 7.5)
3953 self.assertTrue(c.flags[FloatOperation])
3956 self.assertRaises(FloatOperation, c.create_decimal, 7.5)
3957 self.assertTrue(c.flags[FloatOperation])
3962 self.assertFalse(c.flags[FloatOperation])
3966 self.assertFalse(c.flags[FloatOperation])
3968 def test_float_comparison(self):
3969 Decimal = self.decimal.Decimal
3970 Context = self.decimal.Context
3971 FloatOperation = self.decimal.FloatOperation
3972 localcontext = self.decimal.localcontext
3978 self.assertRaises(signal, f, b)
3980 self.assertIs(f(b), True)
3981 self.assertTrue(context.flags[FloatOperation])
4031 self.assertEqual(len(s), 1)
4032 self.assertTrue(c.flags[FloatOperation])
4036 self.assertRaises(signal, sorted, [1.0, Decimal('10.0')])
4039 self.assertTrue(c.flags[FloatOperation])
4043 self.assertTrue(c.flags[FloatOperation])
4047 self.assertTrue(c.flags[FloatOperation])
4051 self.assertFalse(c.traps[FloatOperation])
4059 def test_float_operation_default(self):
4060 Decimal = self.decimal.Decimal
4061 Context = self.decimal.Context
4062 Inexact = self.decimal.Inexact
4063 FloatOperation= self.decimal.FloatOperation
4066 self.assertFalse(context.flags[FloatOperation])
4067 self.assertFalse(context.traps[FloatOperation])
4072 self.assertTrue(context.traps[FloatOperation])
4073 self.assertTrue(context.traps[Inexact])
4083 def test_context_templates(self):
4084 BasicContext = self.decimal.BasicContext
4085 ExtendedContext = self.decimal.ExtendedContext
4086 getcontext = self.decimal.getcontext
4087 setcontext = self.decimal.setcontext
4088 InvalidOperation = self.decimal.InvalidOperation
4089 DivisionByZero = self.decimal.DivisionByZero
4090 Overflow = self.decimal.Overflow
4091 Underflow = self.decimal.Underflow
4092 Clamped = self.decimal.Clamped
4094 assert_signals(self, BasicContext, 'traps',
4108 self.assertIsNot(c, template)
4109 self.assertEqual(c.prec, 441)
4119 def test_default_context(self):
4120 DefaultContext = self.decimal.DefaultContext
4121 BasicContext = self.decimal.BasicContext
4122 ExtendedContext = self.decimal.ExtendedContext
4123 getcontext = self.decimal.getcontext
4124 setcontext = self.decimal.setcontext
4125 InvalidOperation = self.decimal.InvalidOperation
4126 DivisionByZero = self.decimal.DivisionByZero
4127 Overflow = self.decimal.Overflow
4129 self.assertEqual(BasicContext.prec, 9)
4130 self.assertEqual(ExtendedContext.prec, 9)
4132 assert_signals(self, DefaultContext, 'traps',
4146 self.assertEqual(c.prec, saveprec)
4150 self.assertIsNot(c, DefaultContext)
4151 self.assertEqual(c.prec, 961)
4167 def test_invalid_context(self):
4168 Context = self.decimal.Context
4169 DefaultContext = self.decimal.DefaultContext
4176 self.assertEqual(getattr(c, attr), 999999)
4177 self.assertRaises(ValueError, setattr, c, attr, -1)
4178 self.assertRaises(TypeError, setattr, c, attr, 'xyz')
4182 self.assertEqual(getattr(c, 'Emin'), -999999)
4183 self.assertRaises(ValueError, setattr, c, 'Emin', 1)
4184 self.assertRaises(TypeError, setattr, c, 'Emin', (1,2,3))
4186 self.assertRaises(TypeError, setattr, c, 'rounding', -1)
4187 self.assertRaises(TypeError, setattr, c, 'rounding', 9)
4188 self.assertRaises(TypeError, setattr, c, 'rounding', 1.0)
4189 self.assertRaises(TypeError, setattr, c, 'rounding', 'xyz')
4193 self.assertRaises(ValueError, setattr, c, attr, -1)
4194 self.assertRaises(ValueError, setattr, c, attr, 2)
4195 self.assertRaises(TypeError, setattr, c, attr, [1,2,3])
4198 self.assertRaises(AttributeError, setattr, c, 'emax', 100)
4201 self.assertRaises(TypeError, setattr, c, 'flags', [])
4202 self.assertRaises(KeyError, setattr, c, 'flags', {})
4203 self.assertRaises(KeyError, setattr, c, 'traps',
4209 self.assertRaises(AttributeError, c.__delattr__, attr)
4212 self.assertRaises(TypeError, getattr, c, 9)
4213 self.assertRaises(TypeError, setattr, c, 9)
4216 self.assertRaises(TypeError, Context, rounding=999999)
4217 self.assertRaises(TypeError, Context, rounding='xyz')
4218 self.assertRaises(ValueError, Context, clamp=2)
4219 self.assertRaises(ValueError, Context, capitals=-1)
4220 self.assertRaises(KeyError, Context, flags=["P"])
4221 self.assertRaises(KeyError, Context, traps=["Q"])
4224 self.assertRaises(TypeError, Context, flags=(0,1))
4225 self.assertRaises(TypeError, Context, traps=(1,0))
4234 def test_context_subclassing(self):
4235 decimal = self.decimal
4248 def __init__(self, prec=None, rounding=None, Emin=None, Emax=None,
4251 Context.__init__(self)
4253 self.prec = prec
4255 self.rounding = rounding
4257 self.Emin = Emin
4259 self.Emax = Emax
4261 self.capitals = capitals
4263 self.clamp = clamp
4267 self.flags = flags
4271 self.traps = traps
4277 self.assertEqual(getattr(c, attr), getattr(d, attr))
4280 self.assertRaises(ValueError, MyContext, **{'prec':-1})
4282 self.assertEqual(c.prec, 1)
4283 self.assertRaises(InvalidOperation, c.quantize, Decimal('9e2'), 0)
4286 self.assertRaises(TypeError, MyContext, **{'rounding':'XYZ'})
4288 self.assertEqual(c.rounding, ROUND_DOWN)
4289 self.assertEqual(c.plus(Decimal('9.9')), 9)
4292 self.assertRaises(ValueError, MyContext, **{'Emin':5})
4294 self.assertEqual(c.Emin, -1)
4296 self.assertEqual(x, Decimal('0.0'))
4298 self.assertTrue(c.flags[signal])
4301 self.assertRaises(ValueError, MyContext, **{'Emax':-1})
4303 self.assertEqual(c.Emax, 1)
4304 self.assertRaises(Overflow, c.add, Decimal('1e99'), Decimal('2.234e2000'))
4305 if self.decimal == C:
4307 self.assertTrue(c.flags[signal])
4310 self.assertRaises(ValueError, MyContext, **{'capitals':-1})
4312 self.assertEqual(c.capitals, 0)
4314 self.assertEqual(c.to_sci_string(x), '1e+222')
4317 self.assertRaises(ValueError, MyContext, **{'clamp':2})
4319 self.assertEqual(c.clamp, 1)
4321 self.assertEqual(str(x), '1.000000000000000000000000000E+99')
4324 self.assertRaises(TypeError, MyContext, **{'flags':'XYZ'})
4327 self.assertTrue(c.flags[signal])
4330 self.assertFalse(c.flags[signal])
4333 self.assertRaises(TypeError, MyContext, **{'traps':'XYZ'})
4336 self.assertTrue(c.traps[signal])
4339 self.assertFalse(c.traps[signal])
4349 def test_module_attributes(self):
4352 self.assertEqual(C.MAX_PREC, P.MAX_PREC)
4353 self.assertEqual(C.MAX_EMAX, P.MAX_EMAX)
4354 self.assertEqual(C.MIN_EMIN, P.MIN_EMIN)
4355 self.assertEqual(C.MIN_ETINY, P.MIN_ETINY)
4357 self.assertTrue(C.HAVE_THREADS is True or C.HAVE_THREADS is False)
4358 self.assertTrue(P.HAVE_THREADS is True or P.HAVE_THREADS is False)
4360 self.assertEqual(C.__version__, P.__version__)
4362 self.assertEqual(dir(C), dir(P))
4364 def test_context_attributes(self):
4368 self.assertEqual(set(x) - set(y), set())
4370 def test_decimal_attributes(self):
4374 self.assertEqual(set(x) - set(y), set())
4378 def test_adjusted(self):
4379 Decimal = self.decimal.Decimal
4381 self.assertEqual(Decimal('1234e9999').adjusted(), 10002)
4383 self.assertEqual(Decimal('nan').adjusted(), 0)
4384 self.assertEqual(Decimal('inf').adjusted(), 0)
4386 def test_canonical(self):
4387 Decimal = self.decimal.Decimal
4388 getcontext = self.decimal.getcontext
4391 self.assertEqual(x, 9)
4395 self.assertEqual(x, 9)
4397 def test_context_repr(self):
4398 c = self.decimal.DefaultContext.copy()
4406 for sig in OrderedSignals[self.decimal]:
4414 self.assertEqual(s, t)
4416 def test_implicit_context(self):
4417 Decimal = self.decimal.Decimal
4418 localcontext = self.decimal.localcontext
4426 self.assertEqual(abs(Decimal("-10")), 10)
4428 self.assertEqual(Decimal("7") + 1, 8)
4430 self.assertEqual(Decimal("10") / 5, 2)
4432 self.assertEqual(Decimal("10") // 7, 1)
4434 self.assertEqual(Decimal("1.2").fma(Decimal("0.01"), 1), 1)
4435 self.assertIs(Decimal("NaN").fma(7, 1).is_nan(), True)
4437 self.assertEqual(pow(Decimal(10), 2, 7), 2)
4439 self.assertEqual(Decimal("1.01").exp(), 3)
4441 self.assertIs(Decimal("0.01").is_normal(), False)
4443 self.assertIs(Decimal("0.01").is_subnormal(), True)
4445 self.assertEqual(Decimal("20").ln(), 3)
4447 self.assertEqual(Decimal("20").log10(), 1)
4449 self.assertEqual(Decimal("580").logb(), 2)
4451 self.assertEqual(Decimal("10").logical_invert(), 1)
4453 self.assertEqual(-Decimal("-10"), 10)
4455 self.assertEqual(Decimal("2") * 4, 8)
4457 self.assertEqual(Decimal("10").next_minus(), 9)
4459 self.assertEqual(Decimal("10").next_plus(), Decimal('2E+1'))
4461 self.assertEqual(Decimal("-10").normalize(), Decimal('-1E+1'))
4463 self.assertEqual(Decimal("10").number_class(), '+Normal')
4465 self.assertEqual(+Decimal("-1"), -1)
4467 self.assertEqual(Decimal("10") % 7, 3)
4469 self.assertEqual(Decimal("10") - 7, 3)
4471 self.assertEqual(Decimal("1.12345").to_integral_exact(), 1)
4474 self.assertTrue(Decimal("1").is_canonical())
4475 self.assertTrue(Decimal("1").is_finite())
4476 self.assertTrue(Decimal("1").is_finite())
4477 self.assertTrue(Decimal("snan").is_snan())
4478 self.assertTrue(Decimal("-1").is_signed())
4479 self.assertTrue(Decimal("0").is_zero())
4480 self.assertTrue(Decimal("0").is_zero())
4489 self.assertEqual(z, x)
4492 self.assertEqual(z, x)
4495 self.assertEqual(z, x)
4497 def test_divmod(self):
4498 Decimal = self.decimal.Decimal
4499 localcontext = self.decimal.localcontext
4500 InvalidOperation = self.decimal.InvalidOperation
4501 DivisionByZero = self.decimal.DivisionByZero
4505 self.assertEqual(q, Decimal('10901935'))
4506 self.assertEqual(r, Decimal('194'))
4509 self.assertTrue(q.is_nan() and r.is_nan())
4513 self.assertTrue(q.is_nan() and r.is_nan())
4518 self.assertTrue(q.is_nan() and r.is_nan())
4519 self.assertTrue(c.flags[InvalidOperation])
4523 self.assertTrue(q.is_infinite() and r.is_nan())
4524 self.assertTrue(c.flags[InvalidOperation])
4528 self.assertTrue(q.is_nan() and r.is_nan())
4529 self.assertTrue(c.flags[InvalidOperation])
4534 self.assertTrue(q.is_infinite() and r.is_nan())
4535 self.assertTrue(c.flags[InvalidOperation] and
4538 def test_power(self):
4539 Decimal = self.decimal.Decimal
4540 localcontext = self.decimal.localcontext
4541 Overflow = self.decimal.Overflow
4542 Rounded = self.decimal.Rounded
4547 self.assertEqual(Decimal("1.0") ** 100, Decimal('1.00'))
4548 self.assertTrue(c.flags[Rounded])
4555 self.assertEqual(Decimal(10000) ** Decimal("0.5"), Decimal('inf'))
4556 self.assertTrue(c.flags[Overflow])
4558 def test_quantize(self):
4559 Decimal = self.decimal.Decimal
4560 localcontext = self.decimal.localcontext
4561 InvalidOperation = self.decimal.InvalidOperation
4569 self.assertTrue(x.is_nan())
4571 def test_radix(self):
4572 Decimal = self.decimal.Decimal
4573 getcontext = self.decimal.getcontext
4576 self.assertEqual(Decimal("1").radix(), 10)
4577 self.assertEqual(c.radix(), 10)
4579 def test_rop(self):
4580 Decimal = self.decimal.Decimal
4584 self.assertIs(getattr(Decimal("1"), attr)("xyz"), NotImplemented)
4586 def test_round(self):
4588 Decimal = self.decimal.Decimal
4589 localcontext = self.decimal.localcontext
4594 self.assertEqual(str(Decimal("9.99").__round__()), "10")
4595 self.assertEqual(str(Decimal("9.99e-5").__round__()), "0")
4596 self.assertEqual(str(Decimal("1.23456789").__round__(5)), "1.23457")
4597 self.assertEqual(str(Decimal("1.2345").__round__(10)), "1.2345000000")
4598 self.assertEqual(str(Decimal("1.2345").__round__(-10)), "0E+10")
4600 self.assertRaises(TypeError, Decimal("1.23").__round__, "5")
4601 self.assertRaises(TypeError, Decimal("1.23").__round__, 5, 8)
4603 def test_create_decimal(self):
4604 c = self.decimal.Context()
4605 self.assertRaises(ValueError, c.create_decimal, ["%"])
4607 def test_int(self):
4608 Decimal = self.decimal.Decimal
4609 localcontext = self.decimal.localcontext
4614 self.assertEqual(int(x), 1)
4615 self.assertEqual(x.to_integral(), 2)
4617 def test_copy(self):
4618 Context = self.decimal.Context
4625 self.assertEqual(y, -x)
4628 self.assertEqual(y, -x)
4631 self.assertEqual(y, -x)
4638 def setUp(self):
4640 self._previous_int_limit = sys.get_int_max_str_digits()
4643 def tearDown(self):
4644 sys.set_int_max_str_digits(self._previous_int_limit)
4650 def test_py_alternate_formatting(self):
4669 self.assertEqual(format(Decimal(d), fmt), result)
4674 def test_py_exact_power(self):
4682 self.assertEqual(x, Decimal('0.00390625'))
4685 self.assertEqual(x, Decimal('0.0012885819'))
4690 self.assertEqual(x, Decimal("0.2"))
4701 def test_py_immutability_operations(self):
4719 self.assertEqual(d1._sign, b1._sign)
4720 self.assertEqual(d1._int, b1._int)
4721 self.assertEqual(d1._exp, b1._exp)
4722 self.assertEqual(d2._sign, b2._sign)
4723 self.assertEqual(d2._int, b2._int)
4724 self.assertEqual(d2._exp, b2._exp)
4727 self.assertEqual(d1._sign, b1._sign)
4728 self.assertEqual(d1._int, b1._int)
4729 self.assertEqual(d1._exp, b1._exp)
4732 self.assertEqual(d1._sign, b1._sign)
4733 self.assertEqual(d1._int, b1._int)
4734 self.assertEqual(d1._exp, b1._exp)
4780 def test_py_decimal_id(self):
4785 self.assertEqual(str(e), '45')
4786 self.assertNotEqual(id(d), id(e))
4788 def test_py_rescale(self):
4795 self.assertTrue(x.is_nan())
4797 def test_py__round(self):
4801 self.assertRaises(ValueError, Decimal("3.1234")._round, 0, ROUND_UP)
4807 def test_c_ieee_context(self):
4814 def assert_rest(self, context):
4815 self.assertEqual(context.clamp, 1)
4816 assert_signals(self, context, 'traps', [])
4817 assert_signals(self, context, 'flags', [])
4820 self.assertEqual(c.prec, 7)
4821 self.assertEqual(c.Emax, 96)
4822 self.assertEqual(c.Emin, -95)
4823 assert_rest(self, c)
4826 self.assertEqual(c.prec, 16)
4827 self.assertEqual(c.Emax, 384)
4828 self.assertEqual(c.Emin, -383)
4829 assert_rest(self, c)
4832 self.assertEqual(c.prec, 34)
4833 self.assertEqual(c.Emax, 6144)
4834 self.assertEqual(c.Emin, -6143)
4835 assert_rest(self, c)
4838 self.assertRaises(OverflowError, IEEEContext, 2**63)
4839 self.assertRaises(ValueError, IEEEContext, -1)
4840 self.assertRaises(ValueError, IEEEContext, 1024)
4843 def test_c_context(self):
4847 self.assertEqual(c._flags, C.DecClamped)
4848 self.assertEqual(c._traps, C.DecRounded)
4851 def test_constants(self):
4863 self.assertEqual(C.DECIMAL32, 32)
4864 self.assertEqual(C.DECIMAL64, 64)
4865 self.assertEqual(C.DECIMAL128, 128)
4866 self.assertEqual(C.IEEE_CONTEXT_MAX_BITS, 512)
4870 self.assertEqual(v, 1<<i)
4872 self.assertEqual(C.DecIEEEInvalidOperation,
4881 self.assertEqual(C.DecErrors,
4885 self.assertEqual(C.DecTraps,
4891 def test_bignum(self):
4906 self.assertEqual(x, y)
4908 def test_invalid_construction(self):
4909 self.assertRaises(TypeError, C.Decimal, 9, "xyz")
4911 def test_c_input_restriction(self):
4919 self.assertRaises(InvalidOperation, Decimal,
4922 def test_c_context_repr(self):
4949 self.assertEqual(s, t)
4951 def test_c_context_errors(self):
4964 self.assertRaises(KeyError, c.flags.__setitem__, 801, 0)
4965 self.assertRaises(KeyError, c.traps.__setitem__, 801, 0)
4966 self.assertRaises(ValueError, c.flags.__delitem__, Overflow)
4967 self.assertRaises(ValueError, c.traps.__delitem__, InvalidOperation)
4968 self.assertRaises(TypeError, setattr, c, 'flags', ['x'])
4969 self.assertRaises(TypeError, setattr, c,'traps', ['y'])
4970 self.assertRaises(KeyError, setattr, c, 'flags', {0:1})
4971 self.assertRaises(KeyError, setattr, c, 'traps', {0:1})
4978 self.assertRaises(KeyError, setattr, c, 'flags', d)
4979 self.assertRaises(KeyError, setattr, c, 'traps', d)
4987 self.assertRaises(ValueError, setattr, c, attr, gt_max_emax)
4988 self.assertRaises(ValueError, setattr, c, 'Emin', -gt_max_emax)
4991 self.assertRaises(ValueError, Context, prec=gt_max_emax)
4992 self.assertRaises(ValueError, Context, Emax=gt_max_emax)
4993 self.assertRaises(ValueError, Context, Emin=-gt_max_emax)
4996 self.assertRaises(OverflowError, Context, prec=int_max+1)
4997 self.assertRaises(OverflowError, Context, Emax=int_max+1)
4998 self.assertRaises(OverflowError, Context, Emin=-int_max-2)
4999 self.assertRaises(OverflowError, Context, clamp=int_max+1)
5000 self.assertRaises(OverflowError, Context, capitals=int_max+1)
5004 self.assertRaises(OverflowError, setattr, c, attr, int_max+1)
5005 self.assertRaises(OverflowError, setattr, c, attr, -int_max-2)
5007 self.assertRaises(ValueError, setattr, c, attr, int_max)
5008 self.assertRaises(ValueError, setattr, c, attr, -int_max-1)
5012 self.assertRaises(OverflowError, getattr(c, '_unsafe_setprec'),
5014 self.assertRaises(OverflowError, getattr(c, '_unsafe_setemax'),
5016 self.assertRaises(OverflowError, getattr(c, '_unsafe_setemin'),
5021 self.assertRaises(ValueError, getattr(c, '_unsafe_setprec'), 0)
5022 self.assertRaises(ValueError, getattr(c, '_unsafe_setprec'),
5024 self.assertRaises(ValueError, getattr(c, '_unsafe_setemax'), -1)
5025 self.assertRaises(ValueError, getattr(c, '_unsafe_setemax'),
5027 self.assertRaises(ValueError, getattr(c, '_unsafe_setemin'),
5029 self.assertRaises(ValueError, getattr(c, '_unsafe_setemin'), 1)
5033 self.assertRaises(ValueError, setattr, c, attr, -1)
5034 self.assertRaises(ValueError, setattr, c, attr, 2)
5035 self.assertRaises(TypeError, setattr, c, attr, [1,2,3])
5037 self.assertRaises(ValueError, setattr, c, attr, 2**32)
5038 self.assertRaises(ValueError, setattr, c, attr, 2**32+1)
5041 self.assertRaises(TypeError, exec, 'with localcontext("xyz"): pass',
5043 self.assertRaises(TypeError, exec,
5049 self.assertRaises(TypeError, setcontext, "xyz")
5052 def test_rounding_strings_interned(self):
5054 self.assertIs(C.ROUND_UP, P.ROUND_UP)
5055 self.assertIs(C.ROUND_DOWN, P.ROUND_DOWN)
5056 self.assertIs(C.ROUND_CEILING, P.ROUND_CEILING)
5057 self.assertIs(C.ROUND_FLOOR, P.ROUND_FLOOR)
5058 self.assertIs(C.ROUND_HALF_UP, P.ROUND_HALF_UP)
5059 self.assertIs(C.ROUND_HALF_DOWN, P.ROUND_HALF_DOWN)
5060 self.assertIs(C.ROUND_HALF_EVEN, P.ROUND_HALF_EVEN)
5061 self.assertIs(C.ROUND_05UP, P.ROUND_05UP)
5064 def test_c_context_errors_extra(self):
5079 self.assertRaises(OverflowError, setattr, c, '_allcr', int_max+1)
5080 self.assertRaises(OverflowError, setattr, c, '_allcr', -int_max-2)
5082 self.assertRaises(ValueError, setattr, c, '_allcr', int_max)
5083 self.assertRaises(ValueError, setattr, c, '_allcr', -int_max-1)
5087 self.assertRaises(OverflowError, setattr, c, attr, int_max+1)
5088 self.assertRaises(OverflowError, setattr, c, attr, -int_max-2)
5090 self.assertRaises(TypeError, setattr, c, attr, int_max)
5091 self.assertRaises(TypeError, setattr, c, attr, -int_max-1)
5094 self.assertRaises(ValueError, setattr, c, '_allcr', -1)
5095 self.assertRaises(ValueError, setattr, c, '_allcr', 2)
5096 self.assertRaises(TypeError, setattr, c, '_allcr', [1,2,3])
5098 self.assertRaises(ValueError, setattr, c, '_allcr', 2**32)
5099 self.assertRaises(ValueError, setattr, c, '_allcr', 2**32+1)
5103 self.assertRaises(TypeError, setattr, c, attr, 999999)
5104 self.assertRaises(TypeError, setattr, c, attr, 'x')
5106 def test_c_valid_context(self):
5125 self.assertEqual(c.prec, 34)
5126 self.assertEqual(c.rounding, ROUND_HALF_UP)
5127 self.assertEqual(c.Emin, -3000)
5128 self.assertEqual(c.Emax, 3000)
5129 self.assertEqual(c.capitals, 1)
5130 self.assertEqual(c.clamp, 0)
5132 self.assertEqual(c.Etiny(), -3033)
5133 self.assertEqual(c.Etop(), 2967)
5140 self.assertEqual(c.prec, 999999999)
5141 self.assertEqual(c.Emax, 999999999)
5142 self.assertEqual(c.Emin, -999999999)
5145 def test_c_valid_context_extra(self):
5149 self.assertEqual(c._allcr, 1)
5151 self.assertEqual(c._allcr, 0)
5153 def test_c_round(self):
5164 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5166 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5168 self.assertRaises(InvalidOperation, Decimal("1").__round__,
5170 self.assertRaises(C.InvalidOperation, Decimal("1").__round__,
5172 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5174 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5177 def test_c_format(self):
5182 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", [], 9)
5183 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", 9)
5184 self.assertRaises(TypeError, Decimal(1).__format__, [])
5186 self.assertRaises(ValueError, Decimal(1).__format__, "<>=10.10")
5188 self.assertRaises(ValueError, Decimal("1.23456789").__format__,
5191 def test_c_integral(self):
5197 self.assertEqual(x.to_integral(), 10)
5198 self.assertRaises(TypeError, x.to_integral, '10')
5199 self.assertRaises(TypeError, x.to_integral, 10, 'x')
5200 self.assertRaises(TypeError, x.to_integral, 10)
5202 self.assertEqual(x.to_integral_value(), 10)
5203 self.assertRaises(TypeError, x.to_integral_value, '10')
5204 self.assertRaises(TypeError, x.to_integral_value, 10, 'x')
5205 self.assertRaises(TypeError, x.to_integral_value, 10)
5207 self.assertEqual(x.to_integral_exact(), 10)
5208 self.assertRaises(TypeError, x.to_integral_exact, '10')
5209 self.assertRaises(TypeError, x.to_integral_exact, 10, 'x')
5210 self.assertRaises(TypeError, x.to_integral_exact, 10)
5214 self.assertEqual(x, Decimal('100000000000000000000000000'))
5217 self.assertEqual(x, Decimal('100000000000000000000000000'))
5220 self.assertRaises(Inexact, Decimal("999.9").to_integral_exact, ROUND_UP)
5222 def test_c_funcs(self):
5230 self.assertEqual(Decimal('9.99e10').to_eng_string(), '99.9E+9')
5232 self.assertRaises(TypeError, pow, Decimal(1), 2, "3")
5233 self.assertRaises(TypeError, Decimal(9).number_class, "x", "y")
5234 self.assertRaises(TypeError, Decimal(9).same_quantum, 3, "x", "y")
5236 self.assertRaises(
5240 self.assertRaises(
5244 self.assertRaises(
5248 self.assertRaises(
5257 self.assertRaises(TypeError, c.copy_sign, Decimal(1), "x", "y")
5258 self.assertRaises(TypeError, c.canonical, 200)
5259 self.assertRaises(TypeError, c.is_canonical, 200)
5260 self.assertRaises(TypeError, c.divmod, 9, 8, "x", "y")
5261 self.assertRaises(TypeError, c.same_quantum, 9, 3, "x", "y")
5263 self.assertEqual(str(c.canonical(Decimal(200))), '200')
5264 self.assertEqual(c.radix(), 10)
5267 self.assertRaises(DivisionByZero, Decimal(9).__divmod__, 0)
5268 self.assertRaises(DivisionByZero, c.divmod, 9, 0)
5269 self.assertTrue(c.flags[InvalidOperation])
5273 self.assertRaises(InvalidOperation, Decimal(9).__divmod__, 0)
5274 self.assertRaises(InvalidOperation, c.divmod, 9, 0)
5275 self.assertTrue(c.flags[DivisionByZero])
5279 self.assertRaises(InvalidOperation, pow, Decimal(1000), 1, 501)
5281 def test_va_args_exceptions(self):
5291 self.assertRaises(TypeError, func, context="x")
5292 self.assertRaises(TypeError, func, "x", context=None)
5298 self.assertRaises(TypeError, func, context="x")
5299 self.assertRaises(TypeError, func, "x", context=None)
5301 self.assertRaises(TypeError, x.to_integral, rounding=None, context=[])
5302 self.assertRaises(TypeError, x.to_integral, rounding={}, context=[])
5303 self.assertRaises(TypeError, x.to_integral, [], [])
5305 self.assertRaises(TypeError, x.to_integral_value, rounding=None, context=[])
5306 self.assertRaises(TypeError, x.to_integral_value, rounding={}, context=[])
5307 self.assertRaises(TypeError, x.to_integral_value, [], [])
5309 self.assertRaises(TypeError, x.to_integral_exact, rounding=None, context=[])
5310 self.assertRaises(TypeError, x.to_integral_exact, rounding={}, context=[])
5311 self.assertRaises(TypeError, x.to_integral_exact, [], [])
5313 self.assertRaises(TypeError, x.fma, 1, 2, context="x")
5314 self.assertRaises(TypeError, x.fma, 1, 2, "x", context=None)
5316 self.assertRaises(TypeError, x.quantize, 1, [], context=None)
5317 self.assertRaises(TypeError, x.quantize, 1, [], rounding=None)
5318 self.assertRaises(TypeError, x.quantize, 1, [], [])
5321 self.assertRaises(TypeError, c.power, 1, 2, mod="x")
5322 self.assertRaises(TypeError, c.power, 1, "x", mod=None)
5323 self.assertRaises(TypeError, c.power, "x", 2, mod=None)
5326 def test_c_context_templates(self):
5327 self.assertEqual(
5332 self.assertEqual(
5338 def test_c_signal_dict(self):
5361 self.assertTrue(signal_dict[sig])
5363 self.assertFalse(signal_dict[sig])
5368 self.assertTrue(Overflow in c.traps)
5373 self.assertTrue(v)
5376 self.assertFalse(v)
5378 self.assertFalse(c.flags.get(Overflow))
5379 self.assertIs(c.flags.get("x"), None)
5380 self.assertEqual(c.flags.get("x", "y"), "y")
5381 self.assertRaises(TypeError, c.flags.get, "x", "y", "z")
5383 self.assertEqual(len(c.flags), len(c.traps))
5391 self.assertTrue(c.flags[Clamped])
5395 self.assertTrue(c.traps[InvalidOperation])
5444 self.assertEqual(c.prec, prec)
5445 self.assertEqual(c.rounding, round)
5446 self.assertEqual(c.Emin, emin)
5447 self.assertEqual(c.Emax, emax)
5448 self.assertEqual(c.capitals, caps)
5449 self.assertEqual(c.clamp, clamp)
5454 self.assertEqual(c._flags, f)
5459 self.assertEqual(c._traps, f)
5463 self.assertTrue(c._flags&DecIEEEInvalidOperation)
5468 self.assertTrue(c._traps&DecIEEEInvalidOperation)
5471 def test_invalid_override(self):
5477 self.skipTest('locale.CHAR_MAX not available')
5502 self.assertRaises(ValueError, get_fmt, 12345,
5505 self.assertRaises(ValueError, get_fmt, 12345, invalid_dot, 'g')
5506 self.assertRaises(ValueError, get_fmt, 12345, invalid_sep, 'g')
5508 def test_exact_conversion(self):
5519 self.assertRaises(InvalidOperation, Decimal, x)
5522 self.assertRaises(InvalidOperation, Decimal, x)
5526 self.assertRaises(InvalidOperation, Decimal, x)
5530 self.assertRaises(InvalidOperation, Decimal, x)
5532 def test_from_tuple(self):
5548 self.assertEqual(str(c.create_decimal(x)), '-0E+999999')
5549 self.assertRaises(InvalidOperation, Decimal, x)
5552 self.assertRaises(Overflow, c.create_decimal, x)
5553 self.assertRaises(InvalidOperation, Decimal, x)
5557 self.assertEqual(str(c.create_decimal(x)), '-0E-1000007')
5558 self.assertRaises(InvalidOperation, Decimal, x)
5561 self.assertRaises(Underflow, c.create_decimal, x)
5562 self.assertRaises(InvalidOperation, Decimal, x)
5566 self.assertRaises(OverflowError, c.create_decimal, x)
5567 self.assertRaises(OverflowError, Decimal, x)
5570 self.assertRaises(OverflowError, c.create_decimal, x)
5571 self.assertRaises(OverflowError, Decimal, x)
5575 self.assertEqual(str(Decimal(x)), '-sNaN')
5577 self.assertEqual(str(Decimal(x)), '-sNaN')
5579 self.assertEqual(str(Decimal(x)), '-sNaN1')
5581 def test_sizeof(self):
5585 self.assertGreater(Decimal(0).__sizeof__(), 0)
5589 self.assertEqual(y, x+8)
5593 self.assertEqual(y, x+4)
5595 def test_internal_use_of_overridden_methods(self):
5600 def as_integer_ratio(self):
5602 def __abs__(self):
5603 return self
5606 def __abs__(self):
5610 def bit_length(self):
5614 def as_integer_ratio(self):
5616 def __abs__(self):
5617 return self
5620 self.assertEqual(Decimal.from_float(cls(101.1)),
5630 def test_maxcontext_exact_arith(self):
5651 self.assertEqual(Decimal(0).exp(), 1)
5652 self.assertEqual(Decimal(1).ln(), 0)
5653 self.assertEqual(Decimal(1).log10(), 0)
5654 self.assertEqual(Decimal(10**2).log10(), 2)
5655 self.assertEqual(Decimal(10**223).log10(), 223)
5656 self.assertEqual(Decimal(10**19).logb(), 19)
5657 self.assertEqual(Decimal(4).sqrt(), 2)
5658 self.assertEqual(Decimal("40E9").sqrt(), Decimal('2.0E+5'))
5659 self.assertEqual(divmod(Decimal(10), 3), (3, 1))
5660 self.assertEqual(Decimal(10) // 3, 3)
5661 self.assertEqual(Decimal(4) / 2, 2)
5662 self.assertEqual(Decimal(400) ** -1, Decimal('0.0025'))
5670 def test_inspect_module(self):
5686 self.assertEqual(c_names, p_names,
5695 self.assertEqual(c_kind, p_kind,
5698 def test_inspect_types(self):
5734 if name == 'self': continue
5767 self.assertEqual(c_names, p_names,
5773 # 'self' parameter:
5774 self.assertIs(p_kind[0], POS_KWD)
5775 self.assertIs(c_kind[0], POS)
5779 self.assertEqual(c_kind[1:], p_kind[1:],
5782 self.assertEqual(len(c_kind), len(p_kind),
5857 tester = lambda self, f=filename: self.eval_file(directory + f)