diff options
Diffstat (limited to 'lib/python2.7/test/test_decimal.py')
| -rw-r--r-- | lib/python2.7/test/test_decimal.py | 2351 |
1 files changed, 0 insertions, 2351 deletions
diff --git a/lib/python2.7/test/test_decimal.py b/lib/python2.7/test/test_decimal.py deleted file mode 100644 index 3e184ef..0000000 --- a/lib/python2.7/test/test_decimal.py +++ /dev/null @@ -1,2351 +0,0 @@ -# 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) |