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