C: [C.Clamped, C.Rounded, C.Inexact, C.Subnormal, C.Underflow,

C.Overflow, C.DivisionByZero, C.InvalidOperation,

C.FloatOperation] if C else None,

P: [P.Clamped, P.Rounded, P.Inexact, P.Subnormal, P.Underflow,

P.Overflow, P.DivisionByZero, P.InvalidOperation,

P.FloatOperation]

ROUND_UP, ROUND_DOWN, ROUND_CEILING, ROUND_FLOOR,

ROUND_HALF_UP, ROUND_HALF_DOWN, ROUND_HALF_EVEN,

ROUND_05UP

if not m: return

DefaultTestContext = m.Context(

prec=9, rounding=ROUND_HALF_EVEN, traps=dict.fromkeys(Signals[m], 0)

)

"""Class which tests the Decimal class against the IBM test cases."""

def setUp(self):

self.context = self.decimal.Context()

self.readcontext = self.decimal.Context()

self.ignore_list = ['#']

# List of individual .decTest test ids that correspond to tests that

# we're skipping for one reason or another.

self.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',

])

if self.decimal == C:

# status has additional Subnormal, Underflow

self.skipped_test_ids.add('pwsx803')

self.skipped_test_ids.add('pwsx805')

# Correct rounding (skipped for decNumber, too)

self.skipped_test_ids.add('powx4302')

self.skipped_test_ids.add('powx4303')

self.skipped_test_ids.add('powx4342')

self.skipped_test_ids.add('powx4343')

# http://bugs.python.org/issue7049

self.skipped_test_ids.add('pwmx325')

self.skipped_test_ids.add('pwmx326')

# Map test directives to setter functions.

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}

# Name adapter to be able to change the Decimal and Context

# interface without changing the test files from Cowlishaw.

self.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'}

# Map test-case names to roundings.

self.RoundingDict = {'ceiling' : ROUND_CEILING,

'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}

# Map the test cases' error names to the actual errors.

self.ErrorNames = {'clamped' : self.decimal.Clamped,

'conversion_syntax' : self.decimal.InvalidOperation,

'division_by_zero' : self.decimal.DivisionByZero,

'division_impossible' : self.decimal.InvalidOperation,

'division_undefined' : self.decimal.InvalidOperation,

'inexact' : self.decimal.Inexact,

'invalid_context' : self.decimal.InvalidOperation,

'invalid_operation' : self.decimal.InvalidOperation,

'overflow' : self.decimal.Overflow,

'rounded' : self.decimal.Rounded,

'subnormal' : self.decimal.Subnormal,

'underflow' : self.decimal.Underflow}

# The following functions return True/False rather than a

# Decimal instance.

self.LogicalFunctions = ('is_canonical',

'is_finite',

'is_infinite',

'is_nan',

'is_normal',

'is_qnan',

'is_signed',

'is_snan',

'is_subnormal',

'is_zero',

'same_quantum')

def read_unlimited(self, v, context):

"""Work around the limitations of the 32-bit _decimal version. The

if self.decimal == C and self.decimal.MAX_EMAX == 425000000:

self.readcontext._unsafe_setprec(1070000000)

self.readcontext._unsafe_setemax(1070000000)

self.readcontext._unsafe_setemin(-1070000000)

return self.readcontext.create_decimal(v)

else:

return self.decimal.Decimal(v, context)

def eval_file(self, file):

global skip_expected

if skip_expected:

raise unittest.SkipTest

with open(file, encoding="utf-8") as f:

for line in f:

line = line.replace('\r\n', '').replace('\n', '')

#print line

try:

t = self.eval_line(line)

except self.decimal.DecimalException as exception:

#Exception raised where there shouldn't have been one.

self.fail('Exception "'+exception.__class__.__name__ + '" raised on line '+line)

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 = self.RoundingDict[value]

else:

try:

value = int(value)

except ValueError:

pass

funct = self.ChangeDict.get(funct, (lambda *args: None))

funct(value)

def eval_equation(self, s):

if not TEST_ALL and random.random() < 0.90:

return

self.context.clear_flags()

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 self.decimal.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 self.skipped_test_ids:

return

fname = self.NameAdapter.get(funct, funct)

if fname == 'rescale':

return

funct = getattr(self.context, fname)

vals = []

conglomerate = ''

quote = 0

theirexceptions = [self.ErrorNames[x.lower()] for x in exceptions]

for exception in Signals[self.decimal]:

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[self.decimal] 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 = self.read_unlimited(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[self.decimal] 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

# as above, but add traps cumulatively, to check precedence

ordered_errors = [e for e in OrderedSignals[self.decimal] if e in theirexceptions]

for error in ordered_errors:

self.context.traps[error] = 1

try:

funct(*vals)

except error:

pass

except Signals[self.decimal] as 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 self.LogicalFunctions:

result = str(int(eval(result))) # 'True', 'False' -> '1', '0'

except Signals[self.decimal] 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()

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))

def getexceptions(self):

return [e for e in Signals[self.decimal] if self.context.flags[e]]

def change_precision(self, prec):

if self.decimal == C and self.decimal.MAX_PREC == 425000000:

self.context._unsafe_setprec(prec)

else:

self.context.prec = prec

def change_rounding_method(self, rounding):

self.context.rounding = rounding

def change_min_exponent(self, exp):

if self.decimal == C and self.decimal.MAX_PREC == 425000000:

self.context._unsafe_setemin(exp)

else:

self.context.Emin = exp

def change_max_exponent(self, exp):

if self.decimal == C and self.decimal.MAX_PREC == 425000000:

self.context._unsafe_setemax(exp)

else:

self.context.Emax = exp

def change_clamp(self, clamp):

'''Unit tests for Explicit Construction cases of Decimal.'''

def test_explicit_empty(self):

Decimal = self.decimal.Decimal

self.assertEqual(Decimal(), Decimal("0"))

def test_explicit_from_None(self):

Decimal = self.decimal.Decimal

self.assertRaises(TypeError, Decimal, None)

def test_explicit_from_int(self):

Decimal = self.decimal.Decimal

#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')

# single word longs

for n in range(0, 32):

for sign in (-1, 1):

for x in range(-5, 5):

i = sign * (2**n + x)

d = Decimal(i)

self.assertEqual(str(d), str(i))

def test_explicit_from_string(self):

Decimal = self.decimal.Decimal

InvalidOperation = self.decimal.InvalidOperation

localcontext = self.decimal.localcontext

#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')

self.assertEqual(str(Decimal(" 3.45679 ")), '3.45679')

# underscores

self.assertEqual(str(Decimal('1_3.3e4_0')), '1.33E+41')

self.assertEqual(str(Decimal('1_0_0_0')), '1000')

# unicode whitespace

for lead in ["", ' ', '\u00a0', '\u205f']:

for trail in ["", ' ', '\u00a0', '\u205f']:

self.assertEqual(str(Decimal(lead + '9.311E+28' + trail)),

'9.311E+28')

with localcontext() as c:

c.traps[InvalidOperation] = True

# Invalid string

self.assertRaises(InvalidOperation, Decimal, "xyz")

# Two arguments max

self.assertRaises(TypeError, Decimal, "1234", "x", "y")

# space within the numeric part

self.assertRaises(InvalidOperation, Decimal, "1\u00a02\u00a03")

self.assertRaises(InvalidOperation, Decimal, "\u00a01\u00a02\u00a0")

# unicode whitespace

self.assertRaises(InvalidOperation, Decimal, "\u00a0")

self.assertRaises(InvalidOperation, Decimal, "\u00a0\u00a0")

# embedded NUL

self.assertRaises(InvalidOperation, Decimal, "12\u00003")

# underscores don't prevent errors

self.assertRaises(InvalidOperation, Decimal, "1_2_\u00003")

def test_explicit_from_tuples(self):

Decimal = self.decimal.Decimal

#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')

#inf

d = Decimal( (0, (), "F") )

self.assertEqual(str(d), 'Infinity')

#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, "xyz", 2) )

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_list(self):

Decimal = self.decimal.Decimal

d = Decimal([0, [0], 0])

self.assertEqual(str(d), '0')

d = Decimal([1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25])

self.assertEqual(str(d), '-4.34913534E-17')

d = Decimal([1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25])

self.assertEqual(str(d), '-4.34913534E-17')

d = Decimal((1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25))

self.assertEqual(str(d), '-4.34913534E-17')

def test_explicit_from_bool(self):

Decimal = self.decimal.Decimal

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):

Decimal = self.decimal.Decimal

#positive

d = Decimal(45)

e = Decimal(d)

self.assertEqual(str(e), '45')

#very large positive

d = Decimal(500000123)

e = Decimal(d)

self.assertEqual(str(e), '500000123')

#negative

d = Decimal(-45)

e = Decimal(d)

self.assertEqual(str(e), '-45')

#zero

d = Decimal(0)

e = Decimal(d)

self.assertEqual(str(e), '0')

@requires_IEEE_754

def test_explicit_from_float(self):

Decimal = self.decimal.Decimal

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):

Decimal = self.decimal.Decimal

InvalidOperation = self.decimal.InvalidOperation

Rounded = self.decimal.Rounded

nc = copy.copy(self.decimal.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')

# more integers

nc.prec = 28

nc.traps[InvalidOperation] = True

for v in [-2**63-1, -2**63, -2**31-1, -2**31, 0,

2**31-1, 2**31, 2**63-1, 2**63]:

d = nc.create_decimal(v)

self.assertIsInstance(d, Decimal)

self.assertEqual(int(d), v)

nc.prec = 3

nc.traps[Rounded] = True

self.assertRaises(Rounded, nc.create_decimal, 1234)

# from string

nc.prec = 28

self.assertEqual(str(nc.create_decimal('0E-017')), '0E-17')

self.assertEqual(str(nc.create_decimal('45')), '45')

self.assertEqual(str(nc.create_decimal('-Inf')), '-Infinity')

self.assertEqual(str(nc.create_decimal('NaN123')), 'NaN123')

# invalid arguments

self.assertRaises(InvalidOperation, nc.create_decimal, "xyz")

self.assertRaises(ValueError, nc.create_decimal, (1, "xyz", -25))

self.assertRaises(TypeError, nc.create_decimal, "1234", "5678")

# no whitespace and underscore stripping is done with this method

self.assertRaises(InvalidOperation, nc.create_decimal, " 1234")

self.assertRaises(InvalidOperation, nc.create_decimal, "12_34")

# too many NaN payload digits

nc.prec = 3

self.assertRaises(InvalidOperation, nc.create_decimal, 'NaN12345')

self.assertRaises(InvalidOperation, nc.create_decimal,

Decimal('NaN12345'))

nc.traps[InvalidOperation] = False

self.assertEqual(str(nc.create_decimal('NaN12345')), 'NaN')

self.assertTrue(nc.flags[InvalidOperation])

nc.flags[InvalidOperation] = False

self.assertEqual(str(nc.create_decimal(Decimal('NaN12345'))), 'NaN')

self.assertTrue(nc.flags[InvalidOperation])

def test_explicit_context_create_from_float(self):

Decimal = self.decimal.Decimal

nc = self.decimal.Context()

r = nc.create_decimal(0.1)

self.assertEqual(type(r), Decimal)

self.assertEqual(str(r), '0.1000000000000000055511151231')

self.assertTrue(nc.create_decimal(float('nan')).is_qnan())

self.assertTrue(nc.create_decimal(float('inf')).is_infinite())

self.assertTrue(nc.create_decimal(float('-inf')).is_infinite())

self.assertEqual(str(nc.create_decimal(float('nan'))),

str(nc.create_decimal('NaN')))

self.assertEqual(str(nc.create_decimal(float('inf'))),

str(nc.create_decimal('Infinity')))

self.assertEqual(str(nc.create_decimal(float('-inf'))),

str(nc.create_decimal('-Infinity')))

self.assertEqual(str(nc.create_decimal(float('-0.0'))),

str(nc.create_decimal('-0')))

nc.prec = 100

for i in range(200):

x = random.expovariate(0.01) * (random.random() * 2.0 - 1.0)

self.assertEqual(x, float(nc.create_decimal(x))) # roundtrip

def test_from_number(self, cls=None):

Decimal = self.decimal.Decimal

if cls is None:

cls = Decimal

def check(arg, expected):

d = cls.from_number(arg)

self.assertIs(type(d), cls)

self.assertEqual(d, expected)

check(314, Decimal(314))

check(3.14, Decimal.from_float(3.14))

check(Decimal('3.14'), Decimal('3.14'))

self.assertRaises(TypeError, cls.from_number, 3+4j)

self.assertRaises(TypeError, cls.from_number, '314')

self.assertRaises(TypeError, cls.from_number, (0, (3, 1, 4), 0))

self.assertRaises(TypeError, cls.from_number, object())

def test_from_number_subclass(self, cls=None):

class DecimalSubclass(self.decimal.Decimal):

pass

self.test_from_number(DecimalSubclass)

def test_unicode_digits(self):

Decimal = self.decimal.Decimal

test_values = {

'\uff11': '1',

'\u0660.\u0660\u0663\u0667\u0662e-\u0663' : '0.0000372',

'-nan\u0c68\u0c6a\u0c66\u0c66' : '-NaN2400',

}

for input, expected in test_values.items():

'''Unit tests for Implicit Construction cases of Decimal.'''

def test_implicit_from_None(self):

Decimal = self.decimal.Decimal

self.assertRaises(TypeError, eval, 'Decimal(5) + None', locals())

def test_implicit_from_int(self):

Decimal = self.decimal.Decimal

#normal

self.assertEqual(str(Decimal(5) + 45), '50')

#exceeding precision

self.assertEqual(Decimal(5) + 123456789000, Decimal(123456789000))

def test_implicit_from_string(self):

Decimal = self.decimal.Decimal

self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', locals())

def test_implicit_from_float(self):

Decimal = self.decimal.Decimal

self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', locals())

def test_implicit_from_Decimal(self):

Decimal = self.decimal.Decimal

self.assertEqual(Decimal(5) + Decimal(45), Decimal(50))

def test_rop(self):

Decimal = self.decimal.Decimal

# 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()'),

'''Unit tests for the format function.'''

def test_formatting(self):

Decimal = self.decimal.Decimal

# 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'),

('.01f', '3.14159265', '3.1'), # leading zero in precision

('.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

('.0n', '3.14159265', '3'), # same for 'n'