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