# 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 with_statement

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 random

try:

    import threading

except ImportError:

    threading = None

# Useful Test Constant

Signals = getcontext().flags.keys()

# Tests are built around these assumed context defaults.

# test_main() restores the original context.

def init():

    global ORIGINAL_CONTEXT

    ORIGINAL_CONTEXT = getcontext().copy()

    DefaultContext.prec = 9

    DefaultContext.rounding = ROUND_HALF_EVEN

    DefaultContext.traps = 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

directory = testdir + os.sep + TESTDATADIR + os.sep

skip_expected = not os.path.isdir(directory)

# Make sure it actually raises errors when not expected and caught in flags

# Slower, since it runs some things several times.

EXTENDEDERRORTEST = False

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

ErrorNames = {'clamped' : Clamped,

              'conversion_syntax' : InvalidOperation,

              'division_by_zero' : DivisionByZero,

              'division_impossible' : InvalidOperation,

              'division_undefined' : InvalidOperation,

              'inexact' : Inexact,

              'invalid_context' : InvalidOperation,

              'invalid_operation' : InvalidOperation,

              'overflow' : Overflow,

              'rounded' : Rounded,

              'subnormal' : Subnormal,

              'underflow' : Underflow}

def Nonfunction(*args):

    """Doesn't do anything."""

    return None

RoundingDict = {'ceiling' : ROUND_CEILING, #Maps test-case names to roundings.

                'down' : ROUND_DOWN,

                'floor' : ROUND_FLOOR,

                'half_down' : ROUND_HALF_DOWN,

                'half_even' : ROUND_HALF_EVEN,

                'half_up' : ROUND_HALF_UP,

                'up' : ROUND_UP,

                '05up' : ROUND_05UP}

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

# interface without changing the test files from Cowlishaw

nameAdapter = {'and':'logical_and',

               'apply':'_apply',

               'class':'number_class',

               'comparesig':'compare_signal',

               'comparetotal':'compare_total',

               'comparetotmag':'compare_total_mag',

               'copy':'copy_decimal',

               'copyabs':'copy_abs',

               'copynegate':'copy_negate',

               'copysign':'copy_sign',

               'divideint':'divide_int',

               'invert':'logical_invert',

               'iscanonical':'is_canonical',

               'isfinite':'is_finite',

               'isinfinite':'is_infinite',

               'isnan':'is_nan',

               'isnormal':'is_normal',

               'isqnan':'is_qnan',

               'issigned':'is_signed',

               'issnan':'is_snan',

               'issubnormal':'is_subnormal',

               'iszero':'is_zero',

               'maxmag':'max_mag',

               'minmag':'min_mag',

               'nextminus':'next_minus',

               'nextplus':'next_plus',

               'nexttoward':'next_toward',

               'or':'logical_or',

               'reduce':'normalize',

               'remaindernear':'remainder_near',

               'samequantum':'same_quantum',

               'squareroot':'sqrt',

               'toeng':'to_eng_string',

               'tointegral':'to_integral_value',

               'tointegralx':'to_integral_exact',

               'tosci':'to_sci_string',

               'xor':'logical_xor',

              }

# The following functions return True/False rather than a Decimal instance

LOGICAL_FUNCTIONS = (

    'is_canonical',

    'is_finite',

    'is_infinite',

    'is_nan',

    'is_normal',

    'is_qnan',

    'is_signed',

    'is_snan',

    'is_subnormal',

    'is_zero',

    'same_quantum',

    )

# For some operations (currently exp, ln, log10, power), the decNumber

# reference implementation imposes additional restrictions on the

# context and operands.  These restrictions are not part of the

# specification; however, the effect of these restrictions does show

# up in some of the testcases.  We skip testcases that violate these

# restrictions, since Decimal behaves differently from decNumber for

# these testcases so these testcases would otherwise fail.

decNumberRestricted = ('power', 'ln', 'log10', 'exp')

DEC_MAX_MATH = 999999

def outside_decNumber_bounds(v, context):

    if (context.prec > DEC_MAX_MATH or

        context.Emax > DEC_MAX_MATH or

        -context.Emin > DEC_MAX_MATH):

        return True

    if not v._is_special and v and (

        len(v._int) > DEC_MAX_MATH or

        v.adjusted() > DEC_MAX_MATH or

        v.adjusted() < 1-2*DEC_MAX_MATH):

        return True

    return False

class DecimalTest(unittest.TestCase):

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

    Changed for unittest.

    """

    def setUp(self):

        self.context = Context()

        for key in DefaultContext.traps.keys():

            DefaultContext.traps[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.traps.keys():

            DefaultContext.traps[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', '')

            #print line

            try:

                t = self.eval_line(line)

            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

        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

        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)

        # skip tests that are related to bounds imposed in the decNumber

        # reference implementation

        if fname in decNumberRestricted:

            if fname == 'power':

                if not (vals[1]._isinteger() and

                        -1999999997 <= vals[1] <= 999999999):

                    if outside_decNumber_bounds(vals[0], self.context) or \

                            outside_decNumber_bounds(vals[1], self.context):

                        #print "Skipping test %s" % s

                        return

            else:

                if outside_decNumber_bounds(vals[0], self.context):

                    #print "Skipping test %s" % s

                    return

        if EXTENDEDERRORTEST and fname not in ('to_sci_string', 'to_eng_string'):

            for error in theirexceptions:

                self.context.traps[error] = 1

                try:

                    funct(*vals)

                except error:

                    pass

                except Signals, e:

                    self.fail("Raised %s in %s when %s disabled" % \

                              (e, s, error))

                else:

                    self.fail("Did not raise %s in %s" % (error, s))

                self.context.traps[error] = 0

        if DEBUG:

            print "--", self.context

        try:

            result = str(funct(*vals))

            if fname in LOGICAL_FUNCTIONS:

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

        except Signals, error:

            self.fail("Raised %s in %s" % (error, s))

        except: #Catch any error long enough to state the test case.

            print "ERROR:", s

            raise

        myexceptions = self.getexceptions()

        self.context.clear_flags()

        myexceptions.sort()

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

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

    def test_explicit_from_tuples(self):

        #zero

        d = Decimal( (0, (0,), 0) )

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

        #int

        d = Decimal( (1, (4, 5), 0) )

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

        #float

        d = Decimal( (0, (4, 5, 3, 4), -2) )

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

        #weird

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

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

        #wrong number of items

        self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1)) )

        #bad sign

        self.assertRaises(ValueError, Decimal, (8, (4, 3, 4, 9, 1), 2) )

        self.assertRaises(ValueError, Decimal, (0., (4, 3, 4, 9, 1), 2) )

        self.assertRaises(ValueError, Decimal, (Decimal(1), (4, 3, 4, 9, 1), 2))

        #bad exp

        self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!') )

        self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 0.) )

        self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), '1') )

        #bad coefficients

        self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) )

        self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) )

        self.assertRaises(ValueError, Decimal, (1, (4, 10, 4, 9, 1), 2) )

        self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 'a', 1), 2) )

    def test_explicit_from_Decimal(self):

        #positive

        d = Decimal(45)

        e = Decimal(d)

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

        self.assertNotEqual(id(d), id(e))

        #very large positive

        d = Decimal(500000123)

        e = Decimal(d)

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

        self.assertNotEqual(id(d), id(e))

        #negative

        d = Decimal(-45)

        e = Decimal(d)

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

        self.assertNotEqual(id(d), id(e))

        #zero

        d = Decimal(0)

        e = Decimal(d)

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

        self.assertNotEqual(id(d), id(e))

    def test_explicit_context_create_decimal(self):

        nc = copy.copy(getcontext())

        nc.prec = 3

        # empty

        d = Decimal()

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

        d = nc.create_decimal()

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

        # from None

        self.assertRaises(TypeError, nc.create_decimal, None)

        # from int

        d = nc.create_decimal(456)

        self.failUnless(isinstance(d, Decimal))

        self.assertEqual(nc.create_decimal(45678),

                         nc.create_decimal('457E+2'))

        # from string

        d = Decimal('456789')

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

        d = nc.create_decimal('456789')

        self.assertEqual(str(d), '4.57E+5')

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