| # 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. |
| """ |
| |
| from __future__ import division |
| |
| import unittest |
| import glob |
| import os, sys |
| import pickle, copy |
| from decimal import * |
| from test.test_support import TestSkipped, run_unittest, run_doctest, is_resource_enabled |
| import threading |
| |
| # Tests are built around these assumed context defaults |
| DefaultContext.prec=9 |
| DefaultContext.rounding=ROUND_HALF_EVEN |
| DefaultContext.trap_enablers=dict.fromkeys(Signals, 0) |
| setcontext(DefaultContext) |
| |
| |
| TESTDATADIR = 'decimaltestdata' |
| if __name__ == '__main__': |
| file = sys.argv[0] |
| else: |
| file = __file__ |
| testdir = os.path.dirname(file) or os.curdir |
| dir = testdir + os.sep + TESTDATADIR + os.sep |
| |
| skip_expected = not os.path.isdir(dir) |
| |
| # 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' : ConversionSyntax, |
| 'division_by_zero' : DivisionByZero, |
| 'division_impossible' : DivisionImpossible, |
| 'division_undefined' : DivisionUndefined, |
| 'inexact' : Inexact, |
| 'invalid_context' : InvalidContext, |
| '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} |
| |
| # Name adapter to be able to change the Decimal and Context |
| # interface without changing the test files from Cowlishaw |
| nameAdapter = {'toeng':'to_eng_string', |
| 'tosci':'to_sci_string', |
| 'samequantum':'same_quantum', |
| 'tointegral':'to_integral', |
| 'remaindernear':'remainder_near', |
| 'divideint':'divide_int', |
| 'squareroot':'sqrt', |
| 'apply':'_apply', |
| } |
| |
| class DecimalTest(unittest.TestCase): |
| """Class which tests the Decimal class against the test cases. |
| |
| Changed for unittest. |
| """ |
| def setUp(self): |
| global dir |
| self.context = Context() |
| for key in DefaultContext.trap_enablers.keys(): |
| DefaultContext.trap_enablers[key] = 1 |
| 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 tearDown(self): |
| """Cleaning up enviroment.""" |
| # leaving context in original state |
| for key in DefaultContext.trap_enablers.keys(): |
| DefaultContext.trap_enablers[key] = 0 |
| return |
| |
| def eval_file(self, file): |
| global skip_expected |
| if skip_expected: |
| raise TestSkipped |
| return |
| for line in open(file).xreadlines(): |
| line = line.replace('\r\n', '').replace('\n', '') |
| try: |
| t = self.eval_line(line) |
| except ConversionSyntax: |
| print 'Error in test cases:' |
| print line |
| continue |
| except DecimalException, exception: |
| #Exception raised where there shoudn't have been one. |
| self.fail('Exception "'+exception.__class__.__name__ + '" raised on line '+line) |
| |
| return |
| |
| def eval_line(self, s): |
| if s.find(' -> ') >= 0 and s[:2] != '--' and not s.startswith(' --'): |
| s = (s.split('->')[0] + '->' + |
| s.split('->')[1].split('--')[0]).strip() |
| else: |
| s = s.split('--')[0].strip() |
| |
| for ignore in self.ignore_list: |
| if s.find(ignore) >= 0: |
| #print s.split()[0], 'NotImplemented--', ignore |
| return |
| if not s: |
| return |
| elif ':' in s: |
| return self.eval_directive(s) |
| else: |
| return self.eval_equation(s) |
| |
| def eval_directive(self, s): |
| funct, value = 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 |
| try: |
| Sides = s.split('->') |
| L = Sides[0].strip().split() |
| id = L[0] |
| # print id, |
| funct = L[1].lower() |
| valstemp = L[2:] |
| L = Sides[1].strip().split() |
| ans = L[0] |
| exceptions = L[1:] |
| except (TypeError, AttributeError, IndexError): |
| raise ConversionSyntax |
| def FixQuotes(val): |
| val = val.replace("''", 'SingleQuote').replace('""', 'DoubleQuote') |
| val = val.replace("'", '').replace('"', '') |
| val = val.replace('SingleQuote', "'").replace('DoubleQuote', '"') |
| return val |
| fname = nameAdapter.get(funct, funct) |
| if fname == 'rescale': |
| return |
| funct = getattr(self.context, fname) |
| vals = [] |
| conglomerate = '' |
| quote = 0 |
| theirexceptions = [ErrorNames[x.lower()] for x in exceptions] |
| |
| for exception in Signals: |
| self.context.trap_enablers[exception] = 1 #Catch these bugs... |
| for exception in theirexceptions: |
| self.context.trap_enablers[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.trap_enablers[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.trap_enablers[error] = 0 |
| v = self.context.create_decimal(v) |
| else: |
| v = Decimal(v) |
| vals.append(v) |
| |
| ans = FixQuotes(ans) |
| |
| if EXTENDEDERRORTEST and fname not in ('to_sci_string', 'to_eng_string'): |
| for error in theirexceptions: |
| self.context.trap_enablers[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.trap_enablers[error] = 0 |
| try: |
| result = str(funct(*vals)) |
| if fname == 'same_quantum': |
| 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.resetflags() |
| |
| myexceptions.sort() |
| theirexceptions.sort() |
| |
| self.assertEqual(result, ans, |
| 'Incorrect answer for ' + s + ' -- got ' + result) |
| self.assertEqual(myexceptions, theirexceptions, |
| 'Incorrect flags set in ' + s + ' -- got ' \ |
| + str(myexceptions)) |
| return |
| |
| def getexceptions(self): |
| L = [] |
| for exception in Signals: |
| if self.context.flags[exception]: |
| L.append(exception) |
| return L |
| |
| def resetflags(self): |
| for exception in Signals: |
| self.context.flags[exception] = 0 |
| |
| 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 |
| |
| def test_abs(self): |
| self.eval_file(dir + 'abs' + '.decTest') |
| |
| def test_add(self): |
| self.eval_file(dir + 'add' + '.decTest') |
| |
| def test_base(self): |
| self.eval_file(dir + 'base' + '.decTest') |
| |
| def test_clamp(self): |
| self.eval_file(dir + 'clamp' + '.decTest') |
| |
| def test_compare(self): |
| self.eval_file(dir + 'compare' + '.decTest') |
| |
| def test_divide(self): |
| self.eval_file(dir + 'divide' + '.decTest') |
| |
| def test_divideint(self): |
| self.eval_file(dir + 'divideint' + '.decTest') |
| |
| def test_inexact(self): |
| self.eval_file(dir + 'inexact' + '.decTest') |
| |
| def test_max(self): |
| self.eval_file(dir + 'max' + '.decTest') |
| |
| def test_min(self): |
| self.eval_file(dir + 'min' + '.decTest') |
| |
| def test_minus(self): |
| self.eval_file(dir + 'minus' + '.decTest') |
| |
| def test_multiply(self): |
| self.eval_file(dir+'multiply'+'.decTest') |
| |
| def test_normalize(self): |
| self.eval_file(dir + 'normalize' + '.decTest') |
| |
| def test_plus(self): |
| self.eval_file(dir + 'plus' + '.decTest') |
| |
| def test_power(self): |
| self.eval_file(dir + 'power' + '.decTest') |
| |
| def test_quantize(self): |
| self.eval_file(dir + 'quantize' + '.decTest') |
| |
| def test_randomBound32(self): |
| self.eval_file(dir + 'randomBound32' + '.decTest') |
| |
| def test_randoms(self): |
| self.eval_file(dir + 'randoms' + '.decTest') |
| |
| def test_remainder(self): |
| self.eval_file(dir + 'remainder' + '.decTest') |
| |
| def test_remainderNear(self): |
| self.eval_file(dir + 'remainderNear' + '.decTest') |
| |
| def test_rounding(self): |
| self.eval_file(dir + 'rounding' + '.decTest') |
| |
| def test_samequantum(self): |
| self.eval_file(dir + 'samequantum' + '.decTest') |
| |
| def test_squareroot(self): |
| self.eval_file(dir + 'squareroot' + '.decTest') |
| |
| def test_subtract(self): |
| self.eval_file(dir + 'subtract' + '.decTest') |
| |
| def test_tointegral(self): |
| self.eval_file(dir + 'tointegral' + '.decTest') |
| |
| |
| # 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): |
| '''Explicit construction with string.''' |
| |
| #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') |
| |
| 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) ) |
| |
| #bad exp |
| self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!') ) |
| |
| #bad coefficients |
| self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) ) |
| self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) ) |
| |
| def test_explicit_from_Decimal(self): |
| |
| #positive |
| d = Decimal(45) |
| e = Decimal(d) |
| self.assertEqual(str(e), '45') |
| self.assertNotEqual(id(d), id(e)) |
| |
| #very large positive |
| d = Decimal(500000123) |
| e = Decimal(d) |
| self.assertEqual(str(e), '500000123') |
| self.assertNotEqual(id(d), id(e)) |
| |
| #negative |
| d = Decimal(-45) |
| e = Decimal(d) |
| self.assertEqual(str(e), '-45') |
| self.assertNotEqual(id(d), id(e)) |
| |
| #zero |
| d = Decimal(0) |
| e = Decimal(d) |
| self.assertEqual(str(e), '0') |
| self.assertNotEqual(id(d), id(e)) |
| |
| def test_explicit_context_create_decimal(self): |
| |
| nc = copy.copy(getcontext()) |
| nc.prec = 3 |
| |
| # empty |
| self.assertRaises(TypeError, nc.create_decimal) |
| |
| # from None |
| self.assertRaises(TypeError, nc.create_decimal, None) |
| |
| # from int |
| d = nc.create_decimal(456) |
| self.failUnless(isinstance(d, Decimal)) |
| self.assertEqual(nc.create_decimal(45678), |
| nc.create_decimal('457E+2')) |
| |
| # from string |
| d = Decimal('456789') |
| self.assertEqual(str(d), '456789') |
| d = nc.create_decimal('456789') |
| self.assertEqual(str(d), '4.57E+5') |
| |
| # from tuples |
| d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) ) |
| self.assertEqual(str(d), '-4.34913534E-17') |
| d = nc.create_decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) ) |
| self.assertEqual(str(d), '-4.35E-17') |
| |
| # from Decimal |
| prevdec = Decimal(500000123) |
| d = Decimal(prevdec) |
| self.assertEqual(str(d), '500000123') |
| d = nc.create_decimal(prevdec) |
| self.assertEqual(str(d), '5.00E+8') |
| |
| |
| class DecimalImplicitConstructionTest(unittest.TestCase): |
| '''Unit tests for Implicit Construction cases of Decimal.''' |
| |
| def test_implicit_from_None(self): |
| self.assertRaises(TypeError, eval, 'Decimal(5) + None', globals()) |
| |
| def test_implicit_from_int(self): |
| #normal |
| self.assertEqual(str(Decimal(5) + 45), '50') |
| #exceeding precision |
| self.assertEqual(Decimal(5) + 123456789000, Decimal(123456789000)) |
| |
| def test_implicit_from_string(self): |
| self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', globals()) |
| |
| def test_implicit_from_float(self): |
| self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', globals()) |
| |
| def test_implicit_from_Decimal(self): |
| self.assertEqual(Decimal(5) + Decimal(45), Decimal(50)) |
| |
| |
| 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): |
| '''Test floor division in all its ways.''' |
| |
| 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): |
| '''Test powering in all its ways.''' |
| |
| 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 |
| |
| |
| # The following are two functions used to test threading in the next class |
| |
| def thfunc1(cls): |
| d1 = Decimal(1) |
| d3 = Decimal(3) |
| cls.assertEqual(d1/d3, Decimal('0.333333333')) |
| cls.synchro.wait() |
| cls.assertEqual(d1/d3, Decimal('0.333333333')) |
| cls.finish1.set() |
| return |
| |
| def thfunc2(cls): |
| d1 = Decimal(1) |
| d3 = Decimal(3) |
| cls.assertEqual(d1/d3, Decimal('0.333333333')) |
| thiscontext = getcontext() |
| thiscontext.prec = 18 |
| cls.assertEqual(d1/d3, Decimal('0.333333333333333333')) |
| cls.synchro.set() |
| cls.finish2.set() |
| return |
| |
| |
| class DecimalUseOfContextTest(unittest.TestCase): |
| '''Unit tests for Use of Context cases in Decimal.''' |
| |
| import threading |
| # 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.finish1.wait() |
| return |
| |
| |
| class DecimalUsabilityTest(unittest.TestCase): |
| '''Unit tests for Usability cases of Decimal.''' |
| |
| def test_comparison_operators(self): |
| '''Testing ==, !=, <, >, <=, >=, cmp.''' |
| |
| da = Decimal('23.42') |
| db = Decimal('23.42') |
| dc = Decimal('45') |
| |
| #two Decimals |
| self.failUnless(dc > da) |
| self.failUnless(dc >= da) |
| self.failUnless(da < dc) |
| self.failUnless(da <= dc) |
| self.failUnless(da == db) |
| self.failUnless(da != dc) |
| self.failUnless(da <= db) |
| self.failUnless(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.failUnless(dc > 23) |
| self.failUnless(23 < dc) |
| self.failUnless(dc == 45) |
| self.assertEqual(cmp(dc,23), 1) |
| self.assertEqual(cmp(23,dc), -1) |
| self.assertEqual(cmp(dc,45), 0) |
| |
| #a Decimal and uncomparable |
| try: da == 'ugly' |
| except TypeError: pass |
| else: self.fail('Did not raised an error!') |
| |
| try: da == '32.7' |
| except TypeError: pass |
| else: self.fail('Did not raised an error!') |
| |
| try: da == object |
| except TypeError: pass |
| else: self.fail('Did not raised an error!') |
| |
| 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)) |
| #the same hash that to an int |
| self.assertEqual(hash(Decimal(23)), hash(23)) |
| |
| def test_min_and_max_methods(self): |
| |
| d1 = Decimal('15.32') |
| d2 = Decimal('28.5') |
| l1 = 15 |
| l2 = 28 |
| |
| #between Decimals |
| self.failUnless(min(d1,d2) is d1) |
| self.failUnless(min(d2,d1) is d1) |
| self.failUnless(max(d1,d2) is d2) |
| self.failUnless(max(d2,d1) is d2) |
| |
| #between Decimal and long |
| self.failUnless(min(d1,l2) is d1) |
| self.failUnless(min(l2,d1) is d1) |
| self.failUnless(max(l1,d2) is d2) |
| self.failUnless(max(d2,l1) is d2) |
| |
| def test_as_nonzero(self): |
| #as false |
| self.failIf(Decimal(0)) |
| #as true |
| self.failUnless(Decimal('0.372')) |
| |
| def test_tostring_methods(self): |
| #Test str and repr methods. |
| |
| d = Decimal('15.32') |
| self.assertEqual(str(d), '15.32') # str |
| self.assertEqual(repr(d), 'Decimal("15.32")') # repr |
| |
| def test_tonum_methods(self): |
| #Test float, int and long methods. |
| |
| d1 = Decimal('66') |
| d2 = Decimal('15.32') |
| |
| #int |
| self.assertEqual(int(d1), 66) |
| self.assertEqual(int(d2), 15) |
| |
| #long |
| self.assertEqual(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') ) |
| |
| def test_immutability_onpurpose(self): |
| #Try to change internal objects and see if immutable. |
| |
| d = Decimal(42) |
| |
| #you can get the attributes... |
| d.exp |
| d.int |
| d.sign |
| |
| #...but not change them! |
| try: |
| d.exp = 20 |
| d.int = 3 |
| d.sign = 1 |
| except AttributeError: |
| pass |
| else: |
| self.fail('Did not raised an error!') |
| |
| #some new attribute |
| try: |
| d.newone = None |
| except AttributeError: |
| pass |
| else: |
| self.fail('Did not raised an error!') |
| |
| 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("__cmp__", True) |
| checkSameDec("__float__") |
| checkSameDec("__floordiv__", True) |
| checkSameDec("__hash__") |
| checkSameDec("__int__") |
| 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") |
| |
| class DecimalPythonAPItests(unittest.TestCase): |
| |
| def test_pickle(self): |
| d = Decimal('-3.141590000') |
| p = pickle.dumps(d) |
| e = pickle.loads(p) |
| self.assertEqual(d, e) |
| |
| 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_main(arith=False, verbose=None): |
| """ Execute the tests. |
| |
| Runs arithmetic tests if arith is True or if the "decimal" resource |
| is enables in regrtest.py |
| """ |
| test_classes = [ |
| DecimalExplicitConstructionTest, |
| DecimalImplicitConstructionTest, |
| DecimalArithmeticOperatorsTest, |
| DecimalUseOfContextTest, |
| DecimalUsabilityTest, |
| DecimalPythonAPItests, |
| ContextAPItests, |
| ] |
| |
| if arith or is_resource_enabled('decimal'): |
| test_classes.extend([DecimalTest]) |
| |
| run_unittest(*test_classes) |
| import decimal as DecimalModule |
| run_doctest(DecimalModule, verbose) |
| return |
| |
| |
| if __name__ == '__main__': |
| # Calling with no arguments runs all tests. |
| # Calling with "Skip" will skipover the arithmetic tests. |
| if len(sys.argv) == 1: |
| test_main(arith=True, verbose=True) |
| elif len(sys.argv) == 2: |
| arith = sys.argv[1].lower() != 'skip' |
| test_main(arith=arith, verbose=True) |
| else: |
| raise ValueError("test called with wrong arguments, use test_Decimal [Skip]") |