| # Copyright (c) 2004 Python Software Foundation. |
| # All rights reserved. |
| |
| # Written by Eric Price <eprice at tjhsst.edu> |
| # and Facundo Batista <facundo at taniquetil.com.ar> |
| # and Raymond Hettinger <python at rcn.com> |
| # and Aahz (aahz at pobox.com) |
| # and Tim Peters |
| |
| """ |
| These are the test cases for the Decimal module. |
| |
| There are two groups of tests, Arithmetic and Behaviour. The former test |
| the Decimal arithmetic using the tests provided by Mike Cowlishaw. The latter |
| test the pythonic behaviour according to PEP 327. |
| |
| Cowlishaw's tests can be downloaded from: |
| |
| www2.hursley.ibm.com/decimal/dectest.zip |
| |
| This test module can be called from command line with one parameter (Arithmetic |
| or Behaviour) to test each part, or without parameter to test both parts. If |
| you're working through IDLE, you can import this test module and call test_main() |
| with the corresponding argument. |
| """ |
| |
| import math |
| import os, sys |
| import operator |
| import pickle, copy |
| import unittest |
| from decimal import * |
| import numbers |
| from test.test_support import (run_unittest, run_doctest, |
| is_resource_enabled, check_py3k_warnings) |
| import random |
| try: |
| import threading |
| except ImportError: |
| threading = None |
| |
| # Useful Test Constant |
| Signals = tuple(getcontext().flags.keys()) |
| |
| # Signals ordered with respect to precedence: when an operation |
| # produces multiple signals, signals occurring later in the list |
| # should be handled before those occurring earlier in the list. |
| OrderedSignals = (Clamped, Rounded, Inexact, Subnormal, |
| Underflow, Overflow, DivisionByZero, InvalidOperation) |
| |
| # Tests are built around these assumed context defaults. |
| # test_main() restores the original context. |
| def init(): |
| global ORIGINAL_CONTEXT |
| ORIGINAL_CONTEXT = getcontext().copy() |
| DefaultTestContext = Context( |
| prec = 9, |
| rounding = ROUND_HALF_EVEN, |
| traps = dict.fromkeys(Signals, 0) |
| ) |
| setcontext(DefaultTestContext) |
| |
| # decorator for skipping tests on non-IEEE 754 platforms |
| requires_IEEE_754 = unittest.skipUnless( |
| float.__getformat__("double").startswith("IEEE"), |
| "test requires IEEE 754 doubles") |
| |
| TESTDATADIR = 'decimaltestdata' |
| if __name__ == '__main__': |
| file = sys.argv[0] |
| else: |
| file = __file__ |
| testdir = os.path.dirname(file) or os.curdir |
| directory = testdir + os.sep + TESTDATADIR + os.sep |
| |
| skip_expected = not os.path.isdir(directory) |
| |
| # list of individual .decTest test ids that correspond to tests that |
| # we're skipping for one reason or another. |
| skipped_test_ids = set([ |
| # Skip implementation-specific scaleb tests. |
| 'scbx164', |
| 'scbx165', |
| |
| # For some operations (currently exp, ln, log10, power), the decNumber |
| # reference implementation imposes additional restrictions on the context |
| # and operands. These restrictions are not part of the specification; |
| # however, the effect of these restrictions does show up in some of the |
| # testcases. We skip testcases that violate these restrictions, since |
| # Decimal behaves differently from decNumber for these testcases so these |
| # testcases would otherwise fail. |
| 'expx901', |
| 'expx902', |
| 'expx903', |
| 'expx905', |
| 'lnx901', |
| 'lnx902', |
| 'lnx903', |
| 'lnx905', |
| 'logx901', |
| 'logx902', |
| 'logx903', |
| 'logx905', |
| 'powx1183', |
| 'powx1184', |
| 'powx4001', |
| 'powx4002', |
| 'powx4003', |
| 'powx4005', |
| 'powx4008', |
| 'powx4010', |
| 'powx4012', |
| 'powx4014', |
| ]) |
| |
| # Make sure it actually raises errors when not expected and caught in flags |
| # Slower, since it runs some things several times. |
| EXTENDEDERRORTEST = False |
| |
| #Map the test cases' error names to the actual errors |
| ErrorNames = {'clamped' : Clamped, |
| 'conversion_syntax' : InvalidOperation, |
| 'division_by_zero' : DivisionByZero, |
| 'division_impossible' : InvalidOperation, |
| 'division_undefined' : InvalidOperation, |
| 'inexact' : Inexact, |
| 'invalid_context' : InvalidOperation, |
| 'invalid_operation' : InvalidOperation, |
| 'overflow' : Overflow, |
| 'rounded' : Rounded, |
| 'subnormal' : Subnormal, |
| 'underflow' : Underflow} |
| |
| |
| def Nonfunction(*args): |
| """Doesn't do anything.""" |
| return None |
| |
| RoundingDict = {'ceiling' : ROUND_CEILING, #Maps test-case names to roundings. |
| 'down' : ROUND_DOWN, |
| 'floor' : ROUND_FLOOR, |
| 'half_down' : ROUND_HALF_DOWN, |
| 'half_even' : ROUND_HALF_EVEN, |
| 'half_up' : ROUND_HALF_UP, |
| 'up' : ROUND_UP, |
| '05up' : ROUND_05UP} |
| |
| # Name adapter to be able to change the Decimal and Context |
| # interface without changing the test files from Cowlishaw |
| nameAdapter = {'and':'logical_and', |
| 'apply':'_apply', |
| 'class':'number_class', |
| 'comparesig':'compare_signal', |
| 'comparetotal':'compare_total', |
| 'comparetotmag':'compare_total_mag', |
| 'copy':'copy_decimal', |
| 'copyabs':'copy_abs', |
| 'copynegate':'copy_negate', |
| 'copysign':'copy_sign', |
| 'divideint':'divide_int', |
| 'invert':'logical_invert', |
| 'iscanonical':'is_canonical', |
| 'isfinite':'is_finite', |
| 'isinfinite':'is_infinite', |
| 'isnan':'is_nan', |
| 'isnormal':'is_normal', |
| 'isqnan':'is_qnan', |
| 'issigned':'is_signed', |
| 'issnan':'is_snan', |
| 'issubnormal':'is_subnormal', |
| 'iszero':'is_zero', |
| 'maxmag':'max_mag', |
| 'minmag':'min_mag', |
| 'nextminus':'next_minus', |
| 'nextplus':'next_plus', |
| 'nexttoward':'next_toward', |
| 'or':'logical_or', |
| 'reduce':'normalize', |
| 'remaindernear':'remainder_near', |
| 'samequantum':'same_quantum', |
| 'squareroot':'sqrt', |
| 'toeng':'to_eng_string', |
| 'tointegral':'to_integral_value', |
| 'tointegralx':'to_integral_exact', |
| 'tosci':'to_sci_string', |
| 'xor':'logical_xor', |
| } |
| |
| # The following functions return True/False rather than a Decimal instance |
| |
| LOGICAL_FUNCTIONS = ( |
| 'is_canonical', |
| 'is_finite', |
| 'is_infinite', |
| 'is_nan', |
| 'is_normal', |
| 'is_qnan', |
| 'is_signed', |
| 'is_snan', |
| 'is_subnormal', |
| 'is_zero', |
| 'same_quantum', |
| ) |
| |
| class DecimalTest(unittest.TestCase): |
| """Class which tests the Decimal class against the test cases. |
| |
| Changed for unittest. |
| """ |
| def setUp(self): |
| self.context = Context() |
| self.ignore_list = ['#'] |
| # Basically, a # means return NaN InvalidOperation. |
| # Different from a sNaN in trim |
| |
| self.ChangeDict = {'precision' : self.change_precision, |
| 'rounding' : self.change_rounding_method, |
| 'maxexponent' : self.change_max_exponent, |
| 'minexponent' : self.change_min_exponent, |
| 'clamp' : self.change_clamp} |
| |
| def eval_file(self, file): |
| global skip_expected |
| if skip_expected: |
| raise unittest.SkipTest |
| return |
| with open(file) as f: |
| for line in f: |
| line = line.replace('\r\n', '').replace('\n', '') |
| #print line |
| try: |
| t = self.eval_line(line) |
| except DecimalException as exception: |
| #Exception raised where there shouldn't have been one. |
| self.fail('Exception "'+exception.__class__.__name__ + '" raised on line '+line) |
| |
| return |
| |
| def eval_line(self, s): |
| if s.find(' -> ') >= 0 and s[:2] != '--' and not s.startswith(' --'): |
| s = (s.split('->')[0] + '->' + |
| s.split('->')[1].split('--')[0]).strip() |
| else: |
| s = s.split('--')[0].strip() |
| |
| for ignore in self.ignore_list: |
| if s.find(ignore) >= 0: |
| #print s.split()[0], 'NotImplemented--', ignore |
| return |
| if not s: |
| return |
| elif ':' in s: |
| return self.eval_directive(s) |
| else: |
| return self.eval_equation(s) |
| |
| def eval_directive(self, s): |
| funct, value = map(lambda x: x.strip().lower(), s.split(':')) |
| if funct == 'rounding': |
| value = RoundingDict[value] |
| else: |
| try: |
| value = int(value) |
| except ValueError: |
| pass |
| |
| funct = self.ChangeDict.get(funct, Nonfunction) |
| funct(value) |
| |
| def eval_equation(self, s): |
| #global DEFAULT_PRECISION |
| #print DEFAULT_PRECISION |
| |
| if not TEST_ALL and random.random() < 0.90: |
| return |
| |
| try: |
| Sides = s.split('->') |
| L = Sides[0].strip().split() |
| id = L[0] |
| if DEBUG: |
| print "Test ", id, |
| funct = L[1].lower() |
| valstemp = L[2:] |
| L = Sides[1].strip().split() |
| ans = L[0] |
| exceptions = L[1:] |
| except (TypeError, AttributeError, IndexError): |
| raise InvalidOperation |
| def FixQuotes(val): |
| val = val.replace("''", 'SingleQuote').replace('""', 'DoubleQuote') |
| val = val.replace("'", '').replace('"', '') |
| val = val.replace('SingleQuote', "'").replace('DoubleQuote', '"') |
| return val |
| |
| if id in skipped_test_ids: |
| return |
| |
| fname = nameAdapter.get(funct, funct) |
| if fname == 'rescale': |
| return |
| funct = getattr(self.context, fname) |
| vals = [] |
| conglomerate = '' |
| quote = 0 |
| theirexceptions = [ErrorNames[x.lower()] for x in exceptions] |
| |
| for exception in Signals: |
| self.context.traps[exception] = 1 #Catch these bugs... |
| for exception in theirexceptions: |
| self.context.traps[exception] = 0 |
| for i, val in enumerate(valstemp): |
| if val.count("'") % 2 == 1: |
| quote = 1 - quote |
| if quote: |
| conglomerate = conglomerate + ' ' + val |
| continue |
| else: |
| val = conglomerate + val |
| conglomerate = '' |
| v = FixQuotes(val) |
| if fname in ('to_sci_string', 'to_eng_string'): |
| if EXTENDEDERRORTEST: |
| for error in theirexceptions: |
| self.context.traps[error] = 1 |
| try: |
| funct(self.context.create_decimal(v)) |
| except error: |
| pass |
| except Signals, e: |
| self.fail("Raised %s in %s when %s disabled" % \ |
| (e, s, error)) |
| else: |
| self.fail("Did not raise %s in %s" % (error, s)) |
| self.context.traps[error] = 0 |
| v = self.context.create_decimal(v) |
| else: |
| v = Decimal(v, self.context) |
| vals.append(v) |
| |
| ans = FixQuotes(ans) |
| |
| if EXTENDEDERRORTEST and fname not in ('to_sci_string', 'to_eng_string'): |
| for error in theirexceptions: |
| self.context.traps[error] = 1 |
| try: |
| funct(*vals) |
| except error: |
| pass |
| except Signals, e: |
| self.fail("Raised %s in %s when %s disabled" % \ |
| (e, s, error)) |
| else: |
| self.fail("Did not raise %s in %s" % (error, s)) |
| self.context.traps[error] = 0 |
| |
| # as above, but add traps cumulatively, to check precedence |
| ordered_errors = [e for e in OrderedSignals if e in theirexceptions] |
| for error in ordered_errors: |
| self.context.traps[error] = 1 |
| try: |
| funct(*vals) |
| except error: |
| pass |
| except Signals, e: |
| self.fail("Raised %s in %s; expected %s" % |
| (type(e), s, error)) |
| else: |
| self.fail("Did not raise %s in %s" % (error, s)) |
| # reset traps |
| for error in ordered_errors: |
| self.context.traps[error] = 0 |
| |
| |
| if DEBUG: |
| print "--", self.context |
| try: |
| result = str(funct(*vals)) |
| if fname in LOGICAL_FUNCTIONS: |
| result = str(int(eval(result))) # 'True', 'False' -> '1', '0' |
| except Signals, error: |
| self.fail("Raised %s in %s" % (error, s)) |
| except: #Catch any error long enough to state the test case. |
| print "ERROR:", s |
| raise |
| |
| myexceptions = self.getexceptions() |
| self.context.clear_flags() |
| |
| self.assertEqual(result, ans, |
| 'Incorrect answer for ' + s + ' -- got ' + result) |
| self.assertItemsEqual(myexceptions, theirexceptions, |
| 'Incorrect flags set in ' + s + ' -- got ' + str(myexceptions)) |
| return |
| |
| def getexceptions(self): |
| return [e for e in Signals if self.context.flags[e]] |
| |
| def change_precision(self, prec): |
| self.context.prec = prec |
| def change_rounding_method(self, rounding): |
| self.context.rounding = rounding |
| def change_min_exponent(self, exp): |
| self.context.Emin = exp |
| def change_max_exponent(self, exp): |
| self.context.Emax = exp |
| def change_clamp(self, clamp): |
| self.context._clamp = clamp |
| |
| |
| |
| # The following classes test the behaviour of Decimal according to PEP 327 |
| |
| class DecimalExplicitConstructionTest(unittest.TestCase): |
| '''Unit tests for Explicit Construction cases of Decimal.''' |
| |
| def test_explicit_empty(self): |
| self.assertEqual(Decimal(), Decimal("0")) |
| |
| def test_explicit_from_None(self): |
| self.assertRaises(TypeError, Decimal, None) |
| |
| def test_explicit_from_int(self): |
| |
| #positive |
| d = Decimal(45) |
| self.assertEqual(str(d), '45') |
| |
| #very large positive |
| d = Decimal(500000123) |
| self.assertEqual(str(d), '500000123') |
| |
| #negative |
| d = Decimal(-45) |
| self.assertEqual(str(d), '-45') |
| |
| #zero |
| d = Decimal(0) |
| self.assertEqual(str(d), '0') |
| |
| def test_explicit_from_string(self): |
| |
| #empty |
| self.assertEqual(str(Decimal('')), 'NaN') |
| |
| #int |
| self.assertEqual(str(Decimal('45')), '45') |
| |
| #float |
| self.assertEqual(str(Decimal('45.34')), '45.34') |
| |
| #engineer notation |
| self.assertEqual(str(Decimal('45e2')), '4.5E+3') |
| |
| #just not a number |
| self.assertEqual(str(Decimal('ugly')), 'NaN') |
| |
| #leading and trailing whitespace permitted |
| self.assertEqual(str(Decimal('1.3E4 \n')), '1.3E+4') |
| self.assertEqual(str(Decimal(' -7.89')), '-7.89') |
| |
| #unicode strings should be permitted |
| self.assertEqual(str(Decimal(u'0E-017')), '0E-17') |
| self.assertEqual(str(Decimal(u'45')), '45') |
| self.assertEqual(str(Decimal(u'-Inf')), '-Infinity') |
| self.assertEqual(str(Decimal(u'NaN123')), 'NaN123') |
| |
| def test_explicit_from_tuples(self): |
| |
| #zero |
| d = Decimal( (0, (0,), 0) ) |
| self.assertEqual(str(d), '0') |
| |
| #int |
| d = Decimal( (1, (4, 5), 0) ) |
| self.assertEqual(str(d), '-45') |
| |
| #float |
| d = Decimal( (0, (4, 5, 3, 4), -2) ) |
| self.assertEqual(str(d), '45.34') |
| |
| #weird |
| d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) ) |
| self.assertEqual(str(d), '-4.34913534E-17') |
| |
| #wrong number of items |
| self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1)) ) |
| |
| #bad sign |
| self.assertRaises(ValueError, Decimal, (8, (4, 3, 4, 9, 1), 2) ) |
| self.assertRaises(ValueError, Decimal, (0., (4, 3, 4, 9, 1), 2) ) |
| self.assertRaises(ValueError, Decimal, (Decimal(1), (4, 3, 4, 9, 1), 2)) |
| |
| #bad exp |
| self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!') ) |
| self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 0.) ) |
| self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), '1') ) |
| |
| #bad coefficients |
| self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) ) |
| self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) ) |
| self.assertRaises(ValueError, Decimal, (1, (4, 10, 4, 9, 1), 2) ) |
| self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 'a', 1), 2) ) |
| |
| def test_explicit_from_bool(self): |
| self.assertIs(bool(Decimal(0)), False) |
| self.assertIs(bool(Decimal(1)), True) |
| self.assertEqual(Decimal(False), Decimal(0)) |
| self.assertEqual(Decimal(True), Decimal(1)) |
| |
| def test_explicit_from_Decimal(self): |
| |
| #positive |
| d = Decimal(45) |
| e = Decimal(d) |
| self.assertEqual(str(e), '45') |
| self.assertNotEqual(id(d), id(e)) |
| |
| #very large positive |
| d = Decimal(500000123) |
| e = Decimal(d) |
| self.assertEqual(str(e), '500000123') |
| self.assertNotEqual(id(d), id(e)) |
| |
| #negative |
| d = Decimal(-45) |
| e = Decimal(d) |
| self.assertEqual(str(e), '-45') |
| self.assertNotEqual(id(d), id(e)) |
| |
| #zero |
| d = Decimal(0) |
| e = Decimal(d) |
| self.assertEqual(str(e), '0') |
| self.assertNotEqual(id(d), id(e)) |
| |
| @requires_IEEE_754 |
| def test_explicit_from_float(self): |
| r = Decimal(0.1) |
| self.assertEqual(type(r), Decimal) |
| self.assertEqual(str(r), |
| '0.1000000000000000055511151231257827021181583404541015625') |
| self.assertTrue(Decimal(float('nan')).is_qnan()) |
| self.assertTrue(Decimal(float('inf')).is_infinite()) |
| self.assertTrue(Decimal(float('-inf')).is_infinite()) |
| self.assertEqual(str(Decimal(float('nan'))), |
| str(Decimal('NaN'))) |
| self.assertEqual(str(Decimal(float('inf'))), |
| str(Decimal('Infinity'))) |
| self.assertEqual(str(Decimal(float('-inf'))), |
| str(Decimal('-Infinity'))) |
| self.assertEqual(str(Decimal(float('-0.0'))), |
| str(Decimal('-0'))) |
| for i in range(200): |
| x = random.expovariate(0.01) * (random.random() * 2.0 - 1.0) |
| self.assertEqual(x, float(Decimal(x))) # roundtrip |
| |
| def test_explicit_context_create_decimal(self): |
| |
| nc = copy.copy(getcontext()) |
| nc.prec = 3 |
| |
| # empty |
| d = Decimal() |
| self.assertEqual(str(d), '0') |
| d = nc.create_decimal() |
| self.assertEqual(str(d), '0') |
| |
| # from None |
| self.assertRaises(TypeError, nc.create_decimal, None) |
| |
| # from int |
| d = nc.create_decimal(456) |
| self.assertIsInstance(d, Decimal) |
| self.assertEqual(nc.create_decimal(45678), |
| nc.create_decimal('457E+2')) |
| |
| # from string |
| d = Decimal('456789') |
| self.assertEqual(str(d), '456789') |
| d = nc.create_decimal('456789') |
| self.assertEqual(str(d), '4.57E+5') |
| # leading and trailing whitespace should result in a NaN; |
| # spaces are already checked in Cowlishaw's test-suite, so |
| # here we just check that a trailing newline results in a NaN |
| self.assertEqual(str(nc.create_decimal('3.14\n')), 'NaN') |
| |
| # from tuples |
| d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) ) |
| self.assertEqual(str(d), '-4.34913534E-17') |
| d = nc.create_decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) ) |
| self.assertEqual(str(d), '-4.35E-17') |
| |
| # from Decimal |
| prevdec = Decimal(500000123) |
| d = Decimal(prevdec) |
| self.assertEqual(str(d), '500000123') |
| d = nc.create_decimal(prevdec) |
| self.assertEqual(str(d), '5.00E+8') |
| |
| def test_unicode_digits(self): |
| test_values = { |
| u'\uff11': '1', |
| u'\u0660.\u0660\u0663\u0667\u0662e-\u0663' : '0.0000372', |
| u'-nan\u0c68\u0c6a\u0c66\u0c66' : '-NaN2400', |
| } |
| for input, expected in test_values.items(): |
| self.assertEqual(str(Decimal(input)), expected) |
| |
| |
| class DecimalImplicitConstructionTest(unittest.TestCase): |
| '''Unit tests for Implicit Construction cases of Decimal.''' |
| |
| def test_implicit_from_None(self): |
| self.assertRaises(TypeError, eval, 'Decimal(5) + None', globals()) |
| |
| def test_implicit_from_int(self): |
| #normal |
| self.assertEqual(str(Decimal(5) + 45), '50') |
| #exceeding precision |
| self.assertEqual(Decimal(5) + 123456789000, Decimal(123456789000)) |
| |
| def test_implicit_from_string(self): |
| self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', globals()) |
| |
| def test_implicit_from_float(self): |
| self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', globals()) |
| |
| def test_implicit_from_Decimal(self): |
| self.assertEqual(Decimal(5) + Decimal(45), Decimal(50)) |
| |
| def test_rop(self): |
| # Allow other classes to be trained to interact with Decimals |
| class E: |
| def __divmod__(self, other): |
| return 'divmod ' + str(other) |
| def __rdivmod__(self, other): |
| return str(other) + ' rdivmod' |
| def __lt__(self, other): |
| return 'lt ' + str(other) |
| def __gt__(self, other): |
| return 'gt ' + str(other) |
| def __le__(self, other): |
| return 'le ' + str(other) |
| def __ge__(self, other): |
| return 'ge ' + str(other) |
| def __eq__(self, other): |
| return 'eq ' + str(other) |
| def __ne__(self, other): |
| return 'ne ' + str(other) |
| |
| self.assertEqual(divmod(E(), Decimal(10)), 'divmod 10') |
| self.assertEqual(divmod(Decimal(10), E()), '10 rdivmod') |
| self.assertEqual(eval('Decimal(10) < E()'), 'gt 10') |
| self.assertEqual(eval('Decimal(10) > E()'), 'lt 10') |
| self.assertEqual(eval('Decimal(10) <= E()'), 'ge 10') |
| self.assertEqual(eval('Decimal(10) >= E()'), 'le 10') |
| self.assertEqual(eval('Decimal(10) == E()'), 'eq 10') |
| self.assertEqual(eval('Decimal(10) != E()'), 'ne 10') |
| |
| # insert operator methods and then exercise them |
| oplist = [ |
| ('+', '__add__', '__radd__'), |
| ('-', '__sub__', '__rsub__'), |
| ('*', '__mul__', '__rmul__'), |
| ('%', '__mod__', '__rmod__'), |
| ('//', '__floordiv__', '__rfloordiv__'), |
| ('**', '__pow__', '__rpow__') |
| ] |
| with check_py3k_warnings(): |
| if 1 / 2 == 0: |
| # testing with classic division, so add __div__ |
| oplist.append(('/', '__div__', '__rdiv__')) |
| else: |
| # testing with -Qnew, so add __truediv__ |
| oplist.append(('/', '__truediv__', '__rtruediv__')) |
| |
| for sym, lop, rop in oplist: |
| setattr(E, lop, lambda self, other: 'str' + lop + str(other)) |
| setattr(E, rop, lambda self, other: str(other) + rop + 'str') |
| self.assertEqual(eval('E()' + sym + 'Decimal(10)'), |
| 'str' + lop + '10') |
| self.assertEqual(eval('Decimal(10)' + sym + 'E()'), |
| '10' + rop + 'str') |
| |
| |
| class DecimalFormatTest(unittest.TestCase): |
| '''Unit tests for the format function.''' |
| def test_formatting(self): |
| # triples giving a format, a Decimal, and the expected result |
| test_values = [ |
| ('e', '0E-15', '0e-15'), |
| ('e', '2.3E-15', '2.3e-15'), |
| ('e', '2.30E+2', '2.30e+2'), # preserve significant zeros |
| ('e', '2.30000E-15', '2.30000e-15'), |
| ('e', '1.23456789123456789e40', '1.23456789123456789e+40'), |
| ('e', '1.5', '1.5e+0'), |
| ('e', '0.15', '1.5e-1'), |
| ('e', '0.015', '1.5e-2'), |
| ('e', '0.0000000000015', '1.5e-12'), |
| ('e', '15.0', '1.50e+1'), |
| ('e', '-15', '-1.5e+1'), |
| ('e', '0', '0e+0'), |
| ('e', '0E1', '0e+1'), |
| ('e', '0.0', '0e-1'), |
| ('e', '0.00', '0e-2'), |
| ('.6e', '0E-15', '0.000000e-9'), |
| ('.6e', '0', '0.000000e+6'), |
| ('.6e', '9.999999', '9.999999e+0'), |
| ('.6e', '9.9999999', '1.000000e+1'), |
| ('.6e', '-1.23e5', '-1.230000e+5'), |
| ('.6e', '1.23456789e-3', '1.234568e-3'), |
| ('f', '0', '0'), |
| ('f', '0.0', '0.0'), |
| ('f', '0E-2', '0.00'), |
| ('f', '0.00E-8', '0.0000000000'), |
| ('f', '0E1', '0'), # loses exponent information |
| ('f', '3.2E1', '32'), |
| ('f', '3.2E2', '320'), |
| ('f', '3.20E2', '320'), |
| ('f', '3.200E2', '320.0'), |
| ('f', '3.2E-6', '0.0000032'), |
| ('.6f', '0E-15', '0.000000'), # all zeros treated equally |
| ('.6f', '0E1', '0.000000'), |
| ('.6f', '0', '0.000000'), |
| ('.0f', '0', '0'), # no decimal point |
| ('.0f', '0e-2', '0'), |
| ('.0f', '3.14159265', '3'), |
| ('.1f', '3.14159265', '3.1'), |
| ('.4f', '3.14159265', '3.1416'), |
| ('.6f', '3.14159265', '3.141593'), |
| ('.7f', '3.14159265', '3.1415926'), # round-half-even! |
| ('.8f', '3.14159265', '3.14159265'), |
| ('.9f', '3.14159265', '3.141592650'), |
| |
| ('g', '0', '0'), |
| ('g', '0.0', '0.0'), |
| ('g', '0E1', '0e+1'), |
| ('G', '0E1', '0E+1'), |
| ('g', '0E-5', '0.00000'), |
| ('g', '0E-6', '0.000000'), |
| ('g', '0E-7', '0e-7'), |
| ('g', '-0E2', '-0e+2'), |
| ('.0g', '3.14159265', '3'), # 0 sig fig -> 1 sig fig |
| ('.1g', '3.14159265', '3'), |
| ('.2g', '3.14159265', '3.1'), |
| ('.5g', '3.14159265', '3.1416'), |
| ('.7g', '3.14159265', '3.141593'), |
| ('.8g', '3.14159265', '3.1415926'), # round-half-even! |
| ('.9g', '3.14159265', '3.14159265'), |
| ('.10g', '3.14159265', '3.14159265'), # don't pad |
| |
| ('%', '0E1', '0%'), |
| ('%', '0E0', '0%'), |
| ('%', '0E-1', '0%'), |
| ('%', '0E-2', '0%'), |
| ('%', '0E-3', '0.0%'), |
| ('%', '0E-4', '0.00%'), |
| |
| ('.3%', '0', '0.000%'), # all zeros treated equally |
| ('.3%', '0E10', '0.000%'), |
| ('.3%', '0E-10', '0.000%'), |
| ('.3%', '2.34', '234.000%'), |
| ('.3%', '1.234567', '123.457%'), |
| ('.0%', '1.23', '123%'), |
| |
| ('e', 'NaN', 'NaN'), |
| ('f', '-NaN123', '-NaN123'), |
| ('+g', 'NaN456', '+NaN456'), |
| ('.3e', 'Inf', 'Infinity'), |
| ('.16f', '-Inf', '-Infinity'), |
| ('.0g', '-sNaN', '-sNaN'), |
| |
| ('', '1.00', '1.00'), |
| |
| # test alignment and padding |
| ('6', '123', ' 123'), |
| ('<6', '123', '123 '), |
| ('>6', '123', ' 123'), |
| ('^6', '123', ' 123 '), |
| ('=+6', '123', '+ 123'), |
| ('#<10', 'NaN', 'NaN#######'), |
| ('#<10', '-4.3', '-4.3######'), |
| ('#<+10', '0.0130', '+0.0130###'), |
| ('#< 10', '0.0130', ' 0.0130###'), |
| ('@>10', '-Inf', '@-Infinity'), |
| ('#>5', '-Inf', '-Infinity'), |
| ('?^5', '123', '?123?'), |
| ('%^6', '123', '%123%%'), |
| (' ^6', '-45.6', '-45.6 '), |
| ('/=10', '-45.6', '-/////45.6'), |
| ('/=+10', '45.6', '+/////45.6'), |
| ('/= 10', '45.6', ' /////45.6'), |
| |
| # thousands separator |
| (',', '1234567', '1,234,567'), |
| (',', '123456', '123,456'), |
| (',', '12345', '12,345'), |
| (',', '1234', '1,234'), |
| (',', '123', '123'), |
| (',', '12', '12'), |
| (',', '1', '1'), |
| (',', '0', '0'), |
| (',', '-1234567', '-1,234,567'), |
| (',', '-123456', '-123,456'), |
| ('7,', '123456', '123,456'), |
| ('8,', '123456', ' 123,456'), |
| ('08,', '123456', '0,123,456'), # special case: extra 0 needed |
| ('+08,', '123456', '+123,456'), # but not if there's a sign |
| (' 08,', '123456', ' 123,456'), |
| ('08,', '-123456', '-123,456'), |
| ('+09,', '123456', '+0,123,456'), |
| # ... with fractional part... |
| ('07,', '1234.56', '1,234.56'), |
| ('08,', '1234.56', '1,234.56'), |
| ('09,', '1234.56', '01,234.56'), |
| ('010,', '1234.56', '001,234.56'), |
| ('011,', '1234.56', '0,001,234.56'), |
| ('012,', '1234.56', '0,001,234.56'), |
| ('08,.1f', '1234.5', '01,234.5'), |
| # no thousands separators in fraction part |
| (',', '1.23456789', '1.23456789'), |
| (',%', '123.456789', '12,345.6789%'), |
| (',e', '123456', '1.23456e+5'), |
| (',E', '123456', '1.23456E+5'), |
| |
| # issue 6850 |
| ('a=-7.0', '0.12345', 'aaaa0.1'), |
| ] |
| for fmt, d, result in test_values: |
| self.assertEqual(format(Decimal(d), fmt), result) |
| |
| def test_n_format(self): |
| try: |
| from locale import CHAR_MAX |
| except ImportError: |
| return |
| |
| # Set up some localeconv-like dictionaries |
| en_US = { |
| 'decimal_point' : '.', |
| 'grouping' : [3, 3, 0], |
| 'thousands_sep': ',' |
| } |
| |
| fr_FR = { |
| 'decimal_point' : ',', |
| 'grouping' : [CHAR_MAX], |
| 'thousands_sep' : '' |
| } |
| |
| ru_RU = { |
| 'decimal_point' : ',', |
| 'grouping' : [3, 3, 0], |
| 'thousands_sep' : ' ' |
| } |
| |
| crazy = { |
| 'decimal_point' : '&', |
| 'grouping' : [1, 4, 2, CHAR_MAX], |
| 'thousands_sep' : '-' |
| } |
| |
| |
| def get_fmt(x, locale, fmt='n'): |
| return Decimal.__format__(Decimal(x), fmt, _localeconv=locale) |
| |
| self.assertEqual(get_fmt(Decimal('12.7'), en_US), '12.7') |
| self.assertEqual(get_fmt(Decimal('12.7'), fr_FR), '12,7') |
| self.assertEqual(get_fmt(Decimal('12.7'), ru_RU), '12,7') |
| self.assertEqual(get_fmt(Decimal('12.7'), crazy), '1-2&7') |
| |
| self.assertEqual(get_fmt(123456789, en_US), '123,456,789') |
| self.assertEqual(get_fmt(123456789, fr_FR), '123456789') |
| self.assertEqual(get_fmt(123456789, ru_RU), '123 456 789') |
| self.assertEqual(get_fmt(1234567890123, crazy), '123456-78-9012-3') |
| |
| self.assertEqual(get_fmt(123456789, en_US, '.6n'), '1.23457e+8') |
| self.assertEqual(get_fmt(123456789, fr_FR, '.6n'), '1,23457e+8') |
| self.assertEqual(get_fmt(123456789, ru_RU, '.6n'), '1,23457e+8') |
| self.assertEqual(get_fmt(123456789, crazy, '.6n'), '1&23457e+8') |
| |
| # zero padding |
| self.assertEqual(get_fmt(1234, fr_FR, '03n'), '1234') |
| self.assertEqual(get_fmt(1234, fr_FR, '04n'), '1234') |
| self.assertEqual(get_fmt(1234, fr_FR, '05n'), '01234') |
| self.assertEqual(get_fmt(1234, fr_FR, '06n'), '001234') |
| |
| self.assertEqual(get_fmt(12345, en_US, '05n'), '12,345') |
| self.assertEqual(get_fmt(12345, en_US, '06n'), '12,345') |
| self.assertEqual(get_fmt(12345, en_US, '07n'), '012,345') |
| self.assertEqual(get_fmt(12345, en_US, '08n'), '0,012,345') |
| self.assertEqual(get_fmt(12345, en_US, '09n'), '0,012,345') |
| self.assertEqual(get_fmt(12345, en_US, '010n'), '00,012,345') |
| |
| self.assertEqual(get_fmt(123456, crazy, '06n'), '1-2345-6') |
| self.assertEqual(get_fmt(123456, crazy, '07n'), '1-2345-6') |
| self.assertEqual(get_fmt(123456, crazy, '08n'), '1-2345-6') |
| self.assertEqual(get_fmt(123456, crazy, '09n'), '01-2345-6') |
| self.assertEqual(get_fmt(123456, crazy, '010n'), '0-01-2345-6') |
| self.assertEqual(get_fmt(123456, crazy, '011n'), '0-01-2345-6') |
| self.assertEqual(get_fmt(123456, crazy, '012n'), '00-01-2345-6') |
| self.assertEqual(get_fmt(123456, crazy, '013n'), '000-01-2345-6') |
| |
| |
| class DecimalArithmeticOperatorsTest(unittest.TestCase): |
| '''Unit tests for all arithmetic operators, binary and unary.''' |
| |
| def test_addition(self): |
| |
| d1 = Decimal('-11.1') |
| d2 = Decimal('22.2') |
| |
| #two Decimals |
| self.assertEqual(d1+d2, Decimal('11.1')) |
| self.assertEqual(d2+d1, Decimal('11.1')) |
| |
| #with other type, left |
| c = d1 + 5 |
| self.assertEqual(c, Decimal('-6.1')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #with other type, right |
| c = 5 + d1 |
| self.assertEqual(c, Decimal('-6.1')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #inline with decimal |
| d1 += d2 |
| self.assertEqual(d1, Decimal('11.1')) |
| |
| #inline with other type |
| d1 += 5 |
| self.assertEqual(d1, Decimal('16.1')) |
| |
| def test_subtraction(self): |
| |
| d1 = Decimal('-11.1') |
| d2 = Decimal('22.2') |
| |
| #two Decimals |
| self.assertEqual(d1-d2, Decimal('-33.3')) |
| self.assertEqual(d2-d1, Decimal('33.3')) |
| |
| #with other type, left |
| c = d1 - 5 |
| self.assertEqual(c, Decimal('-16.1')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #with other type, right |
| c = 5 - d1 |
| self.assertEqual(c, Decimal('16.1')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #inline with decimal |
| d1 -= d2 |
| self.assertEqual(d1, Decimal('-33.3')) |
| |
| #inline with other type |
| d1 -= 5 |
| self.assertEqual(d1, Decimal('-38.3')) |
| |
| def test_multiplication(self): |
| |
| d1 = Decimal('-5') |
| d2 = Decimal('3') |
| |
| #two Decimals |
| self.assertEqual(d1*d2, Decimal('-15')) |
| self.assertEqual(d2*d1, Decimal('-15')) |
| |
| #with other type, left |
| c = d1 * 5 |
| self.assertEqual(c, Decimal('-25')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #with other type, right |
| c = 5 * d1 |
| self.assertEqual(c, Decimal('-25')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #inline with decimal |
| d1 *= d2 |
| self.assertEqual(d1, Decimal('-15')) |
| |
| #inline with other type |
| d1 *= 5 |
| self.assertEqual(d1, Decimal('-75')) |
| |
| def test_division(self): |
| |
| d1 = Decimal('-5') |
| d2 = Decimal('2') |
| |
| #two Decimals |
| self.assertEqual(d1/d2, Decimal('-2.5')) |
| self.assertEqual(d2/d1, Decimal('-0.4')) |
| |
| #with other type, left |
| c = d1 / 4 |
| self.assertEqual(c, Decimal('-1.25')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #with other type, right |
| c = 4 / d1 |
| self.assertEqual(c, Decimal('-0.8')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #inline with decimal |
| d1 /= d2 |
| self.assertEqual(d1, Decimal('-2.5')) |
| |
| #inline with other type |
| d1 /= 4 |
| self.assertEqual(d1, Decimal('-0.625')) |
| |
| def test_floor_division(self): |
| |
| d1 = Decimal('5') |
| d2 = Decimal('2') |
| |
| #two Decimals |
| self.assertEqual(d1//d2, Decimal('2')) |
| self.assertEqual(d2//d1, Decimal('0')) |
| |
| #with other type, left |
| c = d1 // 4 |
| self.assertEqual(c, Decimal('1')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #with other type, right |
| c = 7 // d1 |
| self.assertEqual(c, Decimal('1')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #inline with decimal |
| d1 //= d2 |
| self.assertEqual(d1, Decimal('2')) |
| |
| #inline with other type |
| d1 //= 2 |
| self.assertEqual(d1, Decimal('1')) |
| |
| def test_powering(self): |
| |
| d1 = Decimal('5') |
| d2 = Decimal('2') |
| |
| #two Decimals |
| self.assertEqual(d1**d2, Decimal('25')) |
| self.assertEqual(d2**d1, Decimal('32')) |
| |
| #with other type, left |
| c = d1 ** 4 |
| self.assertEqual(c, Decimal('625')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #with other type, right |
| c = 7 ** d1 |
| self.assertEqual(c, Decimal('16807')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #inline with decimal |
| d1 **= d2 |
| self.assertEqual(d1, Decimal('25')) |
| |
| #inline with other type |
| d1 **= 4 |
| self.assertEqual(d1, Decimal('390625')) |
| |
| def test_module(self): |
| |
| d1 = Decimal('5') |
| d2 = Decimal('2') |
| |
| #two Decimals |
| self.assertEqual(d1%d2, Decimal('1')) |
| self.assertEqual(d2%d1, Decimal('2')) |
| |
| #with other type, left |
| c = d1 % 4 |
| self.assertEqual(c, Decimal('1')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #with other type, right |
| c = 7 % d1 |
| self.assertEqual(c, Decimal('2')) |
| self.assertEqual(type(c), type(d1)) |
| |
| #inline with decimal |
| d1 %= d2 |
| self.assertEqual(d1, Decimal('1')) |
| |
| #inline with other type |
| d1 %= 4 |
| self.assertEqual(d1, Decimal('1')) |
| |
| def test_floor_div_module(self): |
| |
| d1 = Decimal('5') |
| d2 = Decimal('2') |
| |
| #two Decimals |
| (p, q) = divmod(d1, d2) |
| self.assertEqual(p, Decimal('2')) |
| self.assertEqual(q, Decimal('1')) |
| self.assertEqual(type(p), type(d1)) |
| self.assertEqual(type(q), type(d1)) |
| |
| #with other type, left |
| (p, q) = divmod(d1, 4) |
| self.assertEqual(p, Decimal('1')) |
| self.assertEqual(q, Decimal('1')) |
| self.assertEqual(type(p), type(d1)) |
| self.assertEqual(type(q), type(d1)) |
| |
| #with other type, right |
| (p, q) = divmod(7, d1) |
| self.assertEqual(p, Decimal('1')) |
| self.assertEqual(q, Decimal('2')) |
| self.assertEqual(type(p), type(d1)) |
| self.assertEqual(type(q), type(d1)) |
| |
| def test_unary_operators(self): |
| self.assertEqual(+Decimal(45), Decimal(+45)) # + |
| self.assertEqual(-Decimal(45), Decimal(-45)) # - |
| self.assertEqual(abs(Decimal(45)), abs(Decimal(-45))) # abs |
| |
| def test_nan_comparisons(self): |
| # comparisons involving signaling nans signal InvalidOperation |
| |
| # order comparisons (<, <=, >, >=) involving only quiet nans |
| # also signal InvalidOperation |
| |
| # equality comparisons (==, !=) involving only quiet nans |
| # don't signal, but return False or True respectively. |
| |
| n = Decimal('NaN') |
| s = Decimal('sNaN') |
| i = Decimal('Inf') |
| f = Decimal('2') |
| |
| qnan_pairs = (n, n), (n, i), (i, n), (n, f), (f, n) |
| snan_pairs = (s, n), (n, s), (s, i), (i, s), (s, f), (f, s), (s, s) |
| order_ops = operator.lt, operator.le, operator.gt, operator.ge |
| equality_ops = operator.eq, operator.ne |
| |
| # results when InvalidOperation is not trapped |
| for x, y in qnan_pairs + snan_pairs: |
| for op in order_ops + equality_ops: |
| got = op(x, y) |
| expected = True if op is operator.ne else False |
| self.assertIs(expected, got, |
| "expected {0!r} for operator.{1}({2!r}, {3!r}); " |
| "got {4!r}".format( |
| expected, op.__name__, x, y, got)) |
| |
| # repeat the above, but this time trap the InvalidOperation |
| with localcontext() as ctx: |
| ctx.traps[InvalidOperation] = 1 |
| |
| for x, y in qnan_pairs: |
| for op in equality_ops: |
| got = op(x, y) |
| expected = True if op is operator.ne else False |
| self.assertIs(expected, got, |
| "expected {0!r} for " |
| "operator.{1}({2!r}, {3!r}); " |
| "got {4!r}".format( |
| expected, op.__name__, x, y, got)) |
| |
| for x, y in snan_pairs: |
| for op in equality_ops: |
| self.assertRaises(InvalidOperation, operator.eq, x, y) |
| self.assertRaises(InvalidOperation, operator.ne, x, y) |
| |
| for x, y in qnan_pairs + snan_pairs: |
| for op in order_ops: |
| self.assertRaises(InvalidOperation, op, x, y) |
| |
| def test_copy_sign(self): |
| d = Decimal(1).copy_sign(Decimal(-2)) |
| |
| self.assertEqual(Decimal(1).copy_sign(-2), d) |
| self.assertRaises(TypeError, Decimal(1).copy_sign, '-2') |
| |
| # The following are two functions used to test threading in the next class |
| |
| def thfunc1(cls): |
| d1 = Decimal(1) |
| d3 = Decimal(3) |
| test1 = d1/d3 |
| cls.synchro.wait() |
| test2 = d1/d3 |
| cls.finish1.set() |
| |
| cls.assertEqual(test1, Decimal('0.3333333333333333333333333333')) |
| cls.assertEqual(test2, Decimal('0.3333333333333333333333333333')) |
| return |
| |
| def thfunc2(cls): |
| d1 = Decimal(1) |
| d3 = Decimal(3) |
| test1 = d1/d3 |
| thiscontext = getcontext() |
| thiscontext.prec = 18 |
| test2 = d1/d3 |
| cls.synchro.set() |
| cls.finish2.set() |
| |
| cls.assertEqual(test1, Decimal('0.3333333333333333333333333333')) |
| cls.assertEqual(test2, Decimal('0.333333333333333333')) |
| return |
| |
| |
| class DecimalUseOfContextTest(unittest.TestCase): |
| '''Unit tests for Use of Context cases in Decimal.''' |
| |
| try: |
| import threading |
| except ImportError: |
| threading = None |
| |
| # Take care executing this test from IDLE, there's an issue in threading |
| # that hangs IDLE and I couldn't find it |
| |
| def test_threading(self): |
| #Test the "threading isolation" of a Context. |
| |
| self.synchro = threading.Event() |
| self.finish1 = threading.Event() |
| self.finish2 = threading.Event() |
| |
| th1 = threading.Thread(target=thfunc1, args=(self,)) |
| th2 = threading.Thread(target=thfunc2, args=(self,)) |
| |
| th1.start() |
| th2.start() |
| |
| self.finish1.wait() |
| self.finish2.wait() |
| return |
| |
| if threading is None: |
| del test_threading |
| |
| |
| class DecimalUsabilityTest(unittest.TestCase): |
| '''Unit tests for Usability cases of Decimal.''' |
| |
| def test_comparison_operators(self): |
| |
| da = Decimal('23.42') |
| db = Decimal('23.42') |
| dc = Decimal('45') |
| |
| #two Decimals |
| self.assertGreater(dc, da) |
| self.assertGreaterEqual(dc, da) |
| self.assertLess(da, dc) |
| self.assertLessEqual(da, dc) |
| self.assertEqual(da, db) |
| self.assertNotEqual(da, dc) |
| self.assertLessEqual(da, db) |
| self.assertGreaterEqual(da, db) |
| self.assertEqual(cmp(dc,da), 1) |
| self.assertEqual(cmp(da,dc), -1) |
| self.assertEqual(cmp(da,db), 0) |
| |
| #a Decimal and an int |
| self.assertGreater(dc, 23) |
| self.assertLess(23, dc) |
| self.assertEqual(dc, 45) |
| self.assertEqual(cmp(dc,23), 1) |
| self.assertEqual(cmp(23,dc), -1) |
| self.assertEqual(cmp(dc,45), 0) |
| |
| #a Decimal and uncomparable |
| self.assertNotEqual(da, 'ugly') |
| self.assertNotEqual(da, 32.7) |
| self.assertNotEqual(da, object()) |
| self.assertNotEqual(da, object) |
| |
| # sortable |
| a = map(Decimal, xrange(100)) |
| b = a[:] |
| random.shuffle(a) |
| a.sort() |
| self.assertEqual(a, b) |
| |
| # with None |
| with check_py3k_warnings(): |
| self.assertFalse(Decimal(1) < None) |
| self.assertTrue(Decimal(1) > None) |
| |
| def test_decimal_float_comparison(self): |
| da = Decimal('0.25') |
| db = Decimal('3.0') |
| self.assertLess(da, 3.0) |
| self.assertLessEqual(da, 3.0) |
| self.assertGreater(db, 0.25) |
| self.assertGreaterEqual(db, 0.25) |
| self.assertNotEqual(da, 1.5) |
| self.assertEqual(da, 0.25) |
| self.assertGreater(3.0, da) |
| self.assertGreaterEqual(3.0, da) |
| self.assertLess(0.25, db) |
| self.assertLessEqual(0.25, db) |
| self.assertNotEqual(0.25, db) |
| self.assertEqual(3.0, db) |
| self.assertNotEqual(0.1, Decimal('0.1')) |
| |
| def test_copy_and_deepcopy_methods(self): |
| d = Decimal('43.24') |
| c = copy.copy(d) |
| self.assertEqual(id(c), id(d)) |
| dc = copy.deepcopy(d) |
| self.assertEqual(id(dc), id(d)) |
| |
| def test_hash_method(self): |
| #just that it's hashable |
| hash(Decimal(23)) |
| hash(Decimal('Infinity')) |
| hash(Decimal('-Infinity')) |
| hash(Decimal('nan123')) |
| hash(Decimal('-NaN')) |
| |
| test_values = [Decimal(sign*(2**m + n)) |
| for m in [0, 14, 15, 16, 17, 30, 31, |
| 32, 33, 62, 63, 64, 65, 66] |
| for n in range(-10, 10) |
| for sign in [-1, 1]] |
| test_values.extend([ |
| Decimal("-0"), # zeros |
| Decimal("0.00"), |
| Decimal("-0.000"), |
| Decimal("0E10"), |
| Decimal("-0E12"), |
| Decimal("10.0"), # negative exponent |
| Decimal("-23.00000"), |
| Decimal("1230E100"), # positive exponent |
| Decimal("-4.5678E50"), |
| # a value for which hash(n) != hash(n % (2**64-1)) |
| # in Python pre-2.6 |
| Decimal(2**64 + 2**32 - 1), |
| # selection of values which fail with the old (before |
| # version 2.6) long.__hash__ |
| Decimal("1.634E100"), |
| Decimal("90.697E100"), |
| Decimal("188.83E100"), |
| Decimal("1652.9E100"), |
| Decimal("56531E100"), |
| ]) |
| |
| # check that hash(d) == hash(int(d)) for integral values |
| for value in test_values: |
| self.assertEqual(hash(value), hash(int(value))) |
| |
| #the same hash that to an int |
| self.assertEqual(hash(Decimal(23)), hash(23)) |
| self.assertRaises(TypeError, hash, Decimal('sNaN')) |
| self.assertTrue(hash(Decimal('Inf'))) |
| self.assertTrue(hash(Decimal('-Inf'))) |
| |
| # check that the hashes of a Decimal float match when they |
| # represent exactly the same values |
| test_strings = ['inf', '-Inf', '0.0', '-.0e1', |
| '34.0', '2.5', '112390.625', '-0.515625'] |
| for s in test_strings: |
| f = float(s) |
| d = Decimal(s) |
| self.assertEqual(hash(f), hash(d)) |
| |
| # check that the value of the hash doesn't depend on the |
| # current context (issue #1757) |
| c = getcontext() |
| old_precision = c.prec |
| x = Decimal("123456789.1") |
| |
| c.prec = 6 |
| h1 = hash(x) |
| c.prec = 10 |
| h2 = hash(x) |
| c.prec = 16 |
| h3 = hash(x) |
| |
| self.assertEqual(h1, h2) |
| self.assertEqual(h1, h3) |
| c.prec = old_precision |
| |
| def test_min_and_max_methods(self): |
| |
| d1 = Decimal('15.32') |
| d2 = Decimal('28.5') |
| l1 = 15 |
| l2 = 28 |
| |
| #between Decimals |
| self.assertIs(min(d1,d2), d1) |
| self.assertIs(min(d2,d1), d1) |
| self.assertIs(max(d1,d2), d2) |
| self.assertIs(max(d2,d1), d2) |
| |
| #between Decimal and long |
| self.assertIs(min(d1,l2), d1) |
| self.assertIs(min(l2,d1), d1) |
| self.assertIs(max(l1,d2), d2) |
| self.assertIs(max(d2,l1), d2) |
| |
| def test_as_nonzero(self): |
| #as false |
| self.assertFalse(Decimal(0)) |
| #as true |
| self.assertTrue(Decimal('0.372')) |
| |
| def test_tostring_methods(self): |
| #Test str and repr methods. |
| |
| d = Decimal('15.32') |
| self.assertEqual(str(d), '15.32') # str |
| self.assertEqual(repr(d), "Decimal('15.32')") # repr |
| |
| # result type of string methods should be str, not unicode |
| unicode_inputs = [u'123.4', u'0.5E2', u'Infinity', u'sNaN', |
| u'-0.0E100', u'-NaN001', u'-Inf'] |
| |
| for u in unicode_inputs: |
| d = Decimal(u) |
| self.assertEqual(type(str(d)), str) |
| self.assertEqual(type(repr(d)), str) |
| self.assertEqual(type(d.to_eng_string()), str) |
| |
| def test_tonum_methods(self): |
| #Test float, int and long methods. |
| |
| d1 = Decimal('66') |
| d2 = Decimal('15.32') |
| |
| #int |
| self.assertEqual(int(d1), 66) |
| self.assertEqual(int(d2), 15) |
| |
| #long |
| self.assertEqual(long(d1), 66) |
| self.assertEqual(long(d2), 15) |
| |
| #float |
| self.assertEqual(float(d1), 66) |
| self.assertEqual(float(d2), 15.32) |
| |
| def test_nan_to_float(self): |
| # Test conversions of decimal NANs to float. |
| # See http://bugs.python.org/issue15544 |
| for s in ('nan', 'nan1234', '-nan', '-nan2468'): |
| f = float(Decimal(s)) |
| self.assertTrue(math.isnan(f)) |
| |
| def test_snan_to_float(self): |
| for s in ('snan', '-snan', 'snan1357', '-snan1234'): |
| d = Decimal(s) |
| self.assertRaises(ValueError, float, d) |
| |
| def test_eval_round_trip(self): |
| |
| #with zero |
| d = Decimal( (0, (0,), 0) ) |
| self.assertEqual(d, eval(repr(d))) |
| |
| #int |
| d = Decimal( (1, (4, 5), 0) ) |
| self.assertEqual(d, eval(repr(d))) |
| |
| #float |
| d = Decimal( (0, (4, 5, 3, 4), -2) ) |
| self.assertEqual(d, eval(repr(d))) |
| |
| #weird |
| d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) ) |
| self.assertEqual(d, eval(repr(d))) |
| |
| def test_as_tuple(self): |
| |
| #with zero |
| d = Decimal(0) |
| self.assertEqual(d.as_tuple(), (0, (0,), 0) ) |
| |
| #int |
| d = Decimal(-45) |
| self.assertEqual(d.as_tuple(), (1, (4, 5), 0) ) |
| |
| #complicated string |
| d = Decimal("-4.34913534E-17") |
| self.assertEqual(d.as_tuple(), (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) ) |
| |
| #inf |
| d = Decimal("Infinity") |
| self.assertEqual(d.as_tuple(), (0, (0,), 'F') ) |
| |
| #leading zeros in coefficient should be stripped |
| d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), -2) ) |
| self.assertEqual(d.as_tuple(), (0, (4, 0, 5, 3, 4), -2) ) |
| d = Decimal( (1, (0, 0, 0), 37) ) |
| self.assertEqual(d.as_tuple(), (1, (0,), 37)) |
| d = Decimal( (1, (), 37) ) |
| self.assertEqual(d.as_tuple(), (1, (0,), 37)) |
| |
| #leading zeros in NaN diagnostic info should be stripped |
| d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), 'n') ) |
| self.assertEqual(d.as_tuple(), (0, (4, 0, 5, 3, 4), 'n') ) |
| d = Decimal( (1, (0, 0, 0), 'N') ) |
| self.assertEqual(d.as_tuple(), (1, (), 'N') ) |
| d = Decimal( (1, (), 'n') ) |
| self.assertEqual(d.as_tuple(), (1, (), 'n') ) |
| |
| #coefficient in infinity should be ignored |
| d = Decimal( (0, (4, 5, 3, 4), 'F') ) |
| self.assertEqual(d.as_tuple(), (0, (0,), 'F')) |
| d = Decimal( (1, (0, 2, 7, 1), 'F') ) |
| self.assertEqual(d.as_tuple(), (1, (0,), 'F')) |
| |
| def test_immutability_operations(self): |
| # Do operations and check that it didn't change change internal objects. |
| |
| d1 = Decimal('-25e55') |
| b1 = Decimal('-25e55') |
| d2 = Decimal('33e+33') |
| b2 = Decimal('33e+33') |
| |
| def checkSameDec(operation, useOther=False): |
| if useOther: |
| eval("d1." + operation + "(d2)") |
| self.assertEqual(d1._sign, b1._sign) |
| self.assertEqual(d1._int, b1._int) |
| self.assertEqual(d1._exp, b1._exp) |
| self.assertEqual(d2._sign, b2._sign) |
| self.assertEqual(d2._int, b2._int) |
| self.assertEqual(d2._exp, b2._exp) |
| else: |
| eval("d1." + operation + "()") |
| self.assertEqual(d1._sign, b1._sign) |
| self.assertEqual(d1._int, b1._int) |
| self.assertEqual(d1._exp, b1._exp) |
| return |
| |
| Decimal(d1) |
| self.assertEqual(d1._sign, b1._sign) |
| self.assertEqual(d1._int, b1._int) |
| self.assertEqual(d1._exp, b1._exp) |
| |
| checkSameDec("__abs__") |
| checkSameDec("__add__", True) |
| checkSameDec("__div__", True) |
| checkSameDec("__divmod__", True) |
| checkSameDec("__eq__", True) |
| checkSameDec("__ne__", True) |
| checkSameDec("__le__", True) |
| checkSameDec("__lt__", True) |
| checkSameDec("__ge__", True) |
| checkSameDec("__gt__", True) |
| checkSameDec("__float__") |
| checkSameDec("__floordiv__", True) |
| checkSameDec("__hash__") |
| checkSameDec("__int__") |
| checkSameDec("__trunc__") |
| checkSameDec("__long__") |
| checkSameDec("__mod__", True) |
| checkSameDec("__mul__", True) |
| checkSameDec("__neg__") |
| checkSameDec("__nonzero__") |
| checkSameDec("__pos__") |
| checkSameDec("__pow__", True) |
| checkSameDec("__radd__", True) |
| checkSameDec("__rdiv__", True) |
| checkSameDec("__rdivmod__", True) |
| checkSameDec("__repr__") |
| checkSameDec("__rfloordiv__", True) |
| checkSameDec("__rmod__", True) |
| checkSameDec("__rmul__", True) |
| checkSameDec("__rpow__", True) |
| checkSameDec("__rsub__", True) |
| checkSameDec("__str__") |
| checkSameDec("__sub__", True) |
| checkSameDec("__truediv__", True) |
| checkSameDec("adjusted") |
| checkSameDec("as_tuple") |
| checkSameDec("compare", True) |
| checkSameDec("max", True) |
| checkSameDec("min", True) |
| checkSameDec("normalize") |
| checkSameDec("quantize", True) |
| checkSameDec("remainder_near", True) |
| checkSameDec("same_quantum", True) |
| checkSameDec("sqrt") |
| checkSameDec("to_eng_string") |
| checkSameDec("to_integral") |
| |
| def test_subclassing(self): |
| # Different behaviours when subclassing Decimal |
| |
| class MyDecimal(Decimal): |
| pass |
| |
| d1 = MyDecimal(1) |
| d2 = MyDecimal(2) |
| d = d1 + d2 |
| self.assertIs(type(d), Decimal) |
| |
| d = d1.max(d2) |
| self.assertIs(type(d), Decimal) |
| |
| def test_implicit_context(self): |
| # Check results when context given implicitly. (Issue 2478) |
| c = getcontext() |
| self.assertEqual(str(Decimal(0).sqrt()), |
| str(c.sqrt(Decimal(0)))) |
| |
| def test_conversions_from_int(self): |
| # Check that methods taking a second Decimal argument will |
| # always accept an integer in place of a Decimal. |
| self.assertEqual(Decimal(4).compare(3), |
| Decimal(4).compare(Decimal(3))) |
| self.assertEqual(Decimal(4).compare_signal(3), |
| Decimal(4).compare_signal(Decimal(3))) |
| self.assertEqual(Decimal(4).compare_total(3), |
| Decimal(4).compare_total(Decimal(3))) |
| self.assertEqual(Decimal(4).compare_total_mag(3), |
| Decimal(4).compare_total_mag(Decimal(3))) |
| self.assertEqual(Decimal(10101).logical_and(1001), |
| Decimal(10101).logical_and(Decimal(1001))) |
| self.assertEqual(Decimal(10101).logical_or(1001), |
| Decimal(10101).logical_or(Decimal(1001))) |
| self.assertEqual(Decimal(10101).logical_xor(1001), |
| Decimal(10101).logical_xor(Decimal(1001))) |
| self.assertEqual(Decimal(567).max(123), |
| Decimal(567).max(Decimal(123))) |
| self.assertEqual(Decimal(567).max_mag(123), |
| Decimal(567).max_mag(Decimal(123))) |
| self.assertEqual(Decimal(567).min(123), |
| Decimal(567).min(Decimal(123))) |
| self.assertEqual(Decimal(567).min_mag(123), |
| Decimal(567).min_mag(Decimal(123))) |
| self.assertEqual(Decimal(567).next_toward(123), |
| Decimal(567).next_toward(Decimal(123))) |
| self.assertEqual(Decimal(1234).quantize(100), |
| Decimal(1234).quantize(Decimal(100))) |
| self.assertEqual(Decimal(768).remainder_near(1234), |
| Decimal(768).remainder_near(Decimal(1234))) |
| self.assertEqual(Decimal(123).rotate(1), |
| Decimal(123).rotate(Decimal(1))) |
| self.assertEqual(Decimal(1234).same_quantum(1000), |
| Decimal(1234).same_quantum(Decimal(1000))) |
| self.assertEqual(Decimal('9.123').scaleb(-100), |
| Decimal('9.123').scaleb(Decimal(-100))) |
| self.assertEqual(Decimal(456).shift(-1), |
| Decimal(456).shift(Decimal(-1))) |
| |
| self.assertEqual(Decimal(-12).fma(Decimal(45), 67), |
| Decimal(-12).fma(Decimal(45), Decimal(67))) |
| self.assertEqual(Decimal(-12).fma(45, 67), |
| Decimal(-12).fma(Decimal(45), Decimal(67))) |
| self.assertEqual(Decimal(-12).fma(45, Decimal(67)), |
| Decimal(-12).fma(Decimal(45), Decimal(67))) |
| |
| |
| class DecimalPythonAPItests(unittest.TestCase): |
| |
| def test_abc(self): |
| self.assertTrue(issubclass(Decimal, numbers.Number)) |
| self.assertFalse(issubclass(Decimal, numbers.Real)) |
| self.assertIsInstance(Decimal(0), numbers.Number) |
| self.assertNotIsInstance(Decimal(0), numbers.Real) |
| |
| def test_pickle(self): |
| d = Decimal('-3.141590000') |
| p = pickle.dumps(d) |
| e = pickle.loads(p) |
| self.assertEqual(d, e) |
| |
| def test_int(self): |
| for x in range(-250, 250): |
| s = '%0.2f' % (x / 100.0) |
| # should work the same as for floats |
| self.assertEqual(int(Decimal(s)), int(float(s))) |
| # should work the same as to_integral in the ROUND_DOWN mode |
| d = Decimal(s) |
| r = d.to_integral(ROUND_DOWN) |
| self.assertEqual(Decimal(int(d)), r) |
| |
| self.assertRaises(ValueError, int, Decimal('-nan')) |
| self.assertRaises(ValueError, int, Decimal('snan')) |
| self.assertRaises(OverflowError, int, Decimal('inf')) |
| self.assertRaises(OverflowError, int, Decimal('-inf')) |
| |
| self.assertRaises(ValueError, long, Decimal('-nan')) |
| self.assertRaises(ValueError, long, Decimal('snan')) |
| self.assertRaises(OverflowError, long, Decimal('inf')) |
| self.assertRaises(OverflowError, long, Decimal('-inf')) |
| |
| def test_trunc(self): |
| for x in range(-250, 250): |
| s = '%0.2f' % (x / 100.0) |
| # should work the same as for floats |
| self.assertEqual(int(Decimal(s)), int(float(s))) |
| # should work the same as to_integral in the ROUND_DOWN mode |
| d = Decimal(s) |
| r = d.to_integral(ROUND_DOWN) |
| self.assertEqual(Decimal(math.trunc(d)), r) |
| |
| def test_from_float(self): |
| |
| class MyDecimal(Decimal): |
| pass |
| |
| r = MyDecimal.from_float(0.1) |
| self.assertEqual(type(r), MyDecimal) |
| self.assertEqual(str(r), |
| '0.1000000000000000055511151231257827021181583404541015625') |
| bigint = 12345678901234567890123456789 |
| self.assertEqual(MyDecimal.from_float(bigint), MyDecimal(bigint)) |
| self.assertTrue(MyDecimal.from_float(float('nan')).is_qnan()) |
| self.assertTrue(MyDecimal.from_float(float('inf')).is_infinite()) |
| self.assertTrue(MyDecimal.from_float(float('-inf')).is_infinite()) |
| self.assertEqual(str(MyDecimal.from_float(float('nan'))), |
| str(Decimal('NaN'))) |
| self.assertEqual(str(MyDecimal.from_float(float('inf'))), |
| str(Decimal('Infinity'))) |
| self.assertEqual(str(MyDecimal.from_float(float('-inf'))), |
| str(Decimal('-Infinity'))) |
| self.assertRaises(TypeError, MyDecimal.from_float, 'abc') |
| for i in range(200): |
| x = random.expovariate(0.01) * (random.random() * 2.0 - 1.0) |
| self.assertEqual(x, float(MyDecimal.from_float(x))) # roundtrip |
| |
| def test_create_decimal_from_float(self): |
| context = Context(prec=5, rounding=ROUND_DOWN) |
| self.assertEqual( |
| context.create_decimal_from_float(math.pi), |
| Decimal('3.1415') |
| ) |
| context = Context(prec=5, rounding=ROUND_UP) |
| self.assertEqual( |
| context.create_decimal_from_float(math.pi), |
| Decimal('3.1416') |
| ) |
| context = Context(prec=5, traps=[Inexact]) |
| self.assertRaises( |
| Inexact, |
| context.create_decimal_from_float, |
| math.pi |
| ) |
| self.assertEqual(repr(context.create_decimal_from_float(-0.0)), |
| "Decimal('-0')") |
| self.assertEqual(repr(context.create_decimal_from_float(1.0)), |
| "Decimal('1')") |
| self.assertEqual(repr(context.create_decimal_from_float(10)), |
| "Decimal('10')") |
| |
| class ContextAPItests(unittest.TestCase): |
| |
| def test_pickle(self): |
| c = Context() |
| e = pickle.loads(pickle.dumps(c)) |
| for k in vars(c): |
| v1 = vars(c)[k] |
| v2 = vars(e)[k] |
| self.assertEqual(v1, v2) |
| |
| def test_equality_with_other_types(self): |
| self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}]) |
| self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}]) |
| |
| def test_copy(self): |
| # All copies should be deep |
| c = Context() |
| d = c.copy() |
| self.assertNotEqual(id(c), id(d)) |
| self.assertNotEqual(id(c.flags), id(d.flags)) |
| self.assertNotEqual(id(c.traps), id(d.traps)) |
| |
| def test_abs(self): |
| c = Context() |
| d = c.abs(Decimal(-1)) |
| self.assertEqual(c.abs(-1), d) |
| self.assertRaises(TypeError, c.abs, '-1') |
| |
| def test_add(self): |
| c = Context() |
| d = c.add(Decimal(1), Decimal(1)) |
| self.assertEqual(c.add(1, 1), d) |
| self.assertEqual(c.add(Decimal(1), 1), d) |
| self.assertEqual(c.add(1, Decimal(1)), d) |
| self.assertRaises(TypeError, c.add, '1', 1) |
| self.assertRaises(TypeError, c.add, 1, '1') |
| |
| def test_compare(self): |
| c = Context() |
| d = c.compare(Decimal(1), Decimal(1)) |
| self.assertEqual(c.compare(1, 1), d) |
| self.assertEqual(c.compare(Decimal(1), 1), d) |
| self.assertEqual(c.compare(1, Decimal(1)), d) |
| self.assertRaises(TypeError, c.compare, '1', 1) |
| self.assertRaises(TypeError, c.compare, 1, '1') |
| |
| def test_compare_signal(self): |
| c = Context() |
| d = c.compare_signal(Decimal(1), Decimal(1)) |
| self.assertEqual(c.compare_signal(1, 1), d) |
| self.assertEqual(c.compare_signal(Decimal(1), 1), d) |
| self.assertEqual(c.compare_signal(1, Decimal(1)), d) |
| self.assertRaises(TypeError, c.compare_signal, '1', 1) |
| self.assertRaises(TypeError, c.compare_signal, 1, '1') |
| |
| def test_compare_total(self): |
| c = Context() |
| d = c.compare_total(Decimal(1), Decimal(1)) |
| self.assertEqual(c.compare_total(1, 1), d) |
| self.assertEqual(c.compare_total(Decimal(1), 1), d) |
| self.assertEqual(c.compare_total(1, Decimal(1)), d) |
| self.assertRaises(TypeError, c.compare_total, '1', 1) |
| self.assertRaises(TypeError, c.compare_total, 1, '1') |
| |
| def test_compare_total_mag(self): |
| c = Context() |
| d = c.compare_total_mag(Decimal(1), Decimal(1)) |
| self.assertEqual(c.compare_total_mag(1, 1), d) |
| self.assertEqual(c.compare_total_mag(Decimal(1), 1), d) |
| self.assertEqual(c.compare_total_mag(1, Decimal(1)), d) |
| self.assertRaises(TypeError, c.compare_total_mag, '1', 1) |
| self.assertRaises(TypeError, c.compare_total_mag, 1, '1') |
| |
| def test_copy_abs(self): |
| c = Context() |
| d = c.copy_abs(Decimal(-1)) |
| self.assertEqual(c.copy_abs(-1), d) |
| self.assertRaises(TypeError, c.copy_abs, '-1') |
| |
| def test_copy_decimal(self): |
| c = Context() |
| d = c.copy_decimal(Decimal(-1)) |
| self.assertEqual(c.copy_decimal(-1), d) |
| self.assertRaises(TypeError, c.copy_decimal, '-1') |
| |
| def test_copy_negate(self): |
| c = Context() |
| d = c.copy_negate(Decimal(-1)) |
| self.assertEqual(c.copy_negate(-1), d) |
| self.assertRaises(TypeError, c.copy_negate, '-1') |
| |
| def test_copy_sign(self): |
| c = Context() |
| d = c.copy_sign(Decimal(1), Decimal(-2)) |
| self.assertEqual(c.copy_sign(1, -2), d) |
| self.assertEqual(c.copy_sign(Decimal(1), -2), d) |
| self.assertEqual(c.copy_sign(1, Decimal(-2)), d) |
| self.assertRaises(TypeError, c.copy_sign, '1', -2) |
| self.assertRaises(TypeError, c.copy_sign, 1, '-2') |
| |
| def test_divide(self): |
| c = Context() |
| d = c.divide(Decimal(1), Decimal(2)) |
| self.assertEqual(c.divide(1, 2), d) |
| self.assertEqual(c.divide(Decimal(1), 2), d) |
| self.assertEqual(c.divide(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.divide, '1', 2) |
| self.assertRaises(TypeError, c.divide, 1, '2') |
| |
| def test_divide_int(self): |
| c = Context() |
| d = c.divide_int(Decimal(1), Decimal(2)) |
| self.assertEqual(c.divide_int(1, 2), d) |
| self.assertEqual(c.divide_int(Decimal(1), 2), d) |
| self.assertEqual(c.divide_int(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.divide_int, '1', 2) |
| self.assertRaises(TypeError, c.divide_int, 1, '2') |
| |
| def test_divmod(self): |
| c = Context() |
| d = c.divmod(Decimal(1), Decimal(2)) |
| self.assertEqual(c.divmod(1, 2), d) |
| self.assertEqual(c.divmod(Decimal(1), 2), d) |
| self.assertEqual(c.divmod(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.divmod, '1', 2) |
| self.assertRaises(TypeError, c.divmod, 1, '2') |
| |
| def test_exp(self): |
| c = Context() |
| d = c.exp(Decimal(10)) |
| self.assertEqual(c.exp(10), d) |
| self.assertRaises(TypeError, c.exp, '10') |
| |
| def test_fma(self): |
| c = Context() |
| d = c.fma(Decimal(2), Decimal(3), Decimal(4)) |
| self.assertEqual(c.fma(2, 3, 4), d) |
| self.assertEqual(c.fma(Decimal(2), 3, 4), d) |
| self.assertEqual(c.fma(2, Decimal(3), 4), d) |
| self.assertEqual(c.fma(2, 3, Decimal(4)), d) |
| self.assertEqual(c.fma(Decimal(2), Decimal(3), 4), d) |
| self.assertRaises(TypeError, c.fma, '2', 3, 4) |
| self.assertRaises(TypeError, c.fma, 2, '3', 4) |
| self.assertRaises(TypeError, c.fma, 2, 3, '4') |
| |
| def test_is_finite(self): |
| c = Context() |
| d = c.is_finite(Decimal(10)) |
| self.assertEqual(c.is_finite(10), d) |
| self.assertRaises(TypeError, c.is_finite, '10') |
| |
| def test_is_infinite(self): |
| c = Context() |
| d = c.is_infinite(Decimal(10)) |
| self.assertEqual(c.is_infinite(10), d) |
| self.assertRaises(TypeError, c.is_infinite, '10') |
| |
| def test_is_nan(self): |
| c = Context() |
| d = c.is_nan(Decimal(10)) |
| self.assertEqual(c.is_nan(10), d) |
| self.assertRaises(TypeError, c.is_nan, '10') |
| |
| def test_is_normal(self): |
| c = Context() |
| d = c.is_normal(Decimal(10)) |
| self.assertEqual(c.is_normal(10), d) |
| self.assertRaises(TypeError, c.is_normal, '10') |
| |
| def test_is_qnan(self): |
| c = Context() |
| d = c.is_qnan(Decimal(10)) |
| self.assertEqual(c.is_qnan(10), d) |
| self.assertRaises(TypeError, c.is_qnan, '10') |
| |
| def test_is_signed(self): |
| c = Context() |
| d = c.is_signed(Decimal(10)) |
| self.assertEqual(c.is_signed(10), d) |
| self.assertRaises(TypeError, c.is_signed, '10') |
| |
| def test_is_snan(self): |
| c = Context() |
| d = c.is_snan(Decimal(10)) |
| self.assertEqual(c.is_snan(10), d) |
| self.assertRaises(TypeError, c.is_snan, '10') |
| |
| def test_is_subnormal(self): |
| c = Context() |
| d = c.is_subnormal(Decimal(10)) |
| self.assertEqual(c.is_subnormal(10), d) |
| self.assertRaises(TypeError, c.is_subnormal, '10') |
| |
| def test_is_zero(self): |
| c = Context() |
| d = c.is_zero(Decimal(10)) |
| self.assertEqual(c.is_zero(10), d) |
| self.assertRaises(TypeError, c.is_zero, '10') |
| |
| def test_ln(self): |
| c = Context() |
| d = c.ln(Decimal(10)) |
| self.assertEqual(c.ln(10), d) |
| self.assertRaises(TypeError, c.ln, '10') |
| |
| def test_log10(self): |
| c = Context() |
| d = c.log10(Decimal(10)) |
| self.assertEqual(c.log10(10), d) |
| self.assertRaises(TypeError, c.log10, '10') |
| |
| def test_logb(self): |
| c = Context() |
| d = c.logb(Decimal(10)) |
| self.assertEqual(c.logb(10), d) |
| self.assertRaises(TypeError, c.logb, '10') |
| |
| def test_logical_and(self): |
| c = Context() |
| d = c.logical_and(Decimal(1), Decimal(1)) |
| self.assertEqual(c.logical_and(1, 1), d) |
| self.assertEqual(c.logical_and(Decimal(1), 1), d) |
| self.assertEqual(c.logical_and(1, Decimal(1)), d) |
| self.assertRaises(TypeError, c.logical_and, '1', 1) |
| self.assertRaises(TypeError, c.logical_and, 1, '1') |
| |
| def test_logical_invert(self): |
| c = Context() |
| d = c.logical_invert(Decimal(1000)) |
| self.assertEqual(c.logical_invert(1000), d) |
| self.assertRaises(TypeError, c.logical_invert, '1000') |
| |
| def test_logical_or(self): |
| c = Context() |
| d = c.logical_or(Decimal(1), Decimal(1)) |
| self.assertEqual(c.logical_or(1, 1), d) |
| self.assertEqual(c.logical_or(Decimal(1), 1), d) |
| self.assertEqual(c.logical_or(1, Decimal(1)), d) |
| self.assertRaises(TypeError, c.logical_or, '1', 1) |
| self.assertRaises(TypeError, c.logical_or, 1, '1') |
| |
| def test_logical_xor(self): |
| c = Context() |
| d = c.logical_xor(Decimal(1), Decimal(1)) |
| self.assertEqual(c.logical_xor(1, 1), d) |
| self.assertEqual(c.logical_xor(Decimal(1), 1), d) |
| self.assertEqual(c.logical_xor(1, Decimal(1)), d) |
| self.assertRaises(TypeError, c.logical_xor, '1', 1) |
| self.assertRaises(TypeError, c.logical_xor, 1, '1') |
| |
| def test_max(self): |
| c = Context() |
| d = c.max(Decimal(1), Decimal(2)) |
| self.assertEqual(c.max(1, 2), d) |
| self.assertEqual(c.max(Decimal(1), 2), d) |
| self.assertEqual(c.max(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.max, '1', 2) |
| self.assertRaises(TypeError, c.max, 1, '2') |
| |
| def test_max_mag(self): |
| c = Context() |
| d = c.max_mag(Decimal(1), Decimal(2)) |
| self.assertEqual(c.max_mag(1, 2), d) |
| self.assertEqual(c.max_mag(Decimal(1), 2), d) |
| self.assertEqual(c.max_mag(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.max_mag, '1', 2) |
| self.assertRaises(TypeError, c.max_mag, 1, '2') |
| |
| def test_min(self): |
| c = Context() |
| d = c.min(Decimal(1), Decimal(2)) |
| self.assertEqual(c.min(1, 2), d) |
| self.assertEqual(c.min(Decimal(1), 2), d) |
| self.assertEqual(c.min(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.min, '1', 2) |
| self.assertRaises(TypeError, c.min, 1, '2') |
| |
| def test_min_mag(self): |
| c = Context() |
| d = c.min_mag(Decimal(1), Decimal(2)) |
| self.assertEqual(c.min_mag(1, 2), d) |
| self.assertEqual(c.min_mag(Decimal(1), 2), d) |
| self.assertEqual(c.min_mag(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.min_mag, '1', 2) |
| self.assertRaises(TypeError, c.min_mag, 1, '2') |
| |
| def test_minus(self): |
| c = Context() |
| d = c.minus(Decimal(10)) |
| self.assertEqual(c.minus(10), d) |
| self.assertRaises(TypeError, c.minus, '10') |
| |
| def test_multiply(self): |
| c = Context() |
| d = c.multiply(Decimal(1), Decimal(2)) |
| self.assertEqual(c.multiply(1, 2), d) |
| self.assertEqual(c.multiply(Decimal(1), 2), d) |
| self.assertEqual(c.multiply(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.multiply, '1', 2) |
| self.assertRaises(TypeError, c.multiply, 1, '2') |
| |
| def test_next_minus(self): |
| c = Context() |
| d = c.next_minus(Decimal(10)) |
| self.assertEqual(c.next_minus(10), d) |
| self.assertRaises(TypeError, c.next_minus, '10') |
| |
| def test_next_plus(self): |
| c = Context() |
| d = c.next_plus(Decimal(10)) |
| self.assertEqual(c.next_plus(10), d) |
| self.assertRaises(TypeError, c.next_plus, '10') |
| |
| def test_next_toward(self): |
| c = Context() |
| d = c.next_toward(Decimal(1), Decimal(2)) |
| self.assertEqual(c.next_toward(1, 2), d) |
| self.assertEqual(c.next_toward(Decimal(1), 2), d) |
| self.assertEqual(c.next_toward(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.next_toward, '1', 2) |
| self.assertRaises(TypeError, c.next_toward, 1, '2') |
| |
| def test_normalize(self): |
| c = Context() |
| d = c.normalize(Decimal(10)) |
| self.assertEqual(c.normalize(10), d) |
| self.assertRaises(TypeError, c.normalize, '10') |
| |
| def test_number_class(self): |
| c = Context() |
| self.assertEqual(c.number_class(123), c.number_class(Decimal(123))) |
| self.assertEqual(c.number_class(0), c.number_class(Decimal(0))) |
| self.assertEqual(c.number_class(-45), c.number_class(Decimal(-45))) |
| |
| def test_power(self): |
| c = Context() |
| d = c.power(Decimal(1), Decimal(4), Decimal(2)) |
| self.assertEqual(c.power(1, 4, 2), d) |
| self.assertEqual(c.power(Decimal(1), 4, 2), d) |
| self.assertEqual(c.power(1, Decimal(4), 2), d) |
| self.assertEqual(c.power(1, 4, Decimal(2)), d) |
| self.assertEqual(c.power(Decimal(1), Decimal(4), 2), d) |
| self.assertRaises(TypeError, c.power, '1', 4, 2) |
| self.assertRaises(TypeError, c.power, 1, '4', 2) |
| self.assertRaises(TypeError, c.power, 1, 4, '2') |
| |
| def test_plus(self): |
| c = Context() |
| d = c.plus(Decimal(10)) |
| self.assertEqual(c.plus(10), d) |
| self.assertRaises(TypeError, c.plus, '10') |
| |
| def test_quantize(self): |
| c = Context() |
| d = c.quantize(Decimal(1), Decimal(2)) |
| self.assertEqual(c.quantize(1, 2), d) |
| self.assertEqual(c.quantize(Decimal(1), 2), d) |
| self.assertEqual(c.quantize(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.quantize, '1', 2) |
| self.assertRaises(TypeError, c.quantize, 1, '2') |
| |
| def test_remainder(self): |
| c = Context() |
| d = c.remainder(Decimal(1), Decimal(2)) |
| self.assertEqual(c.remainder(1, 2), d) |
| self.assertEqual(c.remainder(Decimal(1), 2), d) |
| self.assertEqual(c.remainder(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.remainder, '1', 2) |
| self.assertRaises(TypeError, c.remainder, 1, '2') |
| |
| def test_remainder_near(self): |
| c = Context() |
| d = c.remainder_near(Decimal(1), Decimal(2)) |
| self.assertEqual(c.remainder_near(1, 2), d) |
| self.assertEqual(c.remainder_near(Decimal(1), 2), d) |
| self.assertEqual(c.remainder_near(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.remainder_near, '1', 2) |
| self.assertRaises(TypeError, c.remainder_near, 1, '2') |
| |
| def test_rotate(self): |
| c = Context() |
| d = c.rotate(Decimal(1), Decimal(2)) |
| self.assertEqual(c.rotate(1, 2), d) |
| self.assertEqual(c.rotate(Decimal(1), 2), d) |
| self.assertEqual(c.rotate(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.rotate, '1', 2) |
| self.assertRaises(TypeError, c.rotate, 1, '2') |
| |
| def test_sqrt(self): |
| c = Context() |
| d = c.sqrt(Decimal(10)) |
| self.assertEqual(c.sqrt(10), d) |
| self.assertRaises(TypeError, c.sqrt, '10') |
| |
| def test_same_quantum(self): |
| c = Context() |
| d = c.same_quantum(Decimal(1), Decimal(2)) |
| self.assertEqual(c.same_quantum(1, 2), d) |
| self.assertEqual(c.same_quantum(Decimal(1), 2), d) |
| self.assertEqual(c.same_quantum(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.same_quantum, '1', 2) |
| self.assertRaises(TypeError, c.same_quantum, 1, '2') |
| |
| def test_scaleb(self): |
| c = Context() |
| d = c.scaleb(Decimal(1), Decimal(2)) |
| self.assertEqual(c.scaleb(1, 2), d) |
| self.assertEqual(c.scaleb(Decimal(1), 2), d) |
| self.assertEqual(c.scaleb(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.scaleb, '1', 2) |
| self.assertRaises(TypeError, c.scaleb, 1, '2') |
| |
| def test_shift(self): |
| c = Context() |
| d = c.shift(Decimal(1), Decimal(2)) |
| self.assertEqual(c.shift(1, 2), d) |
| self.assertEqual(c.shift(Decimal(1), 2), d) |
| self.assertEqual(c.shift(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.shift, '1', 2) |
| self.assertRaises(TypeError, c.shift, 1, '2') |
| |
| def test_subtract(self): |
| c = Context() |
| d = c.subtract(Decimal(1), Decimal(2)) |
| self.assertEqual(c.subtract(1, 2), d) |
| self.assertEqual(c.subtract(Decimal(1), 2), d) |
| self.assertEqual(c.subtract(1, Decimal(2)), d) |
| self.assertRaises(TypeError, c.subtract, '1', 2) |
| self.assertRaises(TypeError, c.subtract, 1, '2') |
| |
| def test_to_eng_string(self): |
| c = Context() |
| d = c.to_eng_string(Decimal(10)) |
| self.assertEqual(c.to_eng_string(10), d) |
| self.assertRaises(TypeError, c.to_eng_string, '10') |
| |
| def test_to_sci_string(self): |
| c = Context() |
| d = c.to_sci_string(Decimal(10)) |
| self.assertEqual(c.to_sci_string(10), d) |
| self.assertRaises(TypeError, c.to_sci_string, '10') |
| |
| def test_to_integral_exact(self): |
| c = Context() |
| d = c.to_integral_exact(Decimal(10)) |
| self.assertEqual(c.to_integral_exact(10), d) |
| self.assertRaises(TypeError, c.to_integral_exact, '10') |
| |
| def test_to_integral_value(self): |
| c = Context() |
| d = c.to_integral_value(Decimal(10)) |
| self.assertEqual(c.to_integral_value(10), d) |
| self.assertRaises(TypeError, c.to_integral_value, '10') |
| |
| class WithStatementTest(unittest.TestCase): |
| # Can't do these as docstrings until Python 2.6 |
| # as doctest can't handle __future__ statements |
| |
| def test_localcontext(self): |
| # Use a copy of the current context in the block |
| orig_ctx = getcontext() |
| with localcontext() as enter_ctx: |
| set_ctx = getcontext() |
| final_ctx = getcontext() |
| self.assertIs(orig_ctx, final_ctx, 'did not restore context correctly') |
| self.assertIsNot(orig_ctx, set_ctx, 'did not copy the context') |
| self.assertIs(set_ctx, enter_ctx, '__enter__ returned wrong context') |
| |
| def test_localcontextarg(self): |
| # Use a copy of the supplied context in the block |
| orig_ctx = getcontext() |
| new_ctx = Context(prec=42) |
| with localcontext(new_ctx) as enter_ctx: |
| set_ctx = getcontext() |
| final_ctx = getcontext() |
| self.assertIs(orig_ctx, final_ctx, 'did not restore context correctly') |
| self.assertEqual(set_ctx.prec, new_ctx.prec, 'did not set correct context') |
| self.assertIsNot(new_ctx, set_ctx, 'did not copy the context') |
| self.assertIs(set_ctx, enter_ctx, '__enter__ returned wrong context') |
| |
| class ContextFlags(unittest.TestCase): |
| def test_flags_irrelevant(self): |
| # check that the result (numeric result + flags raised) of an |
| # arithmetic operation doesn't depend on the current flags |
| |
| context = Context(prec=9, Emin = -999999999, Emax = 999999999, |
| rounding=ROUND_HALF_EVEN, traps=[], flags=[]) |
| |
| # operations that raise various flags, in the form (function, arglist) |
| operations = [ |
| (context._apply, [Decimal("100E-1000000009")]), |
| (context.sqrt, [Decimal(2)]), |
| (context.add, [Decimal("1.23456789"), Decimal("9.87654321")]), |
| (context.multiply, [Decimal("1.23456789"), Decimal("9.87654321")]), |
| (context.subtract, [Decimal("1.23456789"), Decimal("9.87654321")]), |
| ] |
| |
| # try various flags individually, then a whole lot at once |
| flagsets = [[Inexact], [Rounded], [Underflow], [Clamped], [Subnormal], |
| [Inexact, Rounded, Underflow, Clamped, Subnormal]] |
| |
| for fn, args in operations: |
| # find answer and flags raised using a clean context |
| context.clear_flags() |
| ans = fn(*args) |
| flags = [k for k, v in context.flags.items() if v] |
| |
| for extra_flags in flagsets: |
| # set flags, before calling operation |
| context.clear_flags() |
| for flag in extra_flags: |
| context._raise_error(flag) |
| new_ans = fn(*args) |
| |
| # flags that we expect to be set after the operation |
| expected_flags = list(flags) |
| for flag in extra_flags: |
| if flag not in expected_flags: |
| expected_flags.append(flag) |
| |
| # flags we actually got |
| new_flags = [k for k,v in context.flags.items() if v] |
| |
| self.assertEqual(ans, new_ans, |
| "operation produces different answers depending on flags set: " + |
| "expected %s, got %s." % (ans, new_ans)) |
| self.assertItemsEqual(new_flags, expected_flags, |
| "operation raises different flags depending on flags set: " + |
| "expected %s, got %s" % (expected_flags, new_flags)) |
| |
| def test_main(arith=False, verbose=None, todo_tests=None, debug=None): |
| """ Execute the tests. |
| |
| Runs all arithmetic tests if arith is True or if the "decimal" resource |
| is enabled in regrtest.py |
| """ |
| |
| init() |
| global TEST_ALL, DEBUG |
| TEST_ALL = arith or is_resource_enabled('decimal') |
| DEBUG = debug |
| |
| if todo_tests is None: |
| test_classes = [ |
| DecimalExplicitConstructionTest, |
| DecimalImplicitConstructionTest, |
| DecimalArithmeticOperatorsTest, |
| DecimalFormatTest, |
| DecimalUseOfContextTest, |
| DecimalUsabilityTest, |
| DecimalPythonAPItests, |
| ContextAPItests, |
| DecimalTest, |
| WithStatementTest, |
| ContextFlags |
| ] |
| else: |
| test_classes = [DecimalTest] |
| |
| # Dynamically build custom test definition for each file in the test |
| # directory and add the definitions to the DecimalTest class. This |
| # procedure insures that new files do not get skipped. |
| for filename in os.listdir(directory): |
| if '.decTest' not in filename or filename.startswith("."): |
| continue |
| head, tail = filename.split('.') |
| if todo_tests is not None and head not in todo_tests: |
| continue |
| tester = lambda self, f=filename: self.eval_file(directory + f) |
| setattr(DecimalTest, 'test_' + head, tester) |
| del filename, head, tail, tester |
| |
| |
| try: |
| run_unittest(*test_classes) |
| if todo_tests is None: |
| import decimal as DecimalModule |
| run_doctest(DecimalModule, verbose) |
| finally: |
| setcontext(ORIGINAL_CONTEXT) |
| |
| if __name__ == '__main__': |
| import optparse |
| p = optparse.OptionParser("test_decimal.py [--debug] [{--skip | test1 [test2 [...]]}]") |
| p.add_option('--debug', '-d', action='store_true', help='shows the test number and context before each test') |
| p.add_option('--skip', '-s', action='store_true', help='skip over 90% of the arithmetic tests') |
| (opt, args) = p.parse_args() |
| |
| if opt.skip: |
| test_main(arith=False, verbose=True) |
| elif args: |
| test_main(arith=True, verbose=True, todo_tests=args, debug=opt.debug) |
| else: |
| test_main(arith=True, verbose=True) |
