Move Decimal from the sandbox into production.

1 files changed, 1082 insertions, 0 deletions

diff --git a/Lib/test/test_decimal.py b/Lib/test/test_decimal.py
new file mode 100644
index 0000000..b3fb0ad
--- /dev/null
+++ b/Lib/test/test_decimal.py
@@ -0,0 +1,1082 @@
+# 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
+
+TESTDATADIR = 'decimaltestdata'
+dir = os.curdir + 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 ExceptionList:
+            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 ExceptionList, 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 ExceptionList, 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 ExceptionList, 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 ExceptionList:
+            if self.context.flags[exception]:
+                L.append(exception)
+        return L
+
+    def resetflags(self):
+        for exception in ExceptionList:
+            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)
+
+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,
+    ]
+
+    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]")