mirror of
https://github.com/python/cpython.git
synced 2024-11-25 10:54:51 +08:00
e549ead826
svn+ssh://pythondev@svn.python.org/python/trunk ........ r70554 | benjamin.peterson | 2009-03-23 16:25:15 -0500 (Mon, 23 Mar 2009) | 1 line complain when there's no last exception ........ r70588 | benjamin.peterson | 2009-03-24 17:56:32 -0500 (Tue, 24 Mar 2009) | 1 line fix newline issue in test summary ........ r70589 | benjamin.peterson | 2009-03-24 18:07:07 -0500 (Tue, 24 Mar 2009) | 1 line another style nit ........ r70598 | benjamin.peterson | 2009-03-25 16:24:04 -0500 (Wed, 25 Mar 2009) | 1 line add shorthands for expected failures and unexpected success ........ r70605 | benjamin.peterson | 2009-03-26 11:32:23 -0500 (Thu, 26 Mar 2009) | 1 line remove uneeded function ........ r70611 | benjamin.peterson | 2009-03-26 13:35:37 -0500 (Thu, 26 Mar 2009) | 1 line add much better tests for python version information parsing ........ r70612 | benjamin.peterson | 2009-03-26 13:55:48 -0500 (Thu, 26 Mar 2009) | 1 line more and more implementations now support sys.subversion ........ r70613 | benjamin.peterson | 2009-03-26 13:58:30 -0500 (Thu, 26 Mar 2009) | 1 line roll old test in with new one ........ r70614 | benjamin.peterson | 2009-03-26 14:09:21 -0500 (Thu, 26 Mar 2009) | 1 line add support for PyPy ........ r70615 | benjamin.peterson | 2009-03-26 14:58:18 -0500 (Thu, 26 Mar 2009) | 5 lines add some useful utilities for skipping tests with unittest's new skipping ability most significantly apply a modified portion of the patch from #4242 with patches for skipping implementation details ........ r70616 | benjamin.peterson | 2009-03-26 15:05:50 -0500 (Thu, 26 Mar 2009) | 1 line rename TestCase.skip() to skipTest() because it causes annoying problems with trial #5571 ........ r70617 | benjamin.peterson | 2009-03-26 15:17:27 -0500 (Thu, 26 Mar 2009) | 1 line apply the second part of #4242's patch; classify all the implementation details in test_descr ........ r70618 | benjamin.peterson | 2009-03-26 15:48:25 -0500 (Thu, 26 Mar 2009) | 1 line remove test_support.TestSkipped and just use unittest.SkipTest ........ r70619 | benjamin.peterson | 2009-03-26 15:49:40 -0500 (Thu, 26 Mar 2009) | 1 line fix naming ........ r70620 | benjamin.peterson | 2009-03-26 16:10:30 -0500 (Thu, 26 Mar 2009) | 1 line fix incorrect auto-translation of TestSkipped -> unittest.SkipTest ........ r70621 | benjamin.peterson | 2009-03-26 16:11:16 -0500 (Thu, 26 Mar 2009) | 1 line must pass argument to get expected behavior ;) ........ r70623 | benjamin.peterson | 2009-03-26 16:30:10 -0500 (Thu, 26 Mar 2009) | 1 line add missing import ........ r70624 | benjamin.peterson | 2009-03-26 16:30:54 -0500 (Thu, 26 Mar 2009) | 1 line ** is required here ........ r70626 | benjamin.peterson | 2009-03-26 16:40:29 -0500 (Thu, 26 Mar 2009) | 1 line update email tests to use SkipTest ........ r70627 | benjamin.peterson | 2009-03-26 16:44:43 -0500 (Thu, 26 Mar 2009) | 1 line fix another name ........
1760 lines
59 KiB
Python
1760 lines
59 KiB
Python
# 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 glob
|
|
import math
|
|
import os, sys
|
|
import pickle, copy
|
|
import unittest
|
|
from decimal import *
|
|
import numbers
|
|
from test.support import run_unittest, run_doctest, is_resource_enabled
|
|
import random
|
|
try:
|
|
import threading
|
|
except ImportError:
|
|
threading = None
|
|
|
|
# Useful Test Constant
|
|
Signals = tuple(getcontext().flags.keys())
|
|
|
|
# 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)
|
|
|
|
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)
|
|
|
|
# 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',
|
|
)
|
|
|
|
# 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.
|
|
|
|
decNumberRestricted = ('power', 'ln', 'log10', 'exp')
|
|
DEC_MAX_MATH = 999999
|
|
def outside_decNumber_bounds(v, context):
|
|
if (context.prec > DEC_MAX_MATH or
|
|
context.Emax > DEC_MAX_MATH or
|
|
-context.Emin > DEC_MAX_MATH):
|
|
return True
|
|
if not v._is_special and v and (
|
|
v.adjusted() > DEC_MAX_MATH or
|
|
v.adjusted() < 1-2*DEC_MAX_MATH):
|
|
return True
|
|
return False
|
|
|
|
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
|
|
for line in open(file):
|
|
line = line.replace('\r\n', '').replace('\n', '')
|
|
#print line
|
|
try:
|
|
t = self.eval_line(line)
|
|
except DecimalException as exception:
|
|
#Exception raised where there shoudn'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 = (x.strip().lower() for x in 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, end=" ")
|
|
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
|
|
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 as 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)
|
|
|
|
# skip tests that are related to bounds imposed in the decNumber
|
|
# reference implementation
|
|
if fname in decNumberRestricted:
|
|
if fname == 'power':
|
|
if not (vals[1]._isinteger() and
|
|
-1999999997 <= vals[1] <= 999999999):
|
|
if outside_decNumber_bounds(vals[0], self.context) or \
|
|
outside_decNumber_bounds(vals[1], self.context):
|
|
#print "Skipping test %s" % s
|
|
return
|
|
else:
|
|
if outside_decNumber_bounds(vals[0], self.context):
|
|
#print "Skipping test %s" % s
|
|
return
|
|
|
|
|
|
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 as 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
|
|
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 as 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()
|
|
|
|
myexceptions.sort(key=repr)
|
|
theirexceptions.sort(key=repr)
|
|
|
|
self.assertEqual(result, ans,
|
|
'Incorrect answer for ' + s + ' -- got ' + result)
|
|
self.assertEqual(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')
|
|
|
|
#but alternate unicode digits should not
|
|
self.assertEqual(str(Decimal('\uff11')), 'NaN')
|
|
|
|
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_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))
|
|
|
|
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.failUnless(isinstance(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')
|
|
|
|
|
|
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__'),
|
|
('/', '__truediv__', '__rtruediv__'),
|
|
('%', '__mod__', '__rmod__'),
|
|
('//', '__floordiv__', '__rfloordiv__'),
|
|
('**', '__pow__', '__rpow__')
|
|
]
|
|
|
|
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'),
|
|
('#<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'),
|
|
]
|
|
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):
|
|
n = Decimal('NaN')
|
|
s = Decimal('sNaN')
|
|
i = Decimal('Inf')
|
|
f = Decimal('2')
|
|
for x, y in [(n, n), (n, i), (i, n), (n, f), (f, n),
|
|
(s, n), (n, s), (s, i), (i, s), (s, f), (f, s), (s, s)]:
|
|
self.assert_(x != y)
|
|
self.assert_(not (x == y))
|
|
self.assert_(not (x < y))
|
|
self.assert_(not (x <= y))
|
|
self.assert_(not (x > y))
|
|
self.assert_(not (x >= y))
|
|
|
|
# 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.failUnless(dc > da)
|
|
self.failUnless(dc >= da)
|
|
self.failUnless(da < dc)
|
|
self.failUnless(da <= dc)
|
|
self.assertEqual(da, db)
|
|
self.failUnless(da != dc)
|
|
self.failUnless(da <= db)
|
|
self.failUnless(da >= db)
|
|
|
|
#a Decimal and an int
|
|
self.failUnless(dc > 23)
|
|
self.failUnless(23 < dc)
|
|
self.assertEqual(dc, 45)
|
|
|
|
#a Decimal and uncomparable
|
|
self.assertNotEqual(da, 'ugly')
|
|
self.assertNotEqual(da, 32.7)
|
|
self.assertNotEqual(da, object())
|
|
self.assertNotEqual(da, object)
|
|
|
|
# sortable
|
|
a = list(map(Decimal, range(100)))
|
|
b = a[:]
|
|
random.shuffle(a)
|
|
a.sort()
|
|
self.assertEqual(a, b)
|
|
|
|
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))
|
|
|
|
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('NaN'))
|
|
self.assert_(hash(Decimal('Inf')))
|
|
self.assert_(hash(Decimal('-Inf')))
|
|
|
|
# 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.failUnless(min(d1,d2) is d1)
|
|
self.failUnless(min(d2,d1) is d1)
|
|
self.failUnless(max(d1,d2) is d2)
|
|
self.failUnless(max(d2,d1) is d2)
|
|
|
|
#between Decimal and long
|
|
self.failUnless(min(d1,l2) is d1)
|
|
self.failUnless(min(l2,d1) is d1)
|
|
self.failUnless(max(l1,d2) is d2)
|
|
self.failUnless(max(d2,l1) is d2)
|
|
|
|
def test_as_nonzero(self):
|
|
#as false
|
|
self.failIf(Decimal(0))
|
|
#as true
|
|
self.failUnless(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
|
|
|
|
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(int(d1), 66)
|
|
self.assertEqual(int(d2), 15)
|
|
|
|
#float
|
|
self.assertEqual(float(d1), 66)
|
|
self.assertEqual(float(d2), 15.32)
|
|
|
|
#floor
|
|
test_pairs = [
|
|
('123.00', 123),
|
|
('3.2', 3),
|
|
('3.54', 3),
|
|
('3.899', 3),
|
|
('-2.3', -3),
|
|
('-11.0', -11),
|
|
('0.0', 0),
|
|
('-0E3', 0),
|
|
]
|
|
for d, i in test_pairs:
|
|
self.assertEqual(math.floor(Decimal(d)), i)
|
|
self.assertRaises(ValueError, math.floor, Decimal('-NaN'))
|
|
self.assertRaises(ValueError, math.floor, Decimal('sNaN'))
|
|
self.assertRaises(ValueError, math.floor, Decimal('NaN123'))
|
|
self.assertRaises(OverflowError, math.floor, Decimal('Inf'))
|
|
self.assertRaises(OverflowError, math.floor, Decimal('-Inf'))
|
|
|
|
#ceiling
|
|
test_pairs = [
|
|
('123.00', 123),
|
|
('3.2', 4),
|
|
('3.54', 4),
|
|
('3.899', 4),
|
|
('-2.3', -2),
|
|
('-11.0', -11),
|
|
('0.0', 0),
|
|
('-0E3', 0),
|
|
]
|
|
for d, i in test_pairs:
|
|
self.assertEqual(math.ceil(Decimal(d)), i)
|
|
self.assertRaises(ValueError, math.ceil, Decimal('-NaN'))
|
|
self.assertRaises(ValueError, math.ceil, Decimal('sNaN'))
|
|
self.assertRaises(ValueError, math.ceil, Decimal('NaN123'))
|
|
self.assertRaises(OverflowError, math.ceil, Decimal('Inf'))
|
|
self.assertRaises(OverflowError, math.ceil, Decimal('-Inf'))
|
|
|
|
#round, single argument
|
|
test_pairs = [
|
|
('123.00', 123),
|
|
('3.2', 3),
|
|
('3.54', 4),
|
|
('3.899', 4),
|
|
('-2.3', -2),
|
|
('-11.0', -11),
|
|
('0.0', 0),
|
|
('-0E3', 0),
|
|
('-3.5', -4),
|
|
('-2.5', -2),
|
|
('-1.5', -2),
|
|
('-0.5', 0),
|
|
('0.5', 0),
|
|
('1.5', 2),
|
|
('2.5', 2),
|
|
('3.5', 4),
|
|
]
|
|
for d, i in test_pairs:
|
|
self.assertEqual(round(Decimal(d)), i)
|
|
self.assertRaises(ValueError, round, Decimal('-NaN'))
|
|
self.assertRaises(ValueError, round, Decimal('sNaN'))
|
|
self.assertRaises(ValueError, round, Decimal('NaN123'))
|
|
self.assertRaises(OverflowError, round, Decimal('Inf'))
|
|
self.assertRaises(OverflowError, round, Decimal('-Inf'))
|
|
|
|
#round, two arguments; this is essentially equivalent
|
|
#to quantize, which is already extensively tested
|
|
test_triples = [
|
|
('123.456', -4, '0E+4'),
|
|
('123.456', -3, '0E+3'),
|
|
('123.456', -2, '1E+2'),
|
|
('123.456', -1, '1.2E+2'),
|
|
('123.456', 0, '123'),
|
|
('123.456', 1, '123.5'),
|
|
('123.456', 2, '123.46'),
|
|
('123.456', 3, '123.456'),
|
|
('123.456', 4, '123.4560'),
|
|
('123.455', 2, '123.46'),
|
|
('123.445', 2, '123.44'),
|
|
('Inf', 4, 'NaN'),
|
|
('-Inf', -23, 'NaN'),
|
|
('sNaN314', 3, 'NaN314'),
|
|
]
|
|
for d, n, r in test_triples:
|
|
self.assertEqual(str(round(Decimal(d), n)), r)
|
|
|
|
|
|
|
|
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("__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("__mod__", True)
|
|
checkSameDec("__mul__", True)
|
|
checkSameDec("__neg__")
|
|
checkSameDec("__bool__")
|
|
checkSameDec("__pos__")
|
|
checkSameDec("__pow__", True)
|
|
checkSameDec("__radd__", 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.assertTrue(type(d) is Decimal)
|
|
|
|
d = d1.max(d2)
|
|
self.assertTrue(type(d) is 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))))
|
|
|
|
|
|
class DecimalPythonAPItests(unittest.TestCase):
|
|
|
|
def test_abc(self):
|
|
self.assert_(issubclass(Decimal, numbers.Number))
|
|
self.assert_(not issubclass(Decimal, numbers.Real))
|
|
self.assert_(isinstance(Decimal(0), numbers.Number))
|
|
self.assert_(not isinstance(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)
|
|
|
|
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.assert_(MyDecimal.from_float(float('nan')).is_qnan())
|
|
self.assert_(MyDecimal.from_float(float('inf')).is_infinite())
|
|
self.assert_(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.assert_(Decimal(10) in ['a', 1.0, Decimal(10), (1,2), {}])
|
|
self.assert_(Decimal(10) not in ['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))
|
|
|
|
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.assert_(orig_ctx is final_ctx, 'did not restore context correctly')
|
|
self.assert_(orig_ctx is not set_ctx, 'did not copy the context')
|
|
self.assert_(set_ctx is 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.assert_(orig_ctx is final_ctx, 'did not restore context correctly')
|
|
self.assert_(set_ctx.prec == new_ctx.prec, 'did not set correct context')
|
|
self.assert_(new_ctx is not set_ctx, 'did not copy the context')
|
|
self.assert_(set_ctx is 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)
|
|
expected_flags.sort(key=id)
|
|
|
|
# flags we actually got
|
|
new_flags = [k for k,v in context.flags.items() if v]
|
|
new_flags.sort(key=id)
|
|
|
|
self.assertEqual(ans, new_ans,
|
|
"operation produces different answers depending on flags set: " +
|
|
"expected %s, got %s." % (ans, new_ans))
|
|
self.assertEqual(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)
|