Debian Codegraph @

Lib/test/test_decimal.py

raw
1 # Copyright (c) 2004 Python Software Foundation.
2 # All rights reserved.
3
4 # Written by Eric Price <eprice at tjhsst.edu>
5 # and Facundo Batista <facundo at taniquetil.com.ar>
6 # and Raymond Hettinger <python at rcn.com>
7 # and Aahz (aahz at pobox.com)
8 # and Tim Peters
9
10 """
11 These are the test cases for the Decimal module.
12
13 There are two groups of tests, Arithmetic and Behaviour. The former test
14 the Decimal arithmetic using the tests provided by Mike Cowlishaw. The latter
15 test the pythonic behaviour according to PEP 327.
16
17 Cowlishaw's tests can be downloaded from:
18
19 http://speleotrove.com/decimal/dectest.zip
20
21 This test module can be called from command line with one parameter (Arithmetic
22 or Behaviour) to test each part, or without parameter to test both parts. If
23 you're working through IDLE, you can import this test module and call test()
24 with the corresponding argument.
25 """
26
27 import logging
28 import math
29 import os, sys
30 import operator
31 import warnings
32 import pickle, copy
33 import unittest
34 import numbers
35 import locale
36 from test.support import (is_resource_enabled,
37 requires_IEEE_754, requires_docstrings,
38 check_disallow_instantiation)
39 from test.support import (TestFailed,
40 run_with_locale, cpython_only,
41 darwin_malloc_err_warning)
42 from test.support.import_helper import import_fresh_module
43 from test.support import threading_helper
44 from test.support import warnings_helper
45 import random
46 import inspect
47 import threading
48 import contextvars
49
50
51 if sys.platform == 'darwin':
52 darwin_malloc_err_warning('test_decimal')
53
54
55 C = import_fresh_module('decimal', fresh=['_decimal'])
56 P = import_fresh_module('decimal', blocked=['_decimal'])
57 import decimal as orig_sys_decimal
58
59 # fractions module must import the correct decimal module.
60 cfractions = import_fresh_module('fractions', fresh=['fractions'])
61 sys.modules['decimal'] = P
62 pfractions = import_fresh_module('fractions', fresh=['fractions'])
63 sys.modules['decimal'] = C
64 fractions = {C:cfractions, P:pfractions}
65 sys.modules['decimal'] = orig_sys_decimal
66
67 requires_cdecimal = unittest.skipUnless(C, "test requires C version")
68
69 # Useful Test Constant
70 Signals = {
71 C: tuple(C.getcontext().flags.keys()) if C else None,
72 P: tuple(P.getcontext().flags.keys())
73 }
74 # Signals ordered with respect to precedence: when an operation
75 # produces multiple signals, signals occurring later in the list
76 # should be handled before those occurring earlier in the list.
77 OrderedSignals = {
78 C: [C.Clamped, C.Rounded, C.Inexact, C.Subnormal, C.Underflow,
79 C.Overflow, C.DivisionByZero, C.InvalidOperation,
80 C.FloatOperation] if C else None,
81 P: [P.Clamped, P.Rounded, P.Inexact, P.Subnormal, P.Underflow,
82 P.Overflow, P.DivisionByZero, P.InvalidOperation,
83 P.FloatOperation]
84 }
85 def assert_signals(cls, context, attr, expected):
86 d = getattr(context, attr)
87 cls.assertTrue(all(d[s] if s in expected else not d[s] for s in d))
88
89 ROUND_UP = P.ROUND_UP
90 ROUND_DOWN = P.ROUND_DOWN
91 ROUND_CEILING = P.ROUND_CEILING
92 ROUND_FLOOR = P.ROUND_FLOOR
93 ROUND_HALF_UP = P.ROUND_HALF_UP
94 ROUND_HALF_DOWN = P.ROUND_HALF_DOWN
95 ROUND_HALF_EVEN = P.ROUND_HALF_EVEN
96 ROUND_05UP = P.ROUND_05UP
97
98 RoundingModes = [
99 ROUND_UP, ROUND_DOWN, ROUND_CEILING, ROUND_FLOOR,
100 ROUND_HALF_UP, ROUND_HALF_DOWN, ROUND_HALF_EVEN,
101 ROUND_05UP
102 ]
103
104 # Tests are built around these assumed context defaults.
105 # test() restores the original context.
106 ORIGINAL_CONTEXT = {
107 C: C.getcontext().copy() if C else None,
108 P: P.getcontext().copy()
109 }
110 def init(m):
111 if not m: return
112 DefaultTestContext = m.Context(
113 prec=9, rounding=ROUND_HALF_EVEN, traps=dict.fromkeys(Signals[m], 0)
114 )
115 m.setcontext(DefaultTestContext)
116
117 TESTDATADIR = 'decimaltestdata'
118 if __name__ == '__main__':
119 file = sys.argv[0]
120 else:
121 file = __file__
122 testdir = os.path.dirname(file) or os.curdir
123 directory = testdir + os.sep + TESTDATADIR + os.sep
124
125 skip_expected = not os.path.isdir(directory)
126
127 # Make sure it actually raises errors when not expected and caught in flags
128 # Slower, since it runs some things several times.
129 EXTENDEDERRORTEST = False
130
131 # Test extra functionality in the C version (-DEXTRA_FUNCTIONALITY).
132 EXTRA_FUNCTIONALITY = True if hasattr(C, 'DecClamped') else False
133 requires_extra_functionality = unittest.skipUnless(
134 EXTRA_FUNCTIONALITY, "test requires build with -DEXTRA_FUNCTIONALITY")
135 skip_if_extra_functionality = unittest.skipIf(
136 EXTRA_FUNCTIONALITY, "test requires regular build")
137
138
139 class IBMTestCases:
140 """Class which tests the Decimal class against the IBM test cases."""
141
142 def setUp(self):
143 self.context = self.decimal.Context()
144 self.readcontext = self.decimal.Context()
145 self.ignore_list = ['#']
146
147 # List of individual .decTest test ids that correspond to tests that
148 # we're skipping for one reason or another.
149 self.skipped_test_ids = set([
150 # Skip implementation-specific scaleb tests.
151 'scbx164',
152 'scbx165',
153
154 # For some operations (currently exp, ln, log10, power), the decNumber
155 # reference implementation imposes additional restrictions on the context
156 # and operands. These restrictions are not part of the specification;
157 # however, the effect of these restrictions does show up in some of the
158 # testcases. We skip testcases that violate these restrictions, since
159 # Decimal behaves differently from decNumber for these testcases so these
160 # testcases would otherwise fail.
161 'expx901',
162 'expx902',
163 'expx903',
164 'expx905',
165 'lnx901',
166 'lnx902',
167 'lnx903',
168 'lnx905',
169 'logx901',
170 'logx902',
171 'logx903',
172 'logx905',
173 'powx1183',
174 'powx1184',
175 'powx4001',
176 'powx4002',
177 'powx4003',
178 'powx4005',
179 'powx4008',
180 'powx4010',
181 'powx4012',
182 'powx4014',
183 ])
184
185 if self.decimal == C:
186 # status has additional Subnormal, Underflow
187 self.skipped_test_ids.add('pwsx803')
188 self.skipped_test_ids.add('pwsx805')
189 # Correct rounding (skipped for decNumber, too)
190 self.skipped_test_ids.add('powx4302')
191 self.skipped_test_ids.add('powx4303')
192 self.skipped_test_ids.add('powx4342')
193 self.skipped_test_ids.add('powx4343')
194 # http://bugs.python.org/issue7049
195 self.skipped_test_ids.add('pwmx325')
196 self.skipped_test_ids.add('pwmx326')
197
198 # Map test directives to setter functions.
199 self.ChangeDict = {'precision' : self.change_precision,
200 'rounding' : self.change_rounding_method,
201 'maxexponent' : self.change_max_exponent,
202 'minexponent' : self.change_min_exponent,
203 'clamp' : self.change_clamp}
204
205 # Name adapter to be able to change the Decimal and Context
206 # interface without changing the test files from Cowlishaw.
207 self.NameAdapter = {'and':'logical_and',
208 'apply':'_apply',
209 'class':'number_class',
210 'comparesig':'compare_signal',
211 'comparetotal':'compare_total',
212 'comparetotmag':'compare_total_mag',
213 'copy':'copy_decimal',
214 'copyabs':'copy_abs',
215 'copynegate':'copy_negate',
216 'copysign':'copy_sign',
217 'divideint':'divide_int',
218 'invert':'logical_invert',
219 'iscanonical':'is_canonical',
220 'isfinite':'is_finite',
221 'isinfinite':'is_infinite',
222 'isnan':'is_nan',
223 'isnormal':'is_normal',
224 'isqnan':'is_qnan',
225 'issigned':'is_signed',
226 'issnan':'is_snan',
227 'issubnormal':'is_subnormal',
228 'iszero':'is_zero',
229 'maxmag':'max_mag',
230 'minmag':'min_mag',
231 'nextminus':'next_minus',
232 'nextplus':'next_plus',
233 'nexttoward':'next_toward',
234 'or':'logical_or',
235 'reduce':'normalize',
236 'remaindernear':'remainder_near',
237 'samequantum':'same_quantum',
238 'squareroot':'sqrt',
239 'toeng':'to_eng_string',
240 'tointegral':'to_integral_value',
241 'tointegralx':'to_integral_exact',
242 'tosci':'to_sci_string',
243 'xor':'logical_xor'}
244
245 # Map test-case names to roundings.
246 self.RoundingDict = {'ceiling' : ROUND_CEILING,
247 'down' : ROUND_DOWN,
248 'floor' : ROUND_FLOOR,
249 'half_down' : ROUND_HALF_DOWN,
250 'half_even' : ROUND_HALF_EVEN,
251 'half_up' : ROUND_HALF_UP,
252 'up' : ROUND_UP,
253 '05up' : ROUND_05UP}
254
255 # Map the test cases' error names to the actual errors.
256 self.ErrorNames = {'clamped' : self.decimal.Clamped,
257 'conversion_syntax' : self.decimal.InvalidOperation,
258 'division_by_zero' : self.decimal.DivisionByZero,
259 'division_impossible' : self.decimal.InvalidOperation,
260 'division_undefined' : self.decimal.InvalidOperation,
261 'inexact' : self.decimal.Inexact,
262 'invalid_context' : self.decimal.InvalidOperation,
263 'invalid_operation' : self.decimal.InvalidOperation,
264 'overflow' : self.decimal.Overflow,
265 'rounded' : self.decimal.Rounded,
266 'subnormal' : self.decimal.Subnormal,
267 'underflow' : self.decimal.Underflow}
268
269 # The following functions return True/False rather than a
270 # Decimal instance.
271 self.LogicalFunctions = ('is_canonical',
272 'is_finite',
273 'is_infinite',
274 'is_nan',
275 'is_normal',
276 'is_qnan',
277 'is_signed',
278 'is_snan',
279 'is_subnormal',
280 'is_zero',
281 'same_quantum')
282
283 def read_unlimited(self, v, context):
284 """Work around the limitations of the 32-bit _decimal version. The
285 guaranteed maximum values for prec, Emax etc. are 425000000,
286 but higher values usually work, except for rare corner cases.
287 In particular, all of the IBM tests pass with maximum values
288 of 1070000000."""
289 if self.decimal == C and self.decimal.MAX_EMAX == 425000000:
290 self.readcontext._unsafe_setprec(1070000000)
291 self.readcontext._unsafe_setemax(1070000000)
292 self.readcontext._unsafe_setemin(-1070000000)
293 return self.readcontext.create_decimal(v)
294 else:
295 return self.decimal.Decimal(v, context)
296
297 def eval_file(self, file):
298 global skip_expected
299 if skip_expected:
300 raise unittest.SkipTest
301 with open(file, encoding="utf-8") as f:
302 for line in f:
303 line = line.replace('\r\n', '').replace('\n', '')
304 #print line
305 try:
306 t = self.eval_line(line)
307 except self.decimal.DecimalException as exception:
308 #Exception raised where there shouldn't have been one.
309 self.fail('Exception "'+exception.__class__.__name__ + '" raised on line '+line)
310
311
312 def eval_line(self, s):
313 if s.find(' -> ') >= 0 and s[:2] != '--' and not s.startswith(' --'):
314 s = (s.split('->')[0] + '->' +
315 s.split('->')[1].split('--')[0]).strip()
316 else:
317 s = s.split('--')[0].strip()
318
319 for ignore in self.ignore_list:
320 if s.find(ignore) >= 0:
321 #print s.split()[0], 'NotImplemented--', ignore
322 return
323 if not s:
324 return
325 elif ':' in s:
326 return self.eval_directive(s)
327 else:
328 return self.eval_equation(s)
329
330 def eval_directive(self, s):
331 funct, value = (x.strip().lower() for x in s.split(':'))
332 if funct == 'rounding':
333 value = self.RoundingDict[value]
334 else:
335 try:
336 value = int(value)
337 except ValueError:
338 pass
339
340 funct = self.ChangeDict.get(funct, (lambda *args: None))
341 funct(value)
342
343 def eval_equation(self, s):
344
345 if not TEST_ALL and random.random() < 0.90:
346 return
347
348 self.context.clear_flags()
349
350 try:
351 Sides = s.split('->')
352 L = Sides[0].strip().split()
353 id = L[0]
354 if DEBUG:
355 print("Test ", id, end=" ")
356 funct = L[1].lower()
357 valstemp = L[2:]
358 L = Sides[1].strip().split()
359 ans = L[0]
360 exceptions = L[1:]
361 except (TypeError, AttributeError, IndexError):
362 raise self.decimal.InvalidOperation
363 def FixQuotes(val):
364 val = val.replace("''", 'SingleQuote').replace('""', 'DoubleQuote')
365 val = val.replace("'", '').replace('"', '')
366 val = val.replace('SingleQuote', "'").replace('DoubleQuote', '"')
367 return val
368
369 if id in self.skipped_test_ids:
370 return
371
372 fname = self.NameAdapter.get(funct, funct)
373 if fname == 'rescale':
374 return
375 funct = getattr(self.context, fname)
376 vals = []
377 conglomerate = ''
378 quote = 0
379 theirexceptions = [self.ErrorNames[x.lower()] for x in exceptions]
380
381 for exception in Signals[self.decimal]:
382 self.context.traps[exception] = 1 #Catch these bugs...
383 for exception in theirexceptions:
384 self.context.traps[exception] = 0
385 for i, val in enumerate(valstemp):
386 if val.count("'") % 2 == 1:
387 quote = 1 - quote
388 if quote:
389 conglomerate = conglomerate + ' ' + val
390 continue
391 else:
392 val = conglomerate + val
393 conglomerate = ''
394 v = FixQuotes(val)
395 if fname in ('to_sci_string', 'to_eng_string'):
396 if EXTENDEDERRORTEST:
397 for error in theirexceptions:
398 self.context.traps[error] = 1
399 try:
400 funct(self.context.create_decimal(v))
401 except error:
402 pass
403 except Signals[self.decimal] as e:
404 self.fail("Raised %s in %s when %s disabled" % \
405 (e, s, error))
406 else:
407 self.fail("Did not raise %s in %s" % (error, s))
408 self.context.traps[error] = 0
409 v = self.context.create_decimal(v)
410 else:
411 v = self.read_unlimited(v, self.context)
412 vals.append(v)
413
414 ans = FixQuotes(ans)
415
416 if EXTENDEDERRORTEST and fname not in ('to_sci_string', 'to_eng_string'):
417 for error in theirexceptions:
418 self.context.traps[error] = 1
419 try:
420 funct(*vals)
421 except error:
422 pass
423 except Signals[self.decimal] as e:
424 self.fail("Raised %s in %s when %s disabled" % \
425 (e, s, error))
426 else:
427 self.fail("Did not raise %s in %s" % (error, s))
428 self.context.traps[error] = 0
429
430 # as above, but add traps cumulatively, to check precedence
431 ordered_errors = [e for e in OrderedSignals[self.decimal] if e in theirexceptions]
432 for error in ordered_errors:
433 self.context.traps[error] = 1
434 try:
435 funct(*vals)
436 except error:
437 pass
438 except Signals[self.decimal] as e:
439 self.fail("Raised %s in %s; expected %s" %
440 (type(e), s, error))
441 else:
442 self.fail("Did not raise %s in %s" % (error, s))
443 # reset traps
444 for error in ordered_errors:
445 self.context.traps[error] = 0
446
447
448 if DEBUG:
449 print("--", self.context)
450 try:
451 result = str(funct(*vals))
452 if fname in self.LogicalFunctions:
453 result = str(int(eval(result))) # 'True', 'False' -> '1', '0'
454 except Signals[self.decimal] as error:
455 self.fail("Raised %s in %s" % (error, s))
456 except: #Catch any error long enough to state the test case.
457 print("ERROR:", s)
458 raise
459
460 myexceptions = self.getexceptions()
461
462 myexceptions.sort(key=repr)
463 theirexceptions.sort(key=repr)
464
465 self.assertEqual(result, ans,
466 'Incorrect answer for ' + s + ' -- got ' + result)
467
468 self.assertEqual(myexceptions, theirexceptions,
469 'Incorrect flags set in ' + s + ' -- got ' + str(myexceptions))
470
471 def getexceptions(self):
472 return [e for e in Signals[self.decimal] if self.context.flags[e]]
473
474 def change_precision(self, prec):
475 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
476 self.context._unsafe_setprec(prec)
477 else:
478 self.context.prec = prec
479 def change_rounding_method(self, rounding):
480 self.context.rounding = rounding
481 def change_min_exponent(self, exp):
482 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
483 self.context._unsafe_setemin(exp)
484 else:
485 self.context.Emin = exp
486 def change_max_exponent(self, exp):
487 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
488 self.context._unsafe_setemax(exp)
489 else:
490 self.context.Emax = exp
491 def change_clamp(self, clamp):
492 self.context.clamp = clamp
493
494
495 # The following classes test the behaviour of Decimal according to PEP 327
496
497 class ExplicitConstructionTest:
498 '''Unit tests for Explicit Construction cases of Decimal.'''
499
500 def test_explicit_empty(self):
501 Decimal = self.decimal.Decimal
502 self.assertEqual(Decimal(), Decimal("0"))
503
504 def test_explicit_from_None(self):
505 Decimal = self.decimal.Decimal
506 self.assertRaises(TypeError, Decimal, None)
507
508 def test_explicit_from_int(self):
509 Decimal = self.decimal.Decimal
510
511 #positive
512 d = Decimal(45)
513 self.assertEqual(str(d), '45')
514
515 #very large positive
516 d = Decimal(500000123)
517 self.assertEqual(str(d), '500000123')
518
519 #negative
520 d = Decimal(-45)
521 self.assertEqual(str(d), '-45')
522
523 #zero
524 d = Decimal(0)
525 self.assertEqual(str(d), '0')
526
527 # single word longs
528 for n in range(0, 32):
529 for sign in (-1, 1):
530 for x in range(-5, 5):
531 i = sign * (2**n + x)
532 d = Decimal(i)
533 self.assertEqual(str(d), str(i))
534
535 def test_explicit_from_string(self):
536 Decimal = self.decimal.Decimal
537 InvalidOperation = self.decimal.InvalidOperation
538 localcontext = self.decimal.localcontext
539
540 #empty
541 self.assertEqual(str(Decimal('')), 'NaN')
542
543 #int
544 self.assertEqual(str(Decimal('45')), '45')
545
546 #float
547 self.assertEqual(str(Decimal('45.34')), '45.34')
548
549 #engineer notation
550 self.assertEqual(str(Decimal('45e2')), '4.5E+3')
551
552 #just not a number
553 self.assertEqual(str(Decimal('ugly')), 'NaN')
554
555 #leading and trailing whitespace permitted
556 self.assertEqual(str(Decimal('1.3E4 \n')), '1.3E+4')
557 self.assertEqual(str(Decimal(' -7.89')), '-7.89')
558 self.assertEqual(str(Decimal(" 3.45679 ")), '3.45679')
559
560 # underscores
561 self.assertEqual(str(Decimal('1_3.3e4_0')), '1.33E+41')
562 self.assertEqual(str(Decimal('1_0_0_0')), '1000')
563
564 # unicode whitespace
565 for lead in ["", ' ', '\u00a0', '\u205f']:
566 for trail in ["", ' ', '\u00a0', '\u205f']:
567 self.assertEqual(str(Decimal(lead + '9.311E+28' + trail)),
568 '9.311E+28')
569
570 with localcontext() as c:
571 c.traps[InvalidOperation] = True
572 # Invalid string
573 self.assertRaises(InvalidOperation, Decimal, "xyz")
574 # Two arguments max
575 self.assertRaises(TypeError, Decimal, "1234", "x", "y")
576
577 # space within the numeric part
578 self.assertRaises(InvalidOperation, Decimal, "1\u00a02\u00a03")
579 self.assertRaises(InvalidOperation, Decimal, "\u00a01\u00a02\u00a0")
580
581 # unicode whitespace
582 self.assertRaises(InvalidOperation, Decimal, "\u00a0")
583 self.assertRaises(InvalidOperation, Decimal, "\u00a0\u00a0")
584
585 # embedded NUL
586 self.assertRaises(InvalidOperation, Decimal, "12\u00003")
587
588 # underscores don't prevent errors
589 self.assertRaises(InvalidOperation, Decimal, "1_2_\u00003")
590
591 def test_explicit_from_tuples(self):
592 Decimal = self.decimal.Decimal
593
594 #zero
595 d = Decimal( (0, (0,), 0) )
596 self.assertEqual(str(d), '0')
597
598 #int
599 d = Decimal( (1, (4, 5), 0) )
600 self.assertEqual(str(d), '-45')
601
602 #float
603 d = Decimal( (0, (4, 5, 3, 4), -2) )
604 self.assertEqual(str(d), '45.34')
605
606 #weird
607 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
608 self.assertEqual(str(d), '-4.34913534E-17')
609
610 #inf
611 d = Decimal( (0, (), "F") )
612 self.assertEqual(str(d), 'Infinity')
613
614 #wrong number of items
615 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1)) )
616
617 #bad sign
618 self.assertRaises(ValueError, Decimal, (8, (4, 3, 4, 9, 1), 2) )
619 self.assertRaises(ValueError, Decimal, (0., (4, 3, 4, 9, 1), 2) )
620 self.assertRaises(ValueError, Decimal, (Decimal(1), (4, 3, 4, 9, 1), 2))
621
622 #bad exp
623 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!') )
624 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 0.) )
625 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), '1') )
626
627 #bad coefficients
628 self.assertRaises(ValueError, Decimal, (1, "xyz", 2) )
629 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) )
630 self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) )
631 self.assertRaises(ValueError, Decimal, (1, (4, 10, 4, 9, 1), 2) )
632 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 'a', 1), 2) )
633
634 def test_explicit_from_list(self):
635 Decimal = self.decimal.Decimal
636
637 d = Decimal([0, [0], 0])
638 self.assertEqual(str(d), '0')
639
640 d = Decimal([1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25])
641 self.assertEqual(str(d), '-4.34913534E-17')
642
643 d = Decimal([1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25])
644 self.assertEqual(str(d), '-4.34913534E-17')
645
646 d = Decimal((1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25))
647 self.assertEqual(str(d), '-4.34913534E-17')
648
649 def test_explicit_from_bool(self):
650 Decimal = self.decimal.Decimal
651
652 self.assertIs(bool(Decimal(0)), False)
653 self.assertIs(bool(Decimal(1)), True)
654 self.assertEqual(Decimal(False), Decimal(0))
655 self.assertEqual(Decimal(True), Decimal(1))
656
657 def test_explicit_from_Decimal(self):
658 Decimal = self.decimal.Decimal
659
660 #positive
661 d = Decimal(45)
662 e = Decimal(d)
663 self.assertEqual(str(e), '45')
664
665 #very large positive
666 d = Decimal(500000123)
667 e = Decimal(d)
668 self.assertEqual(str(e), '500000123')
669
670 #negative
671 d = Decimal(-45)
672 e = Decimal(d)
673 self.assertEqual(str(e), '-45')
674
675 #zero
676 d = Decimal(0)
677 e = Decimal(d)
678 self.assertEqual(str(e), '0')
679
680 @requires_IEEE_754
681 def test_explicit_from_float(self):
682
683 Decimal = self.decimal.Decimal
684
685 r = Decimal(0.1)
686 self.assertEqual(type(r), Decimal)
687 self.assertEqual(str(r),
688 '0.1000000000000000055511151231257827021181583404541015625')
689 self.assertTrue(Decimal(float('nan')).is_qnan())
690 self.assertTrue(Decimal(float('inf')).is_infinite())
691 self.assertTrue(Decimal(float('-inf')).is_infinite())
692 self.assertEqual(str(Decimal(float('nan'))),
693 str(Decimal('NaN')))
694 self.assertEqual(str(Decimal(float('inf'))),
695 str(Decimal('Infinity')))
696 self.assertEqual(str(Decimal(float('-inf'))),
697 str(Decimal('-Infinity')))
698 self.assertEqual(str(Decimal(float('-0.0'))),
699 str(Decimal('-0')))
700 for i in range(200):
701 x = random.expovariate(0.01) * (random.random() * 2.0 - 1.0)
702 self.assertEqual(x, float(Decimal(x))) # roundtrip
703
704 def test_explicit_context_create_decimal(self):
705 Decimal = self.decimal.Decimal
706 InvalidOperation = self.decimal.InvalidOperation
707 Rounded = self.decimal.Rounded
708
709 nc = copy.copy(self.decimal.getcontext())
710 nc.prec = 3
711
712 # empty
713 d = Decimal()
714 self.assertEqual(str(d), '0')
715 d = nc.create_decimal()
716 self.assertEqual(str(d), '0')
717
718 # from None
719 self.assertRaises(TypeError, nc.create_decimal, None)
720
721 # from int
722 d = nc.create_decimal(456)
723 self.assertIsInstance(d, Decimal)
724 self.assertEqual(nc.create_decimal(45678),
725 nc.create_decimal('457E+2'))
726
727 # from string
728 d = Decimal('456789')
729 self.assertEqual(str(d), '456789')
730 d = nc.create_decimal('456789')
731 self.assertEqual(str(d), '4.57E+5')
732 # leading and trailing whitespace should result in a NaN;
733 # spaces are already checked in Cowlishaw's test-suite, so
734 # here we just check that a trailing newline results in a NaN
735 self.assertEqual(str(nc.create_decimal('3.14\n')), 'NaN')
736
737 # from tuples
738 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
739 self.assertEqual(str(d), '-4.34913534E-17')
740 d = nc.create_decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
741 self.assertEqual(str(d), '-4.35E-17')
742
743 # from Decimal
744 prevdec = Decimal(500000123)
745 d = Decimal(prevdec)
746 self.assertEqual(str(d), '500000123')
747 d = nc.create_decimal(prevdec)
748 self.assertEqual(str(d), '5.00E+8')
749
750 # more integers
751 nc.prec = 28
752 nc.traps[InvalidOperation] = True
753
754 for v in [-2**63-1, -2**63, -2**31-1, -2**31, 0,
755 2**31-1, 2**31, 2**63-1, 2**63]:
756 d = nc.create_decimal(v)
757 self.assertIsInstance(d, Decimal)
758 self.assertEqual(int(d), v)
759
760 nc.prec = 3
761 nc.traps[Rounded] = True
762 self.assertRaises(Rounded, nc.create_decimal, 1234)
763
764 # from string
765 nc.prec = 28
766 self.assertEqual(str(nc.create_decimal('0E-017')), '0E-17')
767 self.assertEqual(str(nc.create_decimal('45')), '45')
768 self.assertEqual(str(nc.create_decimal('-Inf')), '-Infinity')
769 self.assertEqual(str(nc.create_decimal('NaN123')), 'NaN123')
770
771 # invalid arguments
772 self.assertRaises(InvalidOperation, nc.create_decimal, "xyz")
773 self.assertRaises(ValueError, nc.create_decimal, (1, "xyz", -25))
774 self.assertRaises(TypeError, nc.create_decimal, "1234", "5678")
775 # no whitespace and underscore stripping is done with this method
776 self.assertRaises(InvalidOperation, nc.create_decimal, " 1234")
777 self.assertRaises(InvalidOperation, nc.create_decimal, "12_34")
778
779 # too many NaN payload digits
780 nc.prec = 3
781 self.assertRaises(InvalidOperation, nc.create_decimal, 'NaN12345')
782 self.assertRaises(InvalidOperation, nc.create_decimal,
783 Decimal('NaN12345'))
784
785 nc.traps[InvalidOperation] = False
786 self.assertEqual(str(nc.create_decimal('NaN12345')), 'NaN')
787 self.assertTrue(nc.flags[InvalidOperation])
788
789 nc.flags[InvalidOperation] = False
790 self.assertEqual(str(nc.create_decimal(Decimal('NaN12345'))), 'NaN')
791 self.assertTrue(nc.flags[InvalidOperation])
792
793 def test_explicit_context_create_from_float(self):
794
795 Decimal = self.decimal.Decimal
796
797 nc = self.decimal.Context()
798 r = nc.create_decimal(0.1)
799 self.assertEqual(type(r), Decimal)
800 self.assertEqual(str(r), '0.1000000000000000055511151231')
801 self.assertTrue(nc.create_decimal(float('nan')).is_qnan())
802 self.assertTrue(nc.create_decimal(float('inf')).is_infinite())
803 self.assertTrue(nc.create_decimal(float('-inf')).is_infinite())
804 self.assertEqual(str(nc.create_decimal(float('nan'))),
805 str(nc.create_decimal('NaN')))
806 self.assertEqual(str(nc.create_decimal(float('inf'))),
807 str(nc.create_decimal('Infinity')))
808 self.assertEqual(str(nc.create_decimal(float('-inf'))),
809 str(nc.create_decimal('-Infinity')))
810 self.assertEqual(str(nc.create_decimal(float('-0.0'))),
811 str(nc.create_decimal('-0')))
812 nc.prec = 100
813 for i in range(200):
814 x = random.expovariate(0.01) * (random.random() * 2.0 - 1.0)
815 self.assertEqual(x, float(nc.create_decimal(x))) # roundtrip
816
817 def test_from_number(self, cls=None):
818 Decimal = self.decimal.Decimal
819 if cls is None:
820 cls = Decimal
821
822 def check(arg, expected):
823 d = cls.from_number(arg)
824 self.assertIs(type(d), cls)
825 self.assertEqual(d, expected)
826
827 check(314, Decimal(314))
828 check(3.14, Decimal.from_float(3.14))
829 check(Decimal('3.14'), Decimal('3.14'))
830 self.assertRaises(TypeError, cls.from_number, 3+4j)
831 self.assertRaises(TypeError, cls.from_number, '314')
832 self.assertRaises(TypeError, cls.from_number, (0, (3, 1, 4), 0))
833 self.assertRaises(TypeError, cls.from_number, object())
834
835 def test_from_number_subclass(self, cls=None):
836 class DecimalSubclass(self.decimal.Decimal):
837 pass
838 self.test_from_number(DecimalSubclass)
839
840 def test_unicode_digits(self):
841 Decimal = self.decimal.Decimal
842
843 test_values = {
844 '\uff11': '1',
845 '\u0660.\u0660\u0663\u0667\u0662e-\u0663' : '0.0000372',
846 '-nan\u0c68\u0c6a\u0c66\u0c66' : '-NaN2400',
847 }
848 for input, expected in test_values.items():
849 self.assertEqual(str(Decimal(input)), expected)
850
851 @requires_cdecimal
852 class CExplicitConstructionTest(ExplicitConstructionTest, unittest.TestCase):
853 decimal = C
854 class PyExplicitConstructionTest(ExplicitConstructionTest, unittest.TestCase):
855 decimal = P
856
857 class ImplicitConstructionTest:
858 '''Unit tests for Implicit Construction cases of Decimal.'''
859
860 def test_implicit_from_None(self):
861 Decimal = self.decimal.Decimal
862 self.assertRaises(TypeError, eval, 'Decimal(5) + None', locals())
863
864 def test_implicit_from_int(self):
865 Decimal = self.decimal.Decimal
866
867 #normal
868 self.assertEqual(str(Decimal(5) + 45), '50')
869 #exceeding precision
870 self.assertEqual(Decimal(5) + 123456789000, Decimal(123456789000))
871
872 def test_implicit_from_string(self):
873 Decimal = self.decimal.Decimal
874 self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', locals())
875
876 def test_implicit_from_float(self):
877 Decimal = self.decimal.Decimal
878 self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', locals())
879
880 def test_implicit_from_Decimal(self):
881 Decimal = self.decimal.Decimal
882 self.assertEqual(Decimal(5) + Decimal(45), Decimal(50))
883
884 def test_rop(self):
885 Decimal = self.decimal.Decimal
886
887 # Allow other classes to be trained to interact with Decimals
888 class E:
889 def __divmod__(self, other):
890 return 'divmod ' + str(other)
891 def __rdivmod__(self, other):
892 return str(other) + ' rdivmod'
893 def __lt__(self, other):
894 return 'lt ' + str(other)
895 def __gt__(self, other):
896 return 'gt ' + str(other)
897 def __le__(self, other):
898 return 'le ' + str(other)
899 def __ge__(self, other):
900 return 'ge ' + str(other)
901 def __eq__(self, other):
902 return 'eq ' + str(other)
903 def __ne__(self, other):
904 return 'ne ' + str(other)
905
906 self.assertEqual(divmod(E(), Decimal(10)), 'divmod 10')
907 self.assertEqual(divmod(Decimal(10), E()), '10 rdivmod')
908 self.assertEqual(eval('Decimal(10) < E()'), 'gt 10')
909 self.assertEqual(eval('Decimal(10) > E()'), 'lt 10')
910 self.assertEqual(eval('Decimal(10) <= E()'), 'ge 10')
911 self.assertEqual(eval('Decimal(10) >= E()'), 'le 10')
912 self.assertEqual(eval('Decimal(10) == E()'), 'eq 10')
913 self.assertEqual(eval('Decimal(10) != E()'), 'ne 10')
914
915 # insert operator methods and then exercise them
916 oplist = [
917 ('+', '__add__', '__radd__'),
918 ('-', '__sub__', '__rsub__'),
919 ('*', '__mul__', '__rmul__'),
920 ('/', '__truediv__', '__rtruediv__'),
921 ('%', '__mod__', '__rmod__'),
922 ('//', '__floordiv__', '__rfloordiv__'),
923 ('**', '__pow__', '__rpow__')
924 ]
925
926 for sym, lop, rop in oplist:
927 setattr(E, lop, lambda self, other: 'str' + lop + str(other))
928 setattr(E, rop, lambda self, other: str(other) + rop + 'str')
929 self.assertEqual(eval('E()' + sym + 'Decimal(10)'),
930 'str' + lop + '10')
931 self.assertEqual(eval('Decimal(10)' + sym + 'E()'),
932 '10' + rop + 'str')
933
934 @requires_cdecimal
935 class CImplicitConstructionTest(ImplicitConstructionTest, unittest.TestCase):
936 decimal = C
937 class PyImplicitConstructionTest(ImplicitConstructionTest, unittest.TestCase):
938 decimal = P
939
940 class FormatTest:
941 '''Unit tests for the format function.'''
942 def test_formatting(self):
943 Decimal = self.decimal.Decimal
944
945 # triples giving a format, a Decimal, and the expected result
946 test_values = [
947 ('e', '0E-15', '0e-15'),
948 ('e', '2.3E-15', '2.3e-15'),
949 ('e', '2.30E+2', '2.30e+2'), # preserve significant zeros
950 ('e', '2.30000E-15', '2.30000e-15'),
951 ('e', '1.23456789123456789e40', '1.23456789123456789e+40'),
952 ('e', '1.5', '1.5e+0'),
953 ('e', '0.15', '1.5e-1'),
954 ('e', '0.015', '1.5e-2'),
955 ('e', '0.0000000000015', '1.5e-12'),
956 ('e', '15.0', '1.50e+1'),
957 ('e', '-15', '-1.5e+1'),
958 ('e', '0', '0e+0'),
959 ('e', '0E1', '0e+1'),
960 ('e', '0.0', '0e-1'),
961 ('e', '0.00', '0e-2'),
962 ('.6e', '0E-15', '0.000000e-9'),
963 ('.6e', '0', '0.000000e+6'),
964 ('.6e', '9.999999', '9.999999e+0'),
965 ('.6e', '9.9999999', '1.000000e+1'),
966 ('.6e', '-1.23e5', '-1.230000e+5'),
967 ('.6e', '1.23456789e-3', '1.234568e-3'),
968 ('f', '0', '0'),
969 ('f', '0.0', '0.0'),
970 ('f', '0E-2', '0.00'),
971 ('f', '0.00E-8', '0.0000000000'),
972 ('f', '0E1', '0'), # loses exponent information
973 ('f', '3.2E1', '32'),
974 ('f', '3.2E2', '320'),
975 ('f', '3.20E2', '320'),
976 ('f', '3.200E2', '320.0'),
977 ('f', '3.2E-6', '0.0000032'),
978 ('.6f', '0E-15', '0.000000'), # all zeros treated equally
979 ('.6f', '0E1', '0.000000'),
980 ('.6f', '0', '0.000000'),
981 ('.0f', '0', '0'), # no decimal point
982 ('.0f', '0e-2', '0'),
983 ('.0f', '3.14159265', '3'),
984 ('.1f', '3.14159265', '3.1'),
985 ('.01f', '3.14159265', '3.1'), # leading zero in precision
986 ('.4f', '3.14159265', '3.1416'),
987 ('.6f', '3.14159265', '3.141593'),
988 ('.7f', '3.14159265', '3.1415926'), # round-half-even!
989 ('.8f', '3.14159265', '3.14159265'),
990 ('.9f', '3.14159265', '3.141592650'),
991
992 ('g', '0', '0'),
993 ('g', '0.0', '0.0'),
994 ('g', '0E1', '0e+1'),
995 ('G', '0E1', '0E+1'),
996 ('g', '0E-5', '0.00000'),
997 ('g', '0E-6', '0.000000'),
998 ('g', '0E-7', '0e-7'),
999 ('g', '-0E2', '-0e+2'),
1000 ('.0g', '3.14159265', '3'), # 0 sig fig -> 1 sig fig
1001 ('.0n', '3.14159265', '3'), # same for 'n'
1002 ('.1g', '3.14159265', '3'),
1003 ('.2g', '3.14159265', '3.1'),
1004 ('.5g', '3.14159265', '3.1416'),
1005 ('.7g', '3.14159265', '3.141593'),
1006 ('.8g', '3.14159265', '3.1415926'), # round-half-even!
1007 ('.9g', '3.14159265', '3.14159265'),
1008 ('.10g', '3.14159265', '3.14159265'), # don't pad
1009
1010 ('%', '0E1', '0%'),
1011 ('%', '0E0', '0%'),
1012 ('%', '0E-1', '0%'),
1013 ('%', '0E-2', '0%'),
1014 ('%', '0E-3', '0.0%'),
1015 ('%', '0E-4', '0.00%'),
1016
1017 ('.3%', '0', '0.000%'), # all zeros treated equally
1018 ('.3%', '0E10', '0.000%'),
1019 ('.3%', '0E-10', '0.000%'),
1020 ('.3%', '2.34', '234.000%'),
1021 ('.3%', '1.234567', '123.457%'),
1022 ('.0%', '1.23', '123%'),
1023
1024 ('e', 'NaN', 'NaN'),
1025 ('f', '-NaN123', '-NaN123'),
1026 ('+g', 'NaN456', '+NaN456'),
1027 ('.3e', 'Inf', 'Infinity'),
1028 ('.16f', '-Inf', '-Infinity'),
1029 ('.0g', '-sNaN', '-sNaN'),
1030
1031 ('', '1.00', '1.00'),
1032
1033 # test alignment and padding
1034 ('6', '123', ' 123'),
1035 ('<6', '123', '123 '),
1036 ('>6', '123', ' 123'),
1037 ('^6', '123', ' 123 '),
1038 ('=+6', '123', '+ 123'),
1039 ('#<10', 'NaN', 'NaN#######'),
1040 ('#<10', '-4.3', '-4.3######'),
1041 ('#<+10', '0.0130', '+0.0130###'),
1042 ('#< 10', '0.0130', ' 0.0130###'),
1043 ('@>10', '-Inf', '@-Infinity'),
1044 ('#>5', '-Inf', '-Infinity'),
1045 ('?^5', '123', '?123?'),
1046 ('%^6', '123', '%123%%'),
1047 (' ^6', '-45.6', '-45.6 '),
1048 ('/=10', '-45.6', '-/////45.6'),
1049 ('/=+10', '45.6', '+/////45.6'),
1050 ('/= 10', '45.6', ' /////45.6'),
1051 ('\x00=10', '-inf', '-\x00Infinity'),
1052 ('\x00^16', '-inf', '\x00\x00\x00-Infinity\x00\x00\x00\x00'),
1053 ('\x00>10', '1.2345', '\x00\x00\x00\x001.2345'),
1054 ('\x00<10', '1.2345', '1.2345\x00\x00\x00\x00'),
1055
1056 # thousands separator
1057 (',', '1234567', '1,234,567'),
1058 (',', '123456', '123,456'),
1059 (',', '12345', '12,345'),
1060 (',', '1234', '1,234'),
1061 (',', '123', '123'),
1062 (',', '12', '12'),
1063 (',', '1', '1'),
1064 (',', '0', '0'),
1065 (',', '-1234567', '-1,234,567'),
1066 (',', '-123456', '-123,456'),
1067 ('7,', '123456', '123,456'),
1068 ('8,', '123456', ' 123,456'),
1069 ('08,', '123456', '0,123,456'), # special case: extra 0 needed
1070 ('+08,', '123456', '+123,456'), # but not if there's a sign
1071 ('008,', '123456', '0,123,456'), # leading zero in width
1072 (' 08,', '123456', ' 123,456'),
1073 ('08,', '-123456', '-123,456'),
1074 ('+09,', '123456', '+0,123,456'),
1075 # ... with fractional part...
1076 ('07,', '1234.56', '1,234.56'),
1077 ('08,', '1234.56', '1,234.56'),
1078 ('09,', '1234.56', '01,234.56'),
1079 ('010,', '1234.56', '001,234.56'),
1080 ('011,', '1234.56', '0,001,234.56'),
1081 ('012,', '1234.56', '0,001,234.56'),
1082 ('08,.1f', '1234.5', '01,234.5'),
1083 # no thousands separators in fraction part
1084 (',', '1.23456789', '1.23456789'),
1085 (',%', '123.456789', '12,345.6789%'),
1086 (',e', '123456', '1.23456e+5'),
1087 (',E', '123456', '1.23456E+5'),
1088 # ... with '_' instead
1089 ('_', '1234567', '1_234_567'),
1090 ('07_', '1234.56', '1_234.56'),
1091 ('_', '1.23456789', '1.23456789'),
1092 ('_%', '123.456789', '12_345.6789%'),
1093 # and now for something completely different...
1094 ('.,', '1.23456789', '1.234,567,89'),
1095 ('._', '1.23456789', '1.234_567_89'),
1096 ('.6_f', '12345.23456789', '12345.234_568'),
1097 (',._%', '123.456789', '12,345.678_9%'),
1098 (',._e', '123456', '1.234_56e+5'),
1099 (',.4_e', '123456', '1.234_6e+5'),
1100 (',.3_e', '123456', '1.235e+5'),
1101 (',._E', '123456', '1.234_56E+5'),
1102
1103 # negative zero: default behavior
1104 ('.1f', '-0', '-0.0'),
1105 ('.1f', '-.0', '-0.0'),
1106 ('.1f', '-.01', '-0.0'),
1107
1108 # negative zero: z option
1109 ('z.1f', '0.', '0.0'),
1110 ('z6.1f', '0.', ' 0.0'),
1111 ('z6.1f', '-1.', ' -1.0'),
1112 ('z.1f', '-0.', '0.0'),
1113 ('z.1f', '.01', '0.0'),
1114 ('z.1f', '-.01', '0.0'),
1115 ('z.2f', '0.', '0.00'),
1116 ('z.2f', '-0.', '0.00'),
1117 ('z.2f', '.001', '0.00'),
1118 ('z.2f', '-.001', '0.00'),
1119
1120 ('z.1e', '0.', '0.0e+1'),
1121 ('z.1e', '-0.', '0.0e+1'),
1122 ('z.1E', '0.', '0.0E+1'),
1123 ('z.1E', '-0.', '0.0E+1'),
1124
1125 ('z.2e', '-0.001', '-1.00e-3'), # tests for mishandled rounding
1126 ('z.2g', '-0.001', '-0.001'),
1127 ('z.2%', '-0.001', '-0.10%'),
1128
1129 ('zf', '-0.0000', '0.0000'), # non-normalized form is preserved
1130
1131 ('z.1f', '-00000.000001', '0.0'),
1132 ('z.1f', '-00000.', '0.0'),
1133 ('z.1f', '-.0000000000', '0.0'),
1134
1135 ('z.2f', '-00000.000001', '0.00'),
1136 ('z.2f', '-00000.', '0.00'),
1137 ('z.2f', '-.0000000000', '0.00'),
1138
1139 ('z.1f', '.09', '0.1'),
1140 ('z.1f', '-.09', '-0.1'),
1141
1142 (' z.0f', '-0.', ' 0'),
1143 ('+z.0f', '-0.', '+0'),
1144 ('-z.0f', '-0.', '0'),
1145 (' z.0f', '-1.', '-1'),
1146 ('+z.0f', '-1.', '-1'),
1147 ('-z.0f', '-1.', '-1'),
1148
1149 ('z>6.1f', '-0.', 'zz-0.0'),
1150 ('z>z6.1f', '-0.', 'zzz0.0'),
1151 ('x>z6.1f', '-0.', 'xxx0.0'),
1152 ('🖤>z6.1f', '-0.', '🖤🖤🖤0.0'), # multi-byte fill char
1153 ('\x00>z6.1f', '-0.', '\x00\x00\x000.0'), # null fill char
1154
1155 # issue 114563 ('z' format on F type in cdecimal)
1156 ('z3,.10F', '-6.24E-323', '0.0000000000'),
1157
1158 # issue 91060 ('#' format in cdecimal)
1159 ('#', '0', '0.'),
1160
1161 # issue 6850
1162 ('a=-7.0', '0.12345', 'aaaa0.1'),
1163
1164 # issue 22090
1165 ('<^+15.20%', 'inf', '<<+Infinity%<<<'),
1166 ('\x07>,%', 'sNaN1234567', 'sNaN1234567%'),
1167 ('=10.10%', 'NaN123', ' NaN123%'),
1168 ]
1169 for fmt, d, result in test_values:
1170 self.assertEqual(format(Decimal(d), fmt), result)
1171
1172 # bytes format argument
1173 self.assertRaises(TypeError, Decimal(1).__format__, b'-020')
1174
1175 # precision or fractional part separator should follow after dot
1176 self.assertRaises(ValueError, format, Decimal(1), '.f')
1177 self.assertRaises(ValueError, format, Decimal(1), '._6f')
1178
1179 def test_negative_zero_format_directed_rounding(self):
1180 with self.decimal.localcontext() as ctx:
1181 ctx.rounding = ROUND_CEILING
1182 self.assertEqual(format(self.decimal.Decimal('-0.001'), 'z.2f'),
1183 '0.00')
1184
1185 def test_negative_zero_bad_format(self):
1186 self.assertRaises(ValueError, format, self.decimal.Decimal('1.23'), 'fz')
1187
1188 def test_n_format(self):
1189 Decimal = self.decimal.Decimal
1190
1191 try:
1192 from locale import CHAR_MAX
1193 except ImportError:
1194 self.skipTest('locale.CHAR_MAX not available')
1195
1196 def make_grouping(lst):
1197 return ''.join([chr(x) for x in lst]) if self.decimal == C else lst
1198
1199 def get_fmt(x, override=None, fmt='n'):
1200 if self.decimal == C:
1201 return Decimal(x).__format__(fmt, override)
1202 else:
1203 return Decimal(x).__format__(fmt, _localeconv=override)
1204
1205 # Set up some localeconv-like dictionaries
1206 en_US = {
1207 'decimal_point' : '.',
1208 'grouping' : make_grouping([3, 3, 0]),
1209 'thousands_sep' : ','
1210 }
1211
1212 fr_FR = {
1213 'decimal_point' : ',',
1214 'grouping' : make_grouping([CHAR_MAX]),
1215 'thousands_sep' : ''
1216 }
1217
1218 ru_RU = {
1219 'decimal_point' : ',',
1220 'grouping': make_grouping([3, 3, 0]),
1221 'thousands_sep' : ' '
1222 }
1223
1224 crazy = {
1225 'decimal_point' : '&',
1226 'grouping': make_grouping([1, 4, 2, CHAR_MAX]),
1227 'thousands_sep' : '-'
1228 }
1229
1230 dotsep_wide = {
1231 'decimal_point' : b'\xc2\xbf'.decode('utf-8'),
1232 'grouping': make_grouping([3, 3, 0]),
1233 'thousands_sep' : b'\xc2\xb4'.decode('utf-8')
1234 }
1235
1236 self.assertEqual(get_fmt(Decimal('12.7'), en_US), '12.7')
1237 self.assertEqual(get_fmt(Decimal('12.7'), fr_FR), '12,7')
1238 self.assertEqual(get_fmt(Decimal('12.7'), ru_RU), '12,7')
1239 self.assertEqual(get_fmt(Decimal('12.7'), crazy), '1-2&7')
1240
1241 self.assertEqual(get_fmt(123456789, en_US), '123,456,789')
1242 self.assertEqual(get_fmt(123456789, fr_FR), '123456789')
1243 self.assertEqual(get_fmt(123456789, ru_RU), '123 456 789')
1244 self.assertEqual(get_fmt(1234567890123, crazy), '123456-78-9012-3')
1245
1246 self.assertEqual(get_fmt(123456789, en_US, '.6n'), '1.23457e+8')
1247 self.assertEqual(get_fmt(123456789, fr_FR, '.6n'), '1,23457e+8')
1248 self.assertEqual(get_fmt(123456789, ru_RU, '.6n'), '1,23457e+8')
1249 self.assertEqual(get_fmt(123456789, crazy, '.6n'), '1&23457e+8')
1250
1251 # zero padding
1252 self.assertEqual(get_fmt(1234, fr_FR, '03n'), '1234')
1253 self.assertEqual(get_fmt(1234, fr_FR, '04n'), '1234')
1254 self.assertEqual(get_fmt(1234, fr_FR, '05n'), '01234')
1255 self.assertEqual(get_fmt(1234, fr_FR, '06n'), '001234')
1256
1257 self.assertEqual(get_fmt(12345, en_US, '05n'), '12,345')
1258 self.assertEqual(get_fmt(12345, en_US, '06n'), '12,345')
1259 self.assertEqual(get_fmt(12345, en_US, '07n'), '012,345')
1260 self.assertEqual(get_fmt(12345, en_US, '08n'), '0,012,345')
1261 self.assertEqual(get_fmt(12345, en_US, '09n'), '0,012,345')
1262 self.assertEqual(get_fmt(12345, en_US, '010n'), '00,012,345')
1263
1264 self.assertEqual(get_fmt(123456, crazy, '06n'), '1-2345-6')
1265 self.assertEqual(get_fmt(123456, crazy, '07n'), '1-2345-6')
1266 self.assertEqual(get_fmt(123456, crazy, '08n'), '1-2345-6')
1267 self.assertEqual(get_fmt(123456, crazy, '09n'), '01-2345-6')
1268 self.assertEqual(get_fmt(123456, crazy, '010n'), '0-01-2345-6')
1269 self.assertEqual(get_fmt(123456, crazy, '011n'), '0-01-2345-6')
1270 self.assertEqual(get_fmt(123456, crazy, '012n'), '00-01-2345-6')
1271 self.assertEqual(get_fmt(123456, crazy, '013n'), '000-01-2345-6')
1272
1273 # wide char separator and decimal point
1274 self.assertEqual(get_fmt(Decimal('-1.5'), dotsep_wide, '020n'),
1275 '-0\u00b4000\u00b4000\u00b4000\u00b4001\u00bf5')
1276
1277 def test_deprecated_N_format(self):
1278 Decimal = self.decimal.Decimal
1279 h = Decimal('6.62607015e-34')
1280 if self.decimal == C:
1281 with self.assertWarns(DeprecationWarning) as cm:
1282 r = format(h, 'N')
1283 self.assertEqual(cm.filename, __file__)
1284 self.assertEqual(r, format(h, 'n').upper())
1285 with self.assertWarns(DeprecationWarning) as cm:
1286 r = format(h, '010.3N')
1287 self.assertEqual(cm.filename, __file__)
1288 self.assertEqual(r, format(h, '010.3n').upper())
1289 else:
1290 self.assertRaises(ValueError, format, h, 'N')
1291 self.assertRaises(ValueError, format, h, '010.3N')
1292 with warnings_helper.check_no_warnings(self):
1293 self.assertEqual(format(h, 'N>10.3'), 'NN6.63E-34')
1294 self.assertEqual(format(h, 'N>10.3n'), 'NN6.63e-34')
1295 self.assertEqual(format(h, 'N>10.3e'), 'N6.626e-34')
1296 self.assertEqual(format(h, 'N>10.3f'), 'NNNNN0.000')
1297 self.assertRaises(ValueError, format, h, '>Nf')
1298 self.assertRaises(ValueError, format, h, '10Nf')
1299 self.assertRaises(ValueError, format, h, 'Nx')
1300
1301 @run_with_locale('LC_ALL', 'ps_AF', '')
1302 def test_wide_char_separator_decimal_point(self):
1303 # locale with wide char separator and decimal point
1304 Decimal = self.decimal.Decimal
1305
1306 decimal_point = locale.localeconv()['decimal_point']
1307 thousands_sep = locale.localeconv()['thousands_sep']
1308 if decimal_point != '\u066b':
1309 self.skipTest('inappropriate decimal point separator '
1310 '({!a} not {!a})'.format(decimal_point, '\u066b'))
1311 if thousands_sep != '\u066c':
1312 self.skipTest('inappropriate thousands separator '
1313 '({!a} not {!a})'.format(thousands_sep, '\u066c'))
1314
1315 self.assertEqual(format(Decimal('100000000.123'), 'n'),
1316 '100\u066c000\u066c000\u066b123')
1317
1318 def test_decimal_from_float_argument_type(self):
1319 class A(self.decimal.Decimal):
1320 def __init__(self, a):
1321 self.a_type = type(a)
1322 a = A.from_float(42.5)
1323 self.assertEqual(self.decimal.Decimal, a.a_type)
1324
1325 a = A.from_float(42)
1326 self.assertEqual(self.decimal.Decimal, a.a_type)
1327
1328 @requires_cdecimal
1329 class CFormatTest(FormatTest, unittest.TestCase):
1330 decimal = C
1331 class PyFormatTest(FormatTest, unittest.TestCase):
1332 decimal = P
1333
1334 class ArithmeticOperatorsTest:
1335 '''Unit tests for all arithmetic operators, binary and unary.'''
1336
1337 def test_addition(self):
1338 Decimal = self.decimal.Decimal
1339
1340 d1 = Decimal('-11.1')
1341 d2 = Decimal('22.2')
1342
1343 #two Decimals
1344 self.assertEqual(d1+d2, Decimal('11.1'))
1345 self.assertEqual(d2+d1, Decimal('11.1'))
1346
1347 #with other type, left
1348 c = d1 + 5
1349 self.assertEqual(c, Decimal('-6.1'))
1350 self.assertEqual(type(c), type(d1))
1351
1352 #with other type, right
1353 c = 5 + d1
1354 self.assertEqual(c, Decimal('-6.1'))
1355 self.assertEqual(type(c), type(d1))
1356
1357 #inline with decimal
1358 d1 += d2
1359 self.assertEqual(d1, Decimal('11.1'))
1360
1361 #inline with other type
1362 d1 += 5
1363 self.assertEqual(d1, Decimal('16.1'))
1364
1365 def test_subtraction(self):
1366 Decimal = self.decimal.Decimal
1367
1368 d1 = Decimal('-11.1')
1369 d2 = Decimal('22.2')
1370
1371 #two Decimals
1372 self.assertEqual(d1-d2, Decimal('-33.3'))
1373 self.assertEqual(d2-d1, Decimal('33.3'))
1374
1375 #with other type, left
1376 c = d1 - 5
1377 self.assertEqual(c, Decimal('-16.1'))
1378 self.assertEqual(type(c), type(d1))
1379
1380 #with other type, right
1381 c = 5 - d1
1382 self.assertEqual(c, Decimal('16.1'))
1383 self.assertEqual(type(c), type(d1))
1384
1385 #inline with decimal
1386 d1 -= d2
1387 self.assertEqual(d1, Decimal('-33.3'))
1388
1389 #inline with other type
1390 d1 -= 5
1391 self.assertEqual(d1, Decimal('-38.3'))
1392
1393 def test_multiplication(self):
1394 Decimal = self.decimal.Decimal
1395
1396 d1 = Decimal('-5')
1397 d2 = Decimal('3')
1398
1399 #two Decimals
1400 self.assertEqual(d1*d2, Decimal('-15'))
1401 self.assertEqual(d2*d1, Decimal('-15'))
1402
1403 #with other type, left
1404 c = d1 * 5
1405 self.assertEqual(c, Decimal('-25'))
1406 self.assertEqual(type(c), type(d1))
1407
1408 #with other type, right
1409 c = 5 * d1
1410 self.assertEqual(c, Decimal('-25'))
1411 self.assertEqual(type(c), type(d1))
1412
1413 #inline with decimal
1414 d1 *= d2
1415 self.assertEqual(d1, Decimal('-15'))
1416
1417 #inline with other type
1418 d1 *= 5
1419 self.assertEqual(d1, Decimal('-75'))
1420
1421 def test_division(self):
1422 Decimal = self.decimal.Decimal
1423
1424 d1 = Decimal('-5')
1425 d2 = Decimal('2')
1426
1427 #two Decimals
1428 self.assertEqual(d1/d2, Decimal('-2.5'))
1429 self.assertEqual(d2/d1, Decimal('-0.4'))
1430
1431 #with other type, left
1432 c = d1 / 4
1433 self.assertEqual(c, Decimal('-1.25'))
1434 self.assertEqual(type(c), type(d1))
1435
1436 #with other type, right
1437 c = 4 / d1
1438 self.assertEqual(c, Decimal('-0.8'))
1439 self.assertEqual(type(c), type(d1))
1440
1441 #inline with decimal
1442 d1 /= d2
1443 self.assertEqual(d1, Decimal('-2.5'))
1444
1445 #inline with other type
1446 d1 /= 4
1447 self.assertEqual(d1, Decimal('-0.625'))
1448
1449 def test_floor_division(self):
1450 Decimal = self.decimal.Decimal
1451
1452 d1 = Decimal('5')
1453 d2 = Decimal('2')
1454
1455 #two Decimals
1456 self.assertEqual(d1//d2, Decimal('2'))
1457 self.assertEqual(d2//d1, Decimal('0'))
1458
1459 #with other type, left
1460 c = d1 // 4
1461 self.assertEqual(c, Decimal('1'))
1462 self.assertEqual(type(c), type(d1))
1463
1464 #with other type, right
1465 c = 7 // d1
1466 self.assertEqual(c, Decimal('1'))
1467 self.assertEqual(type(c), type(d1))
1468
1469 #inline with decimal
1470 d1 //= d2
1471 self.assertEqual(d1, Decimal('2'))
1472
1473 #inline with other type
1474 d1 //= 2
1475 self.assertEqual(d1, Decimal('1'))
1476
1477 def test_powering(self):
1478 Decimal = self.decimal.Decimal
1479
1480 d1 = Decimal('5')
1481 d2 = Decimal('2')
1482
1483 #two Decimals
1484 self.assertEqual(d1**d2, Decimal('25'))
1485 self.assertEqual(d2**d1, Decimal('32'))
1486
1487 #with other type, left
1488 c = d1 ** 4
1489 self.assertEqual(c, Decimal('625'))
1490 self.assertEqual(type(c), type(d1))
1491
1492 #with other type, right
1493 c = 7 ** d1
1494 self.assertEqual(c, Decimal('16807'))
1495 self.assertEqual(type(c), type(d1))
1496
1497 #inline with decimal
1498 d1 **= d2
1499 self.assertEqual(d1, Decimal('25'))
1500
1501 #inline with other type
1502 d1 **= 4
1503 self.assertEqual(d1, Decimal('390625'))
1504
1505 def test_module(self):
1506 Decimal = self.decimal.Decimal
1507
1508 d1 = Decimal('5')
1509 d2 = Decimal('2')
1510
1511 #two Decimals
1512 self.assertEqual(d1%d2, Decimal('1'))
1513 self.assertEqual(d2%d1, Decimal('2'))
1514
1515 #with other type, left
1516 c = d1 % 4
1517 self.assertEqual(c, Decimal('1'))
1518 self.assertEqual(type(c), type(d1))
1519
1520 #with other type, right
1521 c = 7 % d1
1522 self.assertEqual(c, Decimal('2'))
1523 self.assertEqual(type(c), type(d1))
1524
1525 #inline with decimal
1526 d1 %= d2
1527 self.assertEqual(d1, Decimal('1'))
1528
1529 #inline with other type
1530 d1 %= 4
1531 self.assertEqual(d1, Decimal('1'))
1532
1533 def test_floor_div_module(self):
1534 Decimal = self.decimal.Decimal
1535
1536 d1 = Decimal('5')
1537 d2 = Decimal('2')
1538
1539 #two Decimals
1540 (p, q) = divmod(d1, d2)
1541 self.assertEqual(p, Decimal('2'))
1542 self.assertEqual(q, Decimal('1'))
1543 self.assertEqual(type(p), type(d1))
1544 self.assertEqual(type(q), type(d1))
1545
1546 #with other type, left
1547 (p, q) = divmod(d1, 4)
1548 self.assertEqual(p, Decimal('1'))
1549 self.assertEqual(q, Decimal('1'))
1550 self.assertEqual(type(p), type(d1))
1551 self.assertEqual(type(q), type(d1))
1552
1553 #with other type, right
1554 (p, q) = divmod(7, d1)
1555 self.assertEqual(p, Decimal('1'))
1556 self.assertEqual(q, Decimal('2'))
1557 self.assertEqual(type(p), type(d1))
1558 self.assertEqual(type(q), type(d1))
1559
1560 def test_unary_operators(self):
1561 Decimal = self.decimal.Decimal
1562
1563 self.assertEqual(+Decimal(45), Decimal(+45)) # +
1564 self.assertEqual(-Decimal(45), Decimal(-45)) # -
1565 self.assertEqual(abs(Decimal(45)), abs(Decimal(-45))) # abs
1566
1567 def test_nan_comparisons(self):
1568 # comparisons involving signaling nans signal InvalidOperation
1569
1570 # order comparisons (<, <=, >, >=) involving only quiet nans
1571 # also signal InvalidOperation
1572
1573 # equality comparisons (==, !=) involving only quiet nans
1574 # don't signal, but return False or True respectively.
1575 Decimal = self.decimal.Decimal
1576 InvalidOperation = self.decimal.InvalidOperation
1577 localcontext = self.decimal.localcontext
1578
1579 n = Decimal('NaN')
1580 s = Decimal('sNaN')
1581 i = Decimal('Inf')
1582 f = Decimal('2')
1583
1584 qnan_pairs = (n, n), (n, i), (i, n), (n, f), (f, n)
1585 snan_pairs = (s, n), (n, s), (s, i), (i, s), (s, f), (f, s), (s, s)
1586 order_ops = operator.lt, operator.le, operator.gt, operator.ge
1587 equality_ops = operator.eq, operator.ne
1588
1589 # results when InvalidOperation is not trapped
1590 with localcontext() as ctx:
1591 ctx.traps[InvalidOperation] = 0
1592
1593 for x, y in qnan_pairs + snan_pairs:
1594 for op in order_ops + equality_ops:
1595 got = op(x, y)
1596 expected = True if op is operator.ne else False
1597 self.assertIs(expected, got,
1598 "expected {0!r} for operator.{1}({2!r}, {3!r}); "
1599 "got {4!r}".format(
1600 expected, op.__name__, x, y, got))
1601
1602 # repeat the above, but this time trap the InvalidOperation
1603 with localcontext() as ctx:
1604 ctx.traps[InvalidOperation] = 1
1605
1606 for x, y in qnan_pairs:
1607 for op in equality_ops:
1608 got = op(x, y)
1609 expected = True if op is operator.ne else False
1610 self.assertIs(expected, got,
1611 "expected {0!r} for "
1612 "operator.{1}({2!r}, {3!r}); "
1613 "got {4!r}".format(
1614 expected, op.__name__, x, y, got))
1615
1616 for x, y in snan_pairs:
1617 for op in equality_ops:
1618 self.assertRaises(InvalidOperation, operator.eq, x, y)
1619 self.assertRaises(InvalidOperation, operator.ne, x, y)
1620
1621 for x, y in qnan_pairs + snan_pairs:
1622 for op in order_ops:
1623 self.assertRaises(InvalidOperation, op, x, y)
1624
1625 def test_copy_sign(self):
1626 Decimal = self.decimal.Decimal
1627
1628 d = Decimal(1).copy_sign(Decimal(-2))
1629 self.assertEqual(Decimal(1).copy_sign(-2), d)
1630 self.assertRaises(TypeError, Decimal(1).copy_sign, '-2')
1631
1632 @requires_cdecimal
1633 class CArithmeticOperatorsTest(ArithmeticOperatorsTest, unittest.TestCase):
1634 decimal = C
1635 class PyArithmeticOperatorsTest(ArithmeticOperatorsTest, unittest.TestCase):
1636 decimal = P
1637
1638 # The following are two functions used to test threading in the next class
1639
1640 def thfunc1(cls):
1641 Decimal = cls.decimal.Decimal
1642 InvalidOperation = cls.decimal.InvalidOperation
1643 DivisionByZero = cls.decimal.DivisionByZero
1644 Overflow = cls.decimal.Overflow
1645 Underflow = cls.decimal.Underflow
1646 Inexact = cls.decimal.Inexact
1647 getcontext = cls.decimal.getcontext
1648 localcontext = cls.decimal.localcontext
1649
1650 d1 = Decimal(1)
1651 d3 = Decimal(3)
1652 test1 = d1/d3
1653
1654 cls.finish1.set()
1655 cls.synchro.wait()
1656
1657 test2 = d1/d3
1658 with localcontext() as c2:
1659 cls.assertTrue(c2.flags[Inexact])
1660 cls.assertRaises(DivisionByZero, c2.divide, d1, 0)
1661 cls.assertTrue(c2.flags[DivisionByZero])
1662 with localcontext() as c3:
1663 cls.assertTrue(c3.flags[Inexact])
1664 cls.assertTrue(c3.flags[DivisionByZero])
1665 cls.assertRaises(InvalidOperation, c3.compare, d1, Decimal('sNaN'))
1666 cls.assertTrue(c3.flags[InvalidOperation])
1667 del c3
1668 cls.assertFalse(c2.flags[InvalidOperation])
1669 del c2
1670
1671 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1672 cls.assertEqual(test2, Decimal('0.333333333333333333333333'))
1673
1674 c1 = getcontext()
1675 cls.assertTrue(c1.flags[Inexact])
1676 for sig in Overflow, Underflow, DivisionByZero, InvalidOperation:
1677 cls.assertFalse(c1.flags[sig])
1678
1679 def thfunc2(cls):
1680 Decimal = cls.decimal.Decimal
1681 InvalidOperation = cls.decimal.InvalidOperation
1682 DivisionByZero = cls.decimal.DivisionByZero
1683 Overflow = cls.decimal.Overflow
1684 Underflow = cls.decimal.Underflow
1685 Inexact = cls.decimal.Inexact
1686 getcontext = cls.decimal.getcontext
1687 localcontext = cls.decimal.localcontext
1688
1689 d1 = Decimal(1)
1690 d3 = Decimal(3)
1691 test1 = d1/d3
1692
1693 thiscontext = getcontext()
1694 thiscontext.prec = 18
1695 test2 = d1/d3
1696
1697 with localcontext() as c2:
1698 cls.assertTrue(c2.flags[Inexact])
1699 cls.assertRaises(Overflow, c2.multiply, Decimal('1e425000000'), 999)
1700 cls.assertTrue(c2.flags[Overflow])
1701 with localcontext(thiscontext) as c3:
1702 cls.assertTrue(c3.flags[Inexact])
1703 cls.assertFalse(c3.flags[Overflow])
1704 c3.traps[Underflow] = True
1705 cls.assertRaises(Underflow, c3.divide, Decimal('1e-425000000'), 999)
1706 cls.assertTrue(c3.flags[Underflow])
1707 del c3
1708 cls.assertFalse(c2.flags[Underflow])
1709 cls.assertFalse(c2.traps[Underflow])
1710 del c2
1711
1712 cls.synchro.set()
1713 cls.finish2.set()
1714
1715 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1716 cls.assertEqual(test2, Decimal('0.333333333333333333'))
1717
1718 cls.assertFalse(thiscontext.traps[Underflow])
1719 cls.assertTrue(thiscontext.flags[Inexact])
1720 for sig in Overflow, Underflow, DivisionByZero, InvalidOperation:
1721 cls.assertFalse(thiscontext.flags[sig])
1722
1723
1724 @threading_helper.requires_working_threading()
1725 class ThreadingTest:
1726 '''Unit tests for thread local contexts in Decimal.'''
1727
1728 # Take care executing this test from IDLE, there's an issue in threading
1729 # that hangs IDLE and I couldn't find it
1730
1731 def test_threading(self):
1732 DefaultContext = self.decimal.DefaultContext
1733
1734 if self.decimal == C and not self.decimal.HAVE_THREADS:
1735 self.skipTest("compiled without threading")
1736 # Test the "threading isolation" of a Context. Also test changing
1737 # the DefaultContext, which acts as a template for the thread-local
1738 # contexts.
1739 save_prec = DefaultContext.prec
1740 save_emax = DefaultContext.Emax
1741 save_emin = DefaultContext.Emin
1742 DefaultContext.prec = 24
1743 DefaultContext.Emax = 425000000
1744 DefaultContext.Emin = -425000000
1745
1746 self.synchro = threading.Event()
1747 self.finish1 = threading.Event()
1748 self.finish2 = threading.Event()
1749
1750 # This test wants to start threads with an empty context, no matter
1751 # the setting of sys.flags.thread_inherit_context. We pass the
1752 # 'context' argument explicitly with an empty context instance.
1753 th1 = threading.Thread(target=thfunc1, args=(self,),
1754 context=contextvars.Context())
1755 th2 = threading.Thread(target=thfunc2, args=(self,),
1756 context=contextvars.Context())
1757
1758 th1.start()
1759 th2.start()
1760
1761 self.finish1.wait()
1762 self.finish2.wait()
1763
1764 for sig in Signals[self.decimal]:
1765 self.assertFalse(DefaultContext.flags[sig])
1766
1767 th1.join()
1768 th2.join()
1769
1770 DefaultContext.prec = save_prec
1771 DefaultContext.Emax = save_emax
1772 DefaultContext.Emin = save_emin
1773
1774
1775 @requires_cdecimal
1776 class CThreadingTest(ThreadingTest, unittest.TestCase):
1777 decimal = C
1778
1779 class PyThreadingTest(ThreadingTest, unittest.TestCase):
1780 decimal = P
1781
1782 class UsabilityTest:
1783 '''Unit tests for Usability cases of Decimal.'''
1784
1785 def test_comparison_operators(self):
1786
1787 Decimal = self.decimal.Decimal
1788
1789 da = Decimal('23.42')
1790 db = Decimal('23.42')
1791 dc = Decimal('45')
1792
1793 #two Decimals
1794 self.assertGreater(dc, da)
1795 self.assertGreaterEqual(dc, da)
1796 self.assertLess(da, dc)
1797 self.assertLessEqual(da, dc)
1798 self.assertEqual(da, db)
1799 self.assertNotEqual(da, dc)
1800 self.assertLessEqual(da, db)
1801 self.assertGreaterEqual(da, db)
1802
1803 #a Decimal and an int
1804 self.assertGreater(dc, 23)
1805 self.assertLess(23, dc)
1806 self.assertEqual(dc, 45)
1807
1808 #a Decimal and uncomparable
1809 self.assertNotEqual(da, 'ugly')
1810 self.assertNotEqual(da, 32.7)
1811 self.assertNotEqual(da, object())
1812 self.assertNotEqual(da, object)
1813
1814 # sortable
1815 a = list(map(Decimal, range(100)))
1816 b = a[:]
1817 random.shuffle(a)
1818 a.sort()
1819 self.assertEqual(a, b)
1820
1821 def test_decimal_float_comparison(self):
1822 Decimal = self.decimal.Decimal
1823
1824 da = Decimal('0.25')
1825 db = Decimal('3.0')
1826 self.assertLess(da, 3.0)
1827 self.assertLessEqual(da, 3.0)
1828 self.assertGreater(db, 0.25)
1829 self.assertGreaterEqual(db, 0.25)
1830 self.assertNotEqual(da, 1.5)
1831 self.assertEqual(da, 0.25)
1832 self.assertGreater(3.0, da)
1833 self.assertGreaterEqual(3.0, da)
1834 self.assertLess(0.25, db)
1835 self.assertLessEqual(0.25, db)
1836 self.assertNotEqual(0.25, db)
1837 self.assertEqual(3.0, db)
1838 self.assertNotEqual(0.1, Decimal('0.1'))
1839
1840 def test_decimal_complex_comparison(self):
1841 Decimal = self.decimal.Decimal
1842
1843 da = Decimal('0.25')
1844 db = Decimal('3.0')
1845 self.assertNotEqual(da, (1.5+0j))
1846 self.assertNotEqual((1.5+0j), da)
1847 self.assertEqual(da, (0.25+0j))
1848 self.assertEqual((0.25+0j), da)
1849 self.assertEqual((3.0+0j), db)
1850 self.assertEqual(db, (3.0+0j))
1851
1852 self.assertNotEqual(db, (3.0+1j))
1853 self.assertNotEqual((3.0+1j), db)
1854
1855 self.assertIs(db.__lt__(3.0+0j), NotImplemented)
1856 self.assertIs(db.__le__(3.0+0j), NotImplemented)
1857 self.assertIs(db.__gt__(3.0+0j), NotImplemented)
1858 self.assertIs(db.__le__(3.0+0j), NotImplemented)
1859
1860 def test_decimal_fraction_comparison(self):
1861 D = self.decimal.Decimal
1862 F = fractions[self.decimal].Fraction
1863 Context = self.decimal.Context
1864 localcontext = self.decimal.localcontext
1865 InvalidOperation = self.decimal.InvalidOperation
1866
1867
1868 emax = C.MAX_EMAX if C else 999999999
1869 emin = C.MIN_EMIN if C else -999999999
1870 etiny = C.MIN_ETINY if C else -1999999997
1871 c = Context(Emax=emax, Emin=emin)
1872
1873 with localcontext(c):
1874 c.prec = emax
1875 self.assertLess(D(0), F(1,9999999999999999999999999999999999999))
1876 self.assertLess(F(-1,9999999999999999999999999999999999999), D(0))
1877 self.assertLess(F(0,1), D("1e" + str(etiny)))
1878 self.assertLess(D("-1e" + str(etiny)), F(0,1))
1879 self.assertLess(F(0,9999999999999999999999999), D("1e" + str(etiny)))
1880 self.assertLess(D("-1e" + str(etiny)), F(0,9999999999999999999999999))
1881
1882 self.assertEqual(D("0.1"), F(1,10))
1883 self.assertEqual(F(1,10), D("0.1"))
1884
1885 c.prec = 300
1886 self.assertNotEqual(D(1)/3, F(1,3))
1887 self.assertNotEqual(F(1,3), D(1)/3)
1888
1889 self.assertLessEqual(F(120984237, 9999999999), D("9e" + str(emax)))
1890 self.assertGreaterEqual(D("9e" + str(emax)), F(120984237, 9999999999))
1891
1892 self.assertGreater(D('inf'), F(99999999999,123))
1893 self.assertGreater(D('inf'), F(-99999999999,123))
1894 self.assertLess(D('-inf'), F(99999999999,123))
1895 self.assertLess(D('-inf'), F(-99999999999,123))
1896
1897 self.assertRaises(InvalidOperation, D('nan').__gt__, F(-9,123))
1898 self.assertIs(NotImplemented, F(-9,123).__lt__(D('nan')))
1899 self.assertNotEqual(D('nan'), F(-9,123))
1900 self.assertNotEqual(F(-9,123), D('nan'))
1901
1902 def test_copy_and_deepcopy_methods(self):
1903 Decimal = self.decimal.Decimal
1904
1905 d = Decimal('43.24')
1906 c = copy.copy(d)
1907 self.assertEqual(id(c), id(d))
1908 dc = copy.deepcopy(d)
1909 self.assertEqual(id(dc), id(d))
1910
1911 def test_hash_method(self):
1912
1913 Decimal = self.decimal.Decimal
1914 localcontext = self.decimal.localcontext
1915
1916 def hashit(d):
1917 a = hash(d)
1918 b = d.__hash__()
1919 self.assertEqual(a, b)
1920 return a
1921
1922 #just that it's hashable
1923 hashit(Decimal(23))
1924 hashit(Decimal('Infinity'))
1925 hashit(Decimal('-Infinity'))
1926 hashit(Decimal('nan123'))
1927 hashit(Decimal('-NaN'))
1928
1929 test_values = [Decimal(sign*(2**m + n))
1930 for m in [0, 14, 15, 16, 17, 30, 31,
1931 32, 33, 61, 62, 63, 64, 65, 66]
1932 for n in range(-10, 10)
1933 for sign in [-1, 1]]
1934 test_values.extend([
1935 Decimal("-1"), # ==> -2
1936 Decimal("-0"), # zeros
1937 Decimal("0.00"),
1938 Decimal("-0.000"),
1939 Decimal("0E10"),
1940 Decimal("-0E12"),
1941 Decimal("10.0"), # negative exponent
1942 Decimal("-23.00000"),
1943 Decimal("1230E100"), # positive exponent
1944 Decimal("-4.5678E50"),
1945 # a value for which hash(n) != hash(n % (2**64-1))
1946 # in Python pre-2.6
1947 Decimal(2**64 + 2**32 - 1),
1948 # selection of values which fail with the old (before
1949 # version 2.6) long.__hash__
1950 Decimal("1.634E100"),
1951 Decimal("90.697E100"),
1952 Decimal("188.83E100"),
1953 Decimal("1652.9E100"),
1954 Decimal("56531E100"),
1955 ])
1956
1957 # check that hash(d) == hash(int(d)) for integral values
1958 for value in test_values:
1959 self.assertEqual(hashit(value), hash(int(value)))
1960
1961 # check that the hashes of a Decimal float match when they
1962 # represent exactly the same values
1963 test_strings = ['inf', '-Inf', '0.0', '-.0e1',
1964 '34.0', '2.5', '112390.625', '-0.515625']
1965 for s in test_strings:
1966 f = float(s)
1967 d = Decimal(s)
1968 self.assertEqual(hashit(d), hash(f))
1969
1970 with localcontext() as c:
1971 # check that the value of the hash doesn't depend on the
1972 # current context (issue #1757)
1973 x = Decimal("123456789.1")
1974
1975 c.prec = 6
1976 h1 = hashit(x)
1977 c.prec = 10
1978 h2 = hashit(x)
1979 c.prec = 16
1980 h3 = hashit(x)
1981
1982 self.assertEqual(h1, h2)
1983 self.assertEqual(h1, h3)
1984
1985 c.prec = 10000
1986 x = 1100 ** 1248
1987 self.assertEqual(hashit(Decimal(x)), hashit(x))
1988
1989 def test_hash_method_nan(self):
1990 Decimal = self.decimal.Decimal
1991 self.assertRaises(TypeError, hash, Decimal('sNaN'))
1992 value = Decimal('NaN')
1993 self.assertEqual(hash(value), object.__hash__(value))
1994 class H:
1995 def __hash__(self):
1996 return 42
1997 class D(Decimal, H):
1998 pass
1999 value = D('NaN')
2000 self.assertEqual(hash(value), object.__hash__(value))
2001
2002 def test_min_and_max_methods(self):
2003 Decimal = self.decimal.Decimal
2004
2005 d1 = Decimal('15.32')
2006 d2 = Decimal('28.5')
2007 l1 = 15
2008 l2 = 28
2009
2010 #between Decimals
2011 self.assertIs(min(d1,d2), d1)
2012 self.assertIs(min(d2,d1), d1)
2013 self.assertIs(max(d1,d2), d2)
2014 self.assertIs(max(d2,d1), d2)
2015
2016 #between Decimal and int
2017 self.assertIs(min(d1,l2), d1)
2018 self.assertIs(min(l2,d1), d1)
2019 self.assertIs(max(l1,d2), d2)
2020 self.assertIs(max(d2,l1), d2)
2021
2022 def test_as_nonzero(self):
2023 Decimal = self.decimal.Decimal
2024
2025 #as false
2026 self.assertFalse(Decimal(0))
2027 #as true
2028 self.assertTrue(Decimal('0.372'))
2029
2030 def test_tostring_methods(self):
2031 #Test str and repr methods.
2032 Decimal = self.decimal.Decimal
2033
2034 d = Decimal('15.32')
2035 self.assertEqual(str(d), '15.32') # str
2036 self.assertEqual(repr(d), "Decimal('15.32')") # repr
2037
2038 def test_tonum_methods(self):
2039 #Test float and int methods.
2040 Decimal = self.decimal.Decimal
2041
2042 d1 = Decimal('66')
2043 d2 = Decimal('15.32')
2044
2045 #int
2046 self.assertEqual(int(d1), 66)
2047 self.assertEqual(int(d2), 15)
2048
2049 #float
2050 self.assertEqual(float(d1), 66)
2051 self.assertEqual(float(d2), 15.32)
2052
2053 #floor
2054 test_pairs = [
2055 ('123.00', 123),
2056 ('3.2', 3),
2057 ('3.54', 3),
2058 ('3.899', 3),
2059 ('-2.3', -3),
2060 ('-11.0', -11),
2061 ('0.0', 0),
2062 ('-0E3', 0),
2063 ('89891211712379812736.1', 89891211712379812736),
2064 ]
2065 for d, i in test_pairs:
2066 self.assertEqual(math.floor(Decimal(d)), i)
2067 self.assertRaises(ValueError, math.floor, Decimal('-NaN'))
2068 self.assertRaises(ValueError, math.floor, Decimal('sNaN'))
2069 self.assertRaises(ValueError, math.floor, Decimal('NaN123'))
2070 self.assertRaises(OverflowError, math.floor, Decimal('Inf'))
2071 self.assertRaises(OverflowError, math.floor, Decimal('-Inf'))
2072
2073 #ceiling
2074 test_pairs = [
2075 ('123.00', 123),
2076 ('3.2', 4),
2077 ('3.54', 4),
2078 ('3.899', 4),
2079 ('-2.3', -2),
2080 ('-11.0', -11),
2081 ('0.0', 0),
2082 ('-0E3', 0),
2083 ('89891211712379812736.1', 89891211712379812737),
2084 ]
2085 for d, i in test_pairs:
2086 self.assertEqual(math.ceil(Decimal(d)), i)
2087 self.assertRaises(ValueError, math.ceil, Decimal('-NaN'))
2088 self.assertRaises(ValueError, math.ceil, Decimal('sNaN'))
2089 self.assertRaises(ValueError, math.ceil, Decimal('NaN123'))
2090 self.assertRaises(OverflowError, math.ceil, Decimal('Inf'))
2091 self.assertRaises(OverflowError, math.ceil, Decimal('-Inf'))
2092
2093 #round, single argument
2094 test_pairs = [
2095 ('123.00', 123),
2096 ('3.2', 3),
2097 ('3.54', 4),
2098 ('3.899', 4),
2099 ('-2.3', -2),
2100 ('-11.0', -11),
2101 ('0.0', 0),
2102 ('-0E3', 0),
2103 ('-3.5', -4),
2104 ('-2.5', -2),
2105 ('-1.5', -2),
2106 ('-0.5', 0),
2107 ('0.5', 0),
2108 ('1.5', 2),
2109 ('2.5', 2),
2110 ('3.5', 4),
2111 ]
2112 for d, i in test_pairs:
2113 self.assertEqual(round(Decimal(d)), i)
2114 self.assertRaises(ValueError, round, Decimal('-NaN'))
2115 self.assertRaises(ValueError, round, Decimal('sNaN'))
2116 self.assertRaises(ValueError, round, Decimal('NaN123'))
2117 self.assertRaises(OverflowError, round, Decimal('Inf'))
2118 self.assertRaises(OverflowError, round, Decimal('-Inf'))
2119
2120 #round, two arguments; this is essentially equivalent
2121 #to quantize, which is already extensively tested
2122 test_triples = [
2123 ('123.456', -4, '0E+4'),
2124 ('-123.456', -4, '-0E+4'),
2125 ('123.456', -3, '0E+3'),
2126 ('-123.456', -3, '-0E+3'),
2127 ('123.456', -2, '1E+2'),
2128 ('123.456', -1, '1.2E+2'),
2129 ('123.456', 0, '123'),
2130 ('123.456', 1, '123.5'),
2131 ('123.456', 2, '123.46'),
2132 ('123.456', 3, '123.456'),
2133 ('123.456', 4, '123.4560'),
2134 ('123.455', 2, '123.46'),
2135 ('123.445', 2, '123.44'),
2136 ('Inf', 4, 'NaN'),
2137 ('-Inf', -23, 'NaN'),
2138 ('sNaN314', 3, 'NaN314'),
2139 ]
2140 for d, n, r in test_triples:
2141 self.assertEqual(str(round(Decimal(d), n)), r)
2142
2143 def test_nan_to_float(self):
2144 # Test conversions of decimal NANs to float.
2145 # See http://bugs.python.org/issue15544
2146 Decimal = self.decimal.Decimal
2147 for s in ('nan', 'nan1234', '-nan', '-nan2468'):
2148 f = float(Decimal(s))
2149 self.assertTrue(math.isnan(f))
2150 sign = math.copysign(1.0, f)
2151 self.assertEqual(sign, -1.0 if s.startswith('-') else 1.0)
2152
2153 def test_snan_to_float(self):
2154 Decimal = self.decimal.Decimal
2155 for s in ('snan', '-snan', 'snan1357', '-snan1234'):
2156 d = Decimal(s)
2157 self.assertRaises(ValueError, float, d)
2158
2159 def test_eval_round_trip(self):
2160 Decimal = self.decimal.Decimal
2161
2162 #with zero
2163 d = Decimal( (0, (0,), 0) )
2164 self.assertEqual(d, eval(repr(d)))
2165
2166 #int
2167 d = Decimal( (1, (4, 5), 0) )
2168 self.assertEqual(d, eval(repr(d)))
2169
2170 #float
2171 d = Decimal( (0, (4, 5, 3, 4), -2) )
2172 self.assertEqual(d, eval(repr(d)))
2173
2174 #weird
2175 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
2176 self.assertEqual(d, eval(repr(d)))
2177
2178 def test_as_tuple(self):
2179 Decimal = self.decimal.Decimal
2180
2181 #with zero
2182 d = Decimal(0)
2183 self.assertEqual(d.as_tuple(), (0, (0,), 0) )
2184
2185 #int
2186 d = Decimal(-45)
2187 self.assertEqual(d.as_tuple(), (1, (4, 5), 0) )
2188
2189 #complicated string
2190 d = Decimal("-4.34913534E-17")
2191 self.assertEqual(d.as_tuple(), (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
2192
2193 # The '0' coefficient is implementation specific to decimal.py.
2194 # It has no meaning in the C-version and is ignored there.
2195 d = Decimal("Infinity")
2196 self.assertEqual(d.as_tuple(), (0, (0,), 'F') )
2197
2198 #leading zeros in coefficient should be stripped
2199 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), -2) )
2200 self.assertEqual(d.as_tuple(), (0, (4, 0, 5, 3, 4), -2) )
2201 d = Decimal( (1, (0, 0, 0), 37) )
2202 self.assertEqual(d.as_tuple(), (1, (0,), 37))
2203 d = Decimal( (1, (), 37) )
2204 self.assertEqual(d.as_tuple(), (1, (0,), 37))
2205
2206 #leading zeros in NaN diagnostic info should be stripped
2207 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), 'n') )
2208 self.assertEqual(d.as_tuple(), (0, (4, 0, 5, 3, 4), 'n') )
2209 d = Decimal( (1, (0, 0, 0), 'N') )
2210 self.assertEqual(d.as_tuple(), (1, (), 'N') )
2211 d = Decimal( (1, (), 'n') )
2212 self.assertEqual(d.as_tuple(), (1, (), 'n') )
2213
2214 # For infinities, decimal.py has always silently accepted any
2215 # coefficient tuple.
2216 d = Decimal( (0, (0,), 'F') )
2217 self.assertEqual(d.as_tuple(), (0, (0,), 'F'))
2218 d = Decimal( (0, (4, 5, 3, 4), 'F') )
2219 self.assertEqual(d.as_tuple(), (0, (0,), 'F'))
2220 d = Decimal( (1, (0, 2, 7, 1), 'F') )
2221 self.assertEqual(d.as_tuple(), (1, (0,), 'F'))
2222
2223 def test_as_integer_ratio(self):
2224 Decimal = self.decimal.Decimal
2225
2226 # exceptional cases
2227 self.assertRaises(OverflowError,
2228 Decimal.as_integer_ratio, Decimal('inf'))
2229 self.assertRaises(OverflowError,
2230 Decimal.as_integer_ratio, Decimal('-inf'))
2231 self.assertRaises(ValueError,
2232 Decimal.as_integer_ratio, Decimal('-nan'))
2233 self.assertRaises(ValueError,
2234 Decimal.as_integer_ratio, Decimal('snan123'))
2235
2236 for exp in range(-4, 2):
2237 for coeff in range(1000):
2238 for sign in '+', '-':
2239 d = Decimal('%s%dE%d' % (sign, coeff, exp))
2240 pq = d.as_integer_ratio()
2241 p, q = pq
2242
2243 # check return type
2244 self.assertIsInstance(pq, tuple)
2245 self.assertIsInstance(p, int)
2246 self.assertIsInstance(q, int)
2247
2248 # check normalization: q should be positive;
2249 # p should be relatively prime to q.
2250 self.assertGreater(q, 0)
2251 self.assertEqual(math.gcd(p, q), 1)
2252
2253 # check that p/q actually gives the correct value
2254 self.assertEqual(Decimal(p) / Decimal(q), d)
2255
2256 def test_subclassing(self):
2257 # Different behaviours when subclassing Decimal
2258 Decimal = self.decimal.Decimal
2259
2260 class MyDecimal(Decimal):
2261 y = None
2262
2263 d1 = MyDecimal(1)
2264 d2 = MyDecimal(2)
2265 d = d1 + d2
2266 self.assertIs(type(d), Decimal)
2267
2268 d = d1.max(d2)
2269 self.assertIs(type(d), Decimal)
2270
2271 d = copy.copy(d1)
2272 self.assertIs(type(d), MyDecimal)
2273 self.assertEqual(d, d1)
2274
2275 d = copy.deepcopy(d1)
2276 self.assertIs(type(d), MyDecimal)
2277 self.assertEqual(d, d1)
2278
2279 # Decimal(Decimal)
2280 d = Decimal('1.0')
2281 x = Decimal(d)
2282 self.assertIs(type(x), Decimal)
2283 self.assertEqual(x, d)
2284
2285 # MyDecimal(Decimal)
2286 m = MyDecimal(d)
2287 self.assertIs(type(m), MyDecimal)
2288 self.assertEqual(m, d)
2289 self.assertIs(m.y, None)
2290
2291 # Decimal(MyDecimal)
2292 x = Decimal(m)
2293 self.assertIs(type(x), Decimal)
2294 self.assertEqual(x, d)
2295
2296 # MyDecimal(MyDecimal)
2297 m.y = 9
2298 x = MyDecimal(m)
2299 self.assertIs(type(x), MyDecimal)
2300 self.assertEqual(x, d)
2301 self.assertIs(x.y, None)
2302
2303 def test_implicit_context(self):
2304 Decimal = self.decimal.Decimal
2305 getcontext = self.decimal.getcontext
2306
2307 # Check results when context given implicitly. (Issue 2478)
2308 c = getcontext()
2309 self.assertEqual(str(Decimal(0).sqrt()),
2310 str(c.sqrt(Decimal(0))))
2311
2312 def test_none_args(self):
2313 Decimal = self.decimal.Decimal
2314 Context = self.decimal.Context
2315 localcontext = self.decimal.localcontext
2316 InvalidOperation = self.decimal.InvalidOperation
2317 DivisionByZero = self.decimal.DivisionByZero
2318 Overflow = self.decimal.Overflow
2319 Underflow = self.decimal.Underflow
2320 Subnormal = self.decimal.Subnormal
2321 Inexact = self.decimal.Inexact
2322 Rounded = self.decimal.Rounded
2323 Clamped = self.decimal.Clamped
2324
2325 with localcontext(Context()) as c:
2326 c.prec = 7
2327 c.Emax = 999
2328 c.Emin = -999
2329
2330 x = Decimal("111")
2331 y = Decimal("1e9999")
2332 z = Decimal("1e-9999")
2333
2334 ##### Unary functions
2335 c.clear_flags()
2336 self.assertEqual(str(x.exp(context=None)), '1.609487E+48')
2337 self.assertTrue(c.flags[Inexact])
2338 self.assertTrue(c.flags[Rounded])
2339 c.clear_flags()
2340 self.assertRaises(Overflow, y.exp, context=None)
2341 self.assertTrue(c.flags[Overflow])
2342
2343 self.assertIs(z.is_normal(context=None), False)
2344 self.assertIs(z.is_subnormal(context=None), True)
2345
2346 c.clear_flags()
2347 self.assertEqual(str(x.ln(context=None)), '4.709530')
2348 self.assertTrue(c.flags[Inexact])
2349 self.assertTrue(c.flags[Rounded])
2350 c.clear_flags()
2351 self.assertRaises(InvalidOperation, Decimal(-1).ln, context=None)
2352 self.assertTrue(c.flags[InvalidOperation])
2353
2354 c.clear_flags()
2355 self.assertEqual(str(x.log10(context=None)), '2.045323')
2356 self.assertTrue(c.flags[Inexact])
2357 self.assertTrue(c.flags[Rounded])
2358 c.clear_flags()
2359 self.assertRaises(InvalidOperation, Decimal(-1).log10, context=None)
2360 self.assertTrue(c.flags[InvalidOperation])
2361
2362 c.clear_flags()
2363 self.assertEqual(str(x.logb(context=None)), '2')
2364 self.assertRaises(DivisionByZero, Decimal(0).logb, context=None)
2365 self.assertTrue(c.flags[DivisionByZero])
2366
2367 c.clear_flags()
2368 self.assertEqual(str(x.logical_invert(context=None)), '1111000')
2369 self.assertRaises(InvalidOperation, y.logical_invert, context=None)
2370 self.assertTrue(c.flags[InvalidOperation])
2371
2372 c.clear_flags()
2373 self.assertEqual(str(y.next_minus(context=None)), '9.999999E+999')
2374 self.assertRaises(InvalidOperation, Decimal('sNaN').next_minus, context=None)
2375 self.assertTrue(c.flags[InvalidOperation])
2376
2377 c.clear_flags()
2378 self.assertEqual(str(y.next_plus(context=None)), 'Infinity')
2379 self.assertRaises(InvalidOperation, Decimal('sNaN').next_plus, context=None)
2380 self.assertTrue(c.flags[InvalidOperation])
2381
2382 c.clear_flags()
2383 self.assertEqual(str(z.normalize(context=None)), '0')
2384 self.assertRaises(Overflow, y.normalize, context=None)
2385 self.assertTrue(c.flags[Overflow])
2386
2387 self.assertEqual(str(z.number_class(context=None)), '+Subnormal')
2388
2389 c.clear_flags()
2390 self.assertEqual(str(z.sqrt(context=None)), '0E-1005')
2391 self.assertTrue(c.flags[Clamped])
2392 self.assertTrue(c.flags[Inexact])
2393 self.assertTrue(c.flags[Rounded])
2394 self.assertTrue(c.flags[Subnormal])
2395 self.assertTrue(c.flags[Underflow])
2396 c.clear_flags()
2397 self.assertRaises(Overflow, y.sqrt, context=None)
2398 self.assertTrue(c.flags[Overflow])
2399
2400 c.capitals = 0
2401 self.assertEqual(str(z.to_eng_string(context=None)), '1e-9999')
2402 c.capitals = 1
2403
2404
2405 ##### Binary functions
2406 c.clear_flags()
2407 ans = str(x.compare(Decimal('Nan891287828'), context=None))
2408 self.assertEqual(ans, 'NaN1287828')
2409 self.assertRaises(InvalidOperation, x.compare, Decimal('sNaN'), context=None)
2410 self.assertTrue(c.flags[InvalidOperation])
2411
2412 c.clear_flags()
2413 ans = str(x.compare_signal(8224, context=None))
2414 self.assertEqual(ans, '-1')
2415 self.assertRaises(InvalidOperation, x.compare_signal, Decimal('NaN'), context=None)
2416 self.assertTrue(c.flags[InvalidOperation])
2417
2418 c.clear_flags()
2419 ans = str(x.logical_and(101, context=None))
2420 self.assertEqual(ans, '101')
2421 self.assertRaises(InvalidOperation, x.logical_and, 123, context=None)
2422 self.assertTrue(c.flags[InvalidOperation])
2423
2424 c.clear_flags()
2425 ans = str(x.logical_or(101, context=None))
2426 self.assertEqual(ans, '111')
2427 self.assertRaises(InvalidOperation, x.logical_or, 123, context=None)
2428 self.assertTrue(c.flags[InvalidOperation])
2429
2430 c.clear_flags()
2431 ans = str(x.logical_xor(101, context=None))
2432 self.assertEqual(ans, '10')
2433 self.assertRaises(InvalidOperation, x.logical_xor, 123, context=None)
2434 self.assertTrue(c.flags[InvalidOperation])
2435
2436 c.clear_flags()
2437 ans = str(x.max(101, context=None))
2438 self.assertEqual(ans, '111')
2439 self.assertRaises(InvalidOperation, x.max, Decimal('sNaN'), context=None)
2440 self.assertTrue(c.flags[InvalidOperation])
2441
2442 c.clear_flags()
2443 ans = str(x.max_mag(101, context=None))
2444 self.assertEqual(ans, '111')
2445 self.assertRaises(InvalidOperation, x.max_mag, Decimal('sNaN'), context=None)
2446 self.assertTrue(c.flags[InvalidOperation])
2447
2448 c.clear_flags()
2449 ans = str(x.min(101, context=None))
2450 self.assertEqual(ans, '101')
2451 self.assertRaises(InvalidOperation, x.min, Decimal('sNaN'), context=None)
2452 self.assertTrue(c.flags[InvalidOperation])
2453
2454 c.clear_flags()
2455 ans = str(x.min_mag(101, context=None))
2456 self.assertEqual(ans, '101')
2457 self.assertRaises(InvalidOperation, x.min_mag, Decimal('sNaN'), context=None)
2458 self.assertTrue(c.flags[InvalidOperation])
2459
2460 c.clear_flags()
2461 ans = str(x.remainder_near(101, context=None))
2462 self.assertEqual(ans, '10')
2463 self.assertRaises(InvalidOperation, y.remainder_near, 101, context=None)
2464 self.assertTrue(c.flags[InvalidOperation])
2465
2466 c.clear_flags()
2467 ans = str(x.rotate(2, context=None))
2468 self.assertEqual(ans, '11100')
2469 self.assertRaises(InvalidOperation, x.rotate, 101, context=None)
2470 self.assertTrue(c.flags[InvalidOperation])
2471
2472 c.clear_flags()
2473 ans = str(x.scaleb(7, context=None))
2474 self.assertEqual(ans, '1.11E+9')
2475 self.assertRaises(InvalidOperation, x.scaleb, 10000, context=None)
2476 self.assertTrue(c.flags[InvalidOperation])
2477
2478 c.clear_flags()
2479 ans = str(x.shift(2, context=None))
2480 self.assertEqual(ans, '11100')
2481 self.assertRaises(InvalidOperation, x.shift, 10000, context=None)
2482 self.assertTrue(c.flags[InvalidOperation])
2483
2484
2485 ##### Ternary functions
2486 c.clear_flags()
2487 ans = str(x.fma(2, 3, context=None))
2488 self.assertEqual(ans, '225')
2489 self.assertRaises(Overflow, x.fma, Decimal('1e9999'), 3, context=None)
2490 self.assertTrue(c.flags[Overflow])
2491
2492
2493 ##### Special cases
2494 c.rounding = ROUND_HALF_EVEN
2495 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2496 self.assertEqual(ans, '2')
2497 c.rounding = ROUND_DOWN
2498 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2499 self.assertEqual(ans, '1')
2500 ans = str(Decimal('1.5').to_integral(rounding=ROUND_UP, context=None))
2501 self.assertEqual(ans, '2')
2502 c.clear_flags()
2503 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral, context=None)
2504 self.assertTrue(c.flags[InvalidOperation])
2505
2506 c.rounding = ROUND_HALF_EVEN
2507 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2508 self.assertEqual(ans, '2')
2509 c.rounding = ROUND_DOWN
2510 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2511 self.assertEqual(ans, '1')
2512 ans = str(Decimal('1.5').to_integral_value(rounding=ROUND_UP, context=None))
2513 self.assertEqual(ans, '2')
2514 c.clear_flags()
2515 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_value, context=None)
2516 self.assertTrue(c.flags[InvalidOperation])
2517
2518 c.rounding = ROUND_HALF_EVEN
2519 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2520 self.assertEqual(ans, '2')
2521 c.rounding = ROUND_DOWN
2522 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2523 self.assertEqual(ans, '1')
2524 ans = str(Decimal('1.5').to_integral_exact(rounding=ROUND_UP, context=None))
2525 self.assertEqual(ans, '2')
2526 c.clear_flags()
2527 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_exact, context=None)
2528 self.assertTrue(c.flags[InvalidOperation])
2529
2530 c.rounding = ROUND_UP
2531 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2532 self.assertEqual(ans, '1.501')
2533 c.rounding = ROUND_DOWN
2534 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2535 self.assertEqual(ans, '1.500')
2536 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=ROUND_UP, context=None))
2537 self.assertEqual(ans, '1.501')
2538 c.clear_flags()
2539 self.assertRaises(InvalidOperation, y.quantize, Decimal('1e-10'), rounding=ROUND_UP, context=None)
2540 self.assertTrue(c.flags[InvalidOperation])
2541
2542 with localcontext(Context()) as context:
2543 context.prec = 7
2544 context.Emax = 999
2545 context.Emin = -999
2546 with localcontext(ctx=None) as c:
2547 self.assertEqual(c.prec, 7)
2548 self.assertEqual(c.Emax, 999)
2549 self.assertEqual(c.Emin, -999)
2550
2551 def test_conversions_from_int(self):
2552 # Check that methods taking a second Decimal argument will
2553 # always accept an integer in place of a Decimal.
2554 Decimal = self.decimal.Decimal
2555
2556 self.assertEqual(Decimal(4).compare(3),
2557 Decimal(4).compare(Decimal(3)))
2558 self.assertEqual(Decimal(4).compare_signal(3),
2559 Decimal(4).compare_signal(Decimal(3)))
2560 self.assertEqual(Decimal(4).compare_total(3),
2561 Decimal(4).compare_total(Decimal(3)))
2562 self.assertEqual(Decimal(4).compare_total_mag(3),
2563 Decimal(4).compare_total_mag(Decimal(3)))
2564 self.assertEqual(Decimal(10101).logical_and(1001),
2565 Decimal(10101).logical_and(Decimal(1001)))
2566 self.assertEqual(Decimal(10101).logical_or(1001),
2567 Decimal(10101).logical_or(Decimal(1001)))
2568 self.assertEqual(Decimal(10101).logical_xor(1001),
2569 Decimal(10101).logical_xor(Decimal(1001)))
2570 self.assertEqual(Decimal(567).max(123),
2571 Decimal(567).max(Decimal(123)))
2572 self.assertEqual(Decimal(567).max_mag(123),
2573 Decimal(567).max_mag(Decimal(123)))
2574 self.assertEqual(Decimal(567).min(123),
2575 Decimal(567).min(Decimal(123)))
2576 self.assertEqual(Decimal(567).min_mag(123),
2577 Decimal(567).min_mag(Decimal(123)))
2578 self.assertEqual(Decimal(567).next_toward(123),
2579 Decimal(567).next_toward(Decimal(123)))
2580 self.assertEqual(Decimal(1234).quantize(100),
2581 Decimal(1234).quantize(Decimal(100)))
2582 self.assertEqual(Decimal(768).remainder_near(1234),
2583 Decimal(768).remainder_near(Decimal(1234)))
2584 self.assertEqual(Decimal(123).rotate(1),
2585 Decimal(123).rotate(Decimal(1)))
2586 self.assertEqual(Decimal(1234).same_quantum(1000),
2587 Decimal(1234).same_quantum(Decimal(1000)))
2588 self.assertEqual(Decimal('9.123').scaleb(-100),
2589 Decimal('9.123').scaleb(Decimal(-100)))
2590 self.assertEqual(Decimal(456).shift(-1),
2591 Decimal(456).shift(Decimal(-1)))
2592
2593 self.assertEqual(Decimal(-12).fma(Decimal(45), 67),
2594 Decimal(-12).fma(Decimal(45), Decimal(67)))
2595 self.assertEqual(Decimal(-12).fma(45, 67),
2596 Decimal(-12).fma(Decimal(45), Decimal(67)))
2597 self.assertEqual(Decimal(-12).fma(45, Decimal(67)),
2598 Decimal(-12).fma(Decimal(45), Decimal(67)))
2599
2600 @requires_cdecimal
2601 class CUsabilityTest(UsabilityTest, unittest.TestCase):
2602 decimal = C
2603 class PyUsabilityTest(UsabilityTest, unittest.TestCase):
2604 decimal = P
2605
2606 def setUp(self):
2607 super().setUp()
2608 self._previous_int_limit = sys.get_int_max_str_digits()
2609 sys.set_int_max_str_digits(7000)
2610
2611 def tearDown(self):
2612 sys.set_int_max_str_digits(self._previous_int_limit)
2613 super().tearDown()
2614
2615 class PythonAPItests:
2616
2617 def test_abc(self):
2618 Decimal = self.decimal.Decimal
2619
2620 self.assertIsSubclass(Decimal, numbers.Number)
2621 self.assertNotIsSubclass(Decimal, numbers.Real)
2622 self.assertIsInstance(Decimal(0), numbers.Number)
2623 self.assertNotIsInstance(Decimal(0), numbers.Real)
2624
2625 def test_pickle(self):
2626 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
2627 Decimal = self.decimal.Decimal
2628
2629 savedecimal = sys.modules['decimal']
2630
2631 # Round trip
2632 sys.modules['decimal'] = self.decimal
2633 d = Decimal('-3.141590000')
2634 p = pickle.dumps(d, proto)
2635 e = pickle.loads(p)
2636 self.assertEqual(d, e)
2637
2638 if C:
2639 # Test interchangeability
2640 x = C.Decimal('-3.123e81723')
2641 y = P.Decimal('-3.123e81723')
2642
2643 sys.modules['decimal'] = C
2644 sx = pickle.dumps(x, proto)
2645 sys.modules['decimal'] = P
2646 r = pickle.loads(sx)
2647 self.assertIsInstance(r, P.Decimal)
2648 self.assertEqual(r, y)
2649
2650 sys.modules['decimal'] = P
2651 sy = pickle.dumps(y, proto)
2652 sys.modules['decimal'] = C
2653 r = pickle.loads(sy)
2654 self.assertIsInstance(r, C.Decimal)
2655 self.assertEqual(r, x)
2656
2657 x = C.Decimal('-3.123e81723').as_tuple()
2658 y = P.Decimal('-3.123e81723').as_tuple()
2659
2660 sys.modules['decimal'] = C
2661 sx = pickle.dumps(x, proto)
2662 sys.modules['decimal'] = P
2663 r = pickle.loads(sx)
2664 self.assertIsInstance(r, P.DecimalTuple)
2665 self.assertEqual(r, y)
2666
2667 sys.modules['decimal'] = P
2668 sy = pickle.dumps(y, proto)
2669 sys.modules['decimal'] = C
2670 r = pickle.loads(sy)
2671 self.assertIsInstance(r, C.DecimalTuple)
2672 self.assertEqual(r, x)
2673
2674 sys.modules['decimal'] = savedecimal
2675
2676 def test_int(self):
2677 Decimal = self.decimal.Decimal
2678
2679 for x in range(-250, 250):
2680 s = '%0.2f' % (x / 100.0)
2681 # should work the same as for floats
2682 self.assertEqual(int(Decimal(s)), int(float(s)))
2683 # should work the same as to_integral in the ROUND_DOWN mode
2684 d = Decimal(s)
2685 r = d.to_integral(ROUND_DOWN)
2686 self.assertEqual(Decimal(int(d)), r)
2687
2688 self.assertRaises(ValueError, int, Decimal('-nan'))
2689 self.assertRaises(ValueError, int, Decimal('snan'))
2690 self.assertRaises(OverflowError, int, Decimal('inf'))
2691 self.assertRaises(OverflowError, int, Decimal('-inf'))
2692
2693 @cpython_only
2694 def test_small_ints(self):
2695 Decimal = self.decimal.Decimal
2696 # bpo-46361
2697 for x in range(-5, 257):
2698 self.assertIs(int(Decimal(x)), x)
2699
2700 def test_trunc(self):
2701 Decimal = self.decimal.Decimal
2702
2703 for x in range(-250, 250):
2704 s = '%0.2f' % (x / 100.0)
2705 # should work the same as for floats
2706 self.assertEqual(int(Decimal(s)), int(float(s)))
2707 # should work the same as to_integral in the ROUND_DOWN mode
2708 d = Decimal(s)
2709 r = d.to_integral(ROUND_DOWN)
2710 self.assertEqual(Decimal(math.trunc(d)), r)
2711
2712 def test_from_float(self):
2713
2714 Decimal = self.decimal.Decimal
2715
2716 class MyDecimal(Decimal):
2717 def __init__(self, _):
2718 self.x = 'y'
2719
2720 self.assertIsSubclass(MyDecimal, Decimal)
2721
2722 r = MyDecimal.from_float(0.1)
2723 self.assertEqual(type(r), MyDecimal)
2724 self.assertEqual(str(r),
2725 '0.1000000000000000055511151231257827021181583404541015625')
2726 self.assertEqual(r.x, 'y')
2727
2728 bigint = 12345678901234567890123456789
2729 self.assertEqual(MyDecimal.from_float(bigint), MyDecimal(bigint))
2730 self.assertTrue(MyDecimal.from_float(float('nan')).is_qnan())
2731 self.assertTrue(MyDecimal.from_float(float('inf')).is_infinite())
2732 self.assertTrue(MyDecimal.from_float(float('-inf')).is_infinite())
2733 self.assertEqual(str(MyDecimal.from_float(float('nan'))),
2734 str(Decimal('NaN')))
2735 self.assertEqual(str(MyDecimal.from_float(float('inf'))),
2736 str(Decimal('Infinity')))
2737 self.assertEqual(str(MyDecimal.from_float(float('-inf'))),
2738 str(Decimal('-Infinity')))
2739 self.assertRaises(TypeError, MyDecimal.from_float, 'abc')
2740 for i in range(200):
2741 x = random.expovariate(0.01) * (random.random() * 2.0 - 1.0)
2742 self.assertEqual(x, float(MyDecimal.from_float(x))) # roundtrip
2743
2744 def test_create_decimal_from_float(self):
2745 Decimal = self.decimal.Decimal
2746 Context = self.decimal.Context
2747 Inexact = self.decimal.Inexact
2748
2749 context = Context(prec=5, rounding=ROUND_DOWN)
2750 self.assertEqual(
2751 context.create_decimal_from_float(math.pi),
2752 Decimal('3.1415')
2753 )
2754 context = Context(prec=5, rounding=ROUND_UP)
2755 self.assertEqual(
2756 context.create_decimal_from_float(math.pi),
2757 Decimal('3.1416')
2758 )
2759 context = Context(prec=5, traps=[Inexact])
2760 self.assertRaises(
2761 Inexact,
2762 context.create_decimal_from_float,
2763 math.pi
2764 )
2765 self.assertEqual(repr(context.create_decimal_from_float(-0.0)),
2766 "Decimal('-0')")
2767 self.assertEqual(repr(context.create_decimal_from_float(1.0)),
2768 "Decimal('1')")
2769 self.assertEqual(repr(context.create_decimal_from_float(10)),
2770 "Decimal('10')")
2771
2772 def test_quantize(self):
2773 Decimal = self.decimal.Decimal
2774 Context = self.decimal.Context
2775 InvalidOperation = self.decimal.InvalidOperation
2776
2777 c = Context(Emax=99999, Emin=-99999)
2778 self.assertEqual(
2779 Decimal('7.335').quantize(Decimal('.01')),
2780 Decimal('7.34')
2781 )
2782 self.assertEqual(
2783 Decimal('7.335').quantize(Decimal('.01'), rounding=ROUND_DOWN),
2784 Decimal('7.33')
2785 )
2786 self.assertRaises(
2787 InvalidOperation,
2788 Decimal("10e99999").quantize, Decimal('1e100000'), context=c
2789 )
2790
2791 c = Context()
2792 d = Decimal("0.871831e800")
2793 x = d.quantize(context=c, exp=Decimal("1e797"), rounding=ROUND_DOWN)
2794 self.assertEqual(x, Decimal('8.71E+799'))
2795
2796 def test_complex(self):
2797 Decimal = self.decimal.Decimal
2798
2799 x = Decimal("9.8182731e181273")
2800 self.assertEqual(x.real, x)
2801 self.assertEqual(x.imag, 0)
2802 self.assertEqual(x.conjugate(), x)
2803
2804 x = Decimal("1")
2805 self.assertEqual(complex(x), complex(float(1)))
2806
2807 self.assertRaises(AttributeError, setattr, x, 'real', 100)
2808 self.assertRaises(AttributeError, setattr, x, 'imag', 100)
2809 self.assertRaises(AttributeError, setattr, x, 'conjugate', 100)
2810 self.assertRaises(AttributeError, setattr, x, '__complex__', 100)
2811
2812 def test_named_parameters(self):
2813 D = self.decimal.Decimal
2814 Context = self.decimal.Context
2815 localcontext = self.decimal.localcontext
2816 InvalidOperation = self.decimal.InvalidOperation
2817 Overflow = self.decimal.Overflow
2818
2819 xc = Context()
2820 xc.prec = 1
2821 xc.Emax = 1
2822 xc.Emin = -1
2823
2824 with localcontext() as c:
2825 c.clear_flags()
2826
2827 self.assertEqual(D(9, xc), 9)
2828 self.assertEqual(D(9, context=xc), 9)
2829 self.assertEqual(D(context=xc, value=9), 9)
2830 self.assertEqual(D(context=xc), 0)
2831 xc.clear_flags()
2832 self.assertRaises(InvalidOperation, D, "xyz", context=xc)
2833 self.assertTrue(xc.flags[InvalidOperation])
2834 self.assertFalse(c.flags[InvalidOperation])
2835
2836 xc.clear_flags()
2837 self.assertEqual(D(2).exp(context=xc), 7)
2838 self.assertRaises(Overflow, D(8).exp, context=xc)
2839 self.assertTrue(xc.flags[Overflow])
2840 self.assertFalse(c.flags[Overflow])
2841
2842 xc.clear_flags()
2843 self.assertEqual(D(2).ln(context=xc), D('0.7'))
2844 self.assertRaises(InvalidOperation, D(-1).ln, context=xc)
2845 self.assertTrue(xc.flags[InvalidOperation])
2846 self.assertFalse(c.flags[InvalidOperation])
2847
2848 self.assertEqual(D(0).log10(context=xc), D('-inf'))
2849 self.assertEqual(D(-1).next_minus(context=xc), -2)
2850 self.assertEqual(D(-1).next_plus(context=xc), D('-0.9'))
2851 self.assertEqual(D("9.73").normalize(context=xc), D('1E+1'))
2852 self.assertEqual(D("9999").to_integral(context=xc), 9999)
2853 self.assertEqual(D("-2000").to_integral_exact(context=xc), -2000)
2854 self.assertEqual(D("123").to_integral_value(context=xc), 123)
2855 self.assertEqual(D("0.0625").sqrt(context=xc), D('0.2'))
2856
2857 self.assertEqual(D("0.0625").compare(context=xc, other=3), -1)
2858 xc.clear_flags()
2859 self.assertRaises(InvalidOperation,
2860 D("0").compare_signal, D('nan'), context=xc)
2861 self.assertTrue(xc.flags[InvalidOperation])
2862 self.assertFalse(c.flags[InvalidOperation])
2863 self.assertEqual(D("0.01").max(D('0.0101'), context=xc), D('0.0'))
2864 self.assertEqual(D("0.01").max(D('0.0101'), context=xc), D('0.0'))
2865 self.assertEqual(D("0.2").max_mag(D('-0.3'), context=xc),
2866 D('-0.3'))
2867 self.assertEqual(D("0.02").min(D('-0.03'), context=xc), D('-0.0'))
2868 self.assertEqual(D("0.02").min_mag(D('-0.03'), context=xc),
2869 D('0.0'))
2870 self.assertEqual(D("0.2").next_toward(D('-1'), context=xc), D('0.1'))
2871 xc.clear_flags()
2872 self.assertRaises(InvalidOperation,
2873 D("0.2").quantize, D('1e10'), context=xc)
2874 self.assertTrue(xc.flags[InvalidOperation])
2875 self.assertFalse(c.flags[InvalidOperation])
2876 self.assertEqual(D("9.99").remainder_near(D('1.5'), context=xc),
2877 D('-0.5'))
2878
2879 self.assertEqual(D("9.9").fma(third=D('0.9'), context=xc, other=7),
2880 D('7E+1'))
2881
2882 self.assertRaises(TypeError, D(1).is_canonical, context=xc)
2883 self.assertRaises(TypeError, D(1).is_finite, context=xc)
2884 self.assertRaises(TypeError, D(1).is_infinite, context=xc)
2885 self.assertRaises(TypeError, D(1).is_nan, context=xc)
2886 self.assertRaises(TypeError, D(1).is_qnan, context=xc)
2887 self.assertRaises(TypeError, D(1).is_snan, context=xc)
2888 self.assertRaises(TypeError, D(1).is_signed, context=xc)
2889 self.assertRaises(TypeError, D(1).is_zero, context=xc)
2890
2891 self.assertFalse(D("0.01").is_normal(context=xc))
2892 self.assertTrue(D("0.01").is_subnormal(context=xc))
2893
2894 self.assertRaises(TypeError, D(1).adjusted, context=xc)
2895 self.assertRaises(TypeError, D(1).conjugate, context=xc)
2896 self.assertRaises(TypeError, D(1).radix, context=xc)
2897
2898 self.assertEqual(D(-111).logb(context=xc), 2)
2899 self.assertEqual(D(0).logical_invert(context=xc), 1)
2900 self.assertEqual(D('0.01').number_class(context=xc), '+Subnormal')
2901 self.assertEqual(D('0.21').to_eng_string(context=xc), '0.21')
2902
2903 self.assertEqual(D('11').logical_and(D('10'), context=xc), 0)
2904 self.assertEqual(D('11').logical_or(D('10'), context=xc), 1)
2905 self.assertEqual(D('01').logical_xor(D('10'), context=xc), 1)
2906 self.assertEqual(D('23').rotate(1, context=xc), 3)
2907 self.assertEqual(D('23').rotate(1, context=xc), 3)
2908 xc.clear_flags()
2909 self.assertRaises(Overflow,
2910 D('23').scaleb, 1, context=xc)
2911 self.assertTrue(xc.flags[Overflow])
2912 self.assertFalse(c.flags[Overflow])
2913 self.assertEqual(D('23').shift(-1, context=xc), 0)
2914
2915 self.assertRaises(TypeError, D.from_float, 1.1, context=xc)
2916 self.assertRaises(TypeError, D(0).as_tuple, context=xc)
2917
2918 self.assertEqual(D(1).canonical(), 1)
2919 self.assertRaises(TypeError, D("-1").copy_abs, context=xc)
2920 self.assertRaises(TypeError, D("-1").copy_negate, context=xc)
2921 self.assertRaises(TypeError, D(1).canonical, context="x")
2922 self.assertRaises(TypeError, D(1).canonical, xyz="x")
2923
2924 def test_exception_hierarchy(self):
2925
2926 decimal = self.decimal
2927 DecimalException = decimal.DecimalException
2928 InvalidOperation = decimal.InvalidOperation
2929 FloatOperation = decimal.FloatOperation
2930 DivisionByZero = decimal.DivisionByZero
2931 Overflow = decimal.Overflow
2932 Underflow = decimal.Underflow
2933 Subnormal = decimal.Subnormal
2934 Inexact = decimal.Inexact
2935 Rounded = decimal.Rounded
2936 Clamped = decimal.Clamped
2937
2938 self.assertIsSubclass(DecimalException, ArithmeticError)
2939
2940 self.assertIsSubclass(InvalidOperation, DecimalException)
2941 self.assertIsSubclass(FloatOperation, DecimalException)
2942 self.assertIsSubclass(FloatOperation, TypeError)
2943 self.assertIsSubclass(DivisionByZero, DecimalException)
2944 self.assertIsSubclass(DivisionByZero, ZeroDivisionError)
2945 self.assertIsSubclass(Overflow, Rounded)
2946 self.assertIsSubclass(Overflow, Inexact)
2947 self.assertIsSubclass(Overflow, DecimalException)
2948 self.assertIsSubclass(Underflow, Inexact)
2949 self.assertIsSubclass(Underflow, Rounded)
2950 self.assertIsSubclass(Underflow, Subnormal)
2951 self.assertIsSubclass(Underflow, DecimalException)
2952
2953 self.assertIsSubclass(Subnormal, DecimalException)
2954 self.assertIsSubclass(Inexact, DecimalException)
2955 self.assertIsSubclass(Rounded, DecimalException)
2956 self.assertIsSubclass(Clamped, DecimalException)
2957
2958 self.assertIsSubclass(decimal.ConversionSyntax, InvalidOperation)
2959 self.assertIsSubclass(decimal.DivisionImpossible, InvalidOperation)
2960 self.assertIsSubclass(decimal.DivisionUndefined, InvalidOperation)
2961 self.assertIsSubclass(decimal.DivisionUndefined, ZeroDivisionError)
2962 self.assertIsSubclass(decimal.InvalidContext, InvalidOperation)
2963
2964 @requires_cdecimal
2965 class CPythonAPItests(PythonAPItests, unittest.TestCase):
2966 decimal = C
2967 class PyPythonAPItests(PythonAPItests, unittest.TestCase):
2968 decimal = P
2969
2970 class ContextAPItests:
2971
2972 def test_none_args(self):
2973 Context = self.decimal.Context
2974 InvalidOperation = self.decimal.InvalidOperation
2975 DivisionByZero = self.decimal.DivisionByZero
2976 Overflow = self.decimal.Overflow
2977
2978 c1 = Context()
2979 c2 = Context(prec=None, rounding=None, Emax=None, Emin=None,
2980 capitals=None, clamp=None, flags=None, traps=None)
2981 for c in [c1, c2]:
2982 self.assertEqual(c.prec, 28)
2983 self.assertEqual(c.rounding, ROUND_HALF_EVEN)
2984 self.assertEqual(c.Emax, 999999)
2985 self.assertEqual(c.Emin, -999999)
2986 self.assertEqual(c.capitals, 1)
2987 self.assertEqual(c.clamp, 0)
2988 assert_signals(self, c, 'flags', [])
2989 assert_signals(self, c, 'traps', [InvalidOperation, DivisionByZero,
2990 Overflow])
2991
2992 def test_pickle(self):
2993
2994 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
2995 Context = self.decimal.Context
2996
2997 savedecimal = sys.modules['decimal']
2998
2999 # Round trip
3000 sys.modules['decimal'] = self.decimal
3001 c = Context()
3002 e = pickle.loads(pickle.dumps(c, proto))
3003
3004 self.assertEqual(c.prec, e.prec)
3005 self.assertEqual(c.Emin, e.Emin)
3006 self.assertEqual(c.Emax, e.Emax)
3007 self.assertEqual(c.rounding, e.rounding)
3008 self.assertEqual(c.capitals, e.capitals)
3009 self.assertEqual(c.clamp, e.clamp)
3010 self.assertEqual(c.flags, e.flags)
3011 self.assertEqual(c.traps, e.traps)
3012
3013 # Test interchangeability
3014 combinations = [(C, P), (P, C)] if C else [(P, P)]
3015 for dumper, loader in combinations:
3016 for ri, _ in enumerate(RoundingModes):
3017 for fi, _ in enumerate(OrderedSignals[dumper]):
3018 for ti, _ in enumerate(OrderedSignals[dumper]):
3019
3020 prec = random.randrange(1, 100)
3021 emin = random.randrange(-100, 0)
3022 emax = random.randrange(1, 100)
3023 caps = random.randrange(2)
3024 clamp = random.randrange(2)
3025
3026 # One module dumps
3027 sys.modules['decimal'] = dumper
3028 c = dumper.Context(
3029 prec=prec, Emin=emin, Emax=emax,
3030 rounding=RoundingModes[ri],
3031 capitals=caps, clamp=clamp,
3032 flags=OrderedSignals[dumper][:fi],
3033 traps=OrderedSignals[dumper][:ti]
3034 )
3035 s = pickle.dumps(c, proto)
3036
3037 # The other module loads
3038 sys.modules['decimal'] = loader
3039 d = pickle.loads(s)
3040 self.assertIsInstance(d, loader.Context)
3041
3042 self.assertEqual(d.prec, prec)
3043 self.assertEqual(d.Emin, emin)
3044 self.assertEqual(d.Emax, emax)
3045 self.assertEqual(d.rounding, RoundingModes[ri])
3046 self.assertEqual(d.capitals, caps)
3047 self.assertEqual(d.clamp, clamp)
3048 assert_signals(self, d, 'flags', OrderedSignals[loader][:fi])
3049 assert_signals(self, d, 'traps', OrderedSignals[loader][:ti])
3050
3051 sys.modules['decimal'] = savedecimal
3052
3053 def test_equality_with_other_types(self):
3054 Decimal = self.decimal.Decimal
3055
3056 self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}])
3057 self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}])
3058
3059 def test_copy(self):
3060 # All copies should be deep
3061 Decimal = self.decimal.Decimal
3062 Context = self.decimal.Context
3063
3064 c = Context()
3065 d = c.copy()
3066 self.assertNotEqual(id(c), id(d))
3067 self.assertNotEqual(id(c.flags), id(d.flags))
3068 self.assertNotEqual(id(c.traps), id(d.traps))
3069 k1 = set(c.flags.keys())
3070 k2 = set(d.flags.keys())
3071 self.assertEqual(k1, k2)
3072 self.assertEqual(c.flags, d.flags)
3073
3074 def test__clamp(self):
3075 # In Python 3.2, the private attribute `_clamp` was made
3076 # public (issue 8540), with the old `_clamp` becoming a
3077 # property wrapping `clamp`. For the duration of Python 3.2
3078 # only, the attribute should be gettable/settable via both
3079 # `clamp` and `_clamp`; in Python 3.3, `_clamp` should be
3080 # removed.
3081 Context = self.decimal.Context
3082 c = Context()
3083 self.assertRaises(AttributeError, getattr, c, '_clamp')
3084
3085 def test_abs(self):
3086 Decimal = self.decimal.Decimal
3087 Context = self.decimal.Context
3088
3089 c = Context()
3090 d = c.abs(Decimal(-1))
3091 self.assertEqual(c.abs(-1), d)
3092 self.assertRaises(TypeError, c.abs, '-1')
3093
3094 def test_add(self):
3095 Decimal = self.decimal.Decimal
3096 Context = self.decimal.Context
3097
3098 c = Context()
3099 d = c.add(Decimal(1), Decimal(1))
3100 self.assertEqual(c.add(1, 1), d)
3101 self.assertEqual(c.add(Decimal(1), 1), d)
3102 self.assertEqual(c.add(1, Decimal(1)), d)
3103 self.assertRaises(TypeError, c.add, '1', 1)
3104 self.assertRaises(TypeError, c.add, 1, '1')
3105
3106 def test_compare(self):
3107 Decimal = self.decimal.Decimal
3108 Context = self.decimal.Context
3109
3110 c = Context()
3111 d = c.compare(Decimal(1), Decimal(1))
3112 self.assertEqual(c.compare(1, 1), d)
3113 self.assertEqual(c.compare(Decimal(1), 1), d)
3114 self.assertEqual(c.compare(1, Decimal(1)), d)
3115 self.assertRaises(TypeError, c.compare, '1', 1)
3116 self.assertRaises(TypeError, c.compare, 1, '1')
3117
3118 def test_compare_signal(self):
3119 Decimal = self.decimal.Decimal
3120 Context = self.decimal.Context
3121
3122 c = Context()
3123 d = c.compare_signal(Decimal(1), Decimal(1))
3124 self.assertEqual(c.compare_signal(1, 1), d)
3125 self.assertEqual(c.compare_signal(Decimal(1), 1), d)
3126 self.assertEqual(c.compare_signal(1, Decimal(1)), d)
3127 self.assertRaises(TypeError, c.compare_signal, '1', 1)
3128 self.assertRaises(TypeError, c.compare_signal, 1, '1')
3129
3130 def test_compare_total(self):
3131 Decimal = self.decimal.Decimal
3132 Context = self.decimal.Context
3133
3134 c = Context()
3135 d = c.compare_total(Decimal(1), Decimal(1))
3136 self.assertEqual(c.compare_total(1, 1), d)
3137 self.assertEqual(c.compare_total(Decimal(1), 1), d)
3138 self.assertEqual(c.compare_total(1, Decimal(1)), d)
3139 self.assertRaises(TypeError, c.compare_total, '1', 1)
3140 self.assertRaises(TypeError, c.compare_total, 1, '1')
3141
3142 def test_compare_total_mag(self):
3143 Decimal = self.decimal.Decimal
3144 Context = self.decimal.Context
3145
3146 c = Context()
3147 d = c.compare_total_mag(Decimal(1), Decimal(1))
3148 self.assertEqual(c.compare_total_mag(1, 1), d)
3149 self.assertEqual(c.compare_total_mag(Decimal(1), 1), d)
3150 self.assertEqual(c.compare_total_mag(1, Decimal(1)), d)
3151 self.assertRaises(TypeError, c.compare_total_mag, '1', 1)
3152 self.assertRaises(TypeError, c.compare_total_mag, 1, '1')
3153
3154 def test_copy_abs(self):
3155 Decimal = self.decimal.Decimal
3156 Context = self.decimal.Context
3157
3158 c = Context()
3159 d = c.copy_abs(Decimal(-1))
3160 self.assertEqual(c.copy_abs(-1), d)
3161 self.assertRaises(TypeError, c.copy_abs, '-1')
3162
3163 def test_copy_decimal(self):
3164 Decimal = self.decimal.Decimal
3165 Context = self.decimal.Context
3166
3167 c = Context()
3168 d = c.copy_decimal(Decimal(-1))
3169 self.assertEqual(c.copy_decimal(-1), d)
3170 self.assertRaises(TypeError, c.copy_decimal, '-1')
3171
3172 def test_copy_negate(self):
3173 Decimal = self.decimal.Decimal
3174 Context = self.decimal.Context
3175
3176 c = Context()
3177 d = c.copy_negate(Decimal(-1))
3178 self.assertEqual(c.copy_negate(-1), d)
3179 self.assertRaises(TypeError, c.copy_negate, '-1')
3180
3181 def test_copy_sign(self):
3182 Decimal = self.decimal.Decimal
3183 Context = self.decimal.Context
3184
3185 c = Context()
3186 d = c.copy_sign(Decimal(1), Decimal(-2))
3187 self.assertEqual(c.copy_sign(1, -2), d)
3188 self.assertEqual(c.copy_sign(Decimal(1), -2), d)
3189 self.assertEqual(c.copy_sign(1, Decimal(-2)), d)
3190 self.assertRaises(TypeError, c.copy_sign, '1', -2)
3191 self.assertRaises(TypeError, c.copy_sign, 1, '-2')
3192
3193 def test_divide(self):
3194 Decimal = self.decimal.Decimal
3195 Context = self.decimal.Context
3196
3197 c = Context()
3198 d = c.divide(Decimal(1), Decimal(2))
3199 self.assertEqual(c.divide(1, 2), d)
3200 self.assertEqual(c.divide(Decimal(1), 2), d)
3201 self.assertEqual(c.divide(1, Decimal(2)), d)
3202 self.assertRaises(TypeError, c.divide, '1', 2)
3203 self.assertRaises(TypeError, c.divide, 1, '2')
3204
3205 def test_divide_int(self):
3206 Decimal = self.decimal.Decimal
3207 Context = self.decimal.Context
3208
3209 c = Context()
3210 d = c.divide_int(Decimal(1), Decimal(2))
3211 self.assertEqual(c.divide_int(1, 2), d)
3212 self.assertEqual(c.divide_int(Decimal(1), 2), d)
3213 self.assertEqual(c.divide_int(1, Decimal(2)), d)
3214 self.assertRaises(TypeError, c.divide_int, '1', 2)
3215 self.assertRaises(TypeError, c.divide_int, 1, '2')
3216
3217 def test_divmod(self):
3218 Decimal = self.decimal.Decimal
3219 Context = self.decimal.Context
3220
3221 c = Context()
3222 d = c.divmod(Decimal(1), Decimal(2))
3223 self.assertEqual(c.divmod(1, 2), d)
3224 self.assertEqual(c.divmod(Decimal(1), 2), d)
3225 self.assertEqual(c.divmod(1, Decimal(2)), d)
3226 self.assertRaises(TypeError, c.divmod, '1', 2)
3227 self.assertRaises(TypeError, c.divmod, 1, '2')
3228
3229 def test_exp(self):
3230 Decimal = self.decimal.Decimal
3231 Context = self.decimal.Context
3232
3233 c = Context()
3234 d = c.exp(Decimal(10))
3235 self.assertEqual(c.exp(10), d)
3236 self.assertRaises(TypeError, c.exp, '10')
3237
3238 def test_fma(self):
3239 Decimal = self.decimal.Decimal
3240 Context = self.decimal.Context
3241
3242 c = Context()
3243 d = c.fma(Decimal(2), Decimal(3), Decimal(4))
3244 self.assertEqual(c.fma(2, 3, 4), d)
3245 self.assertEqual(c.fma(Decimal(2), 3, 4), d)
3246 self.assertEqual(c.fma(2, Decimal(3), 4), d)
3247 self.assertEqual(c.fma(2, 3, Decimal(4)), d)
3248 self.assertEqual(c.fma(Decimal(2), Decimal(3), 4), d)
3249 self.assertRaises(TypeError, c.fma, '2', 3, 4)
3250 self.assertRaises(TypeError, c.fma, 2, '3', 4)
3251 self.assertRaises(TypeError, c.fma, 2, 3, '4')
3252
3253 # Issue 12079 for Context.fma ...
3254 self.assertRaises(TypeError, c.fma,
3255 Decimal('Infinity'), Decimal(0), "not a decimal")
3256 self.assertRaises(TypeError, c.fma,
3257 Decimal(1), Decimal('snan'), 1.222)
3258 # ... and for Decimal.fma.
3259 self.assertRaises(TypeError, Decimal('Infinity').fma,
3260 Decimal(0), "not a decimal")
3261 self.assertRaises(TypeError, Decimal(1).fma,
3262 Decimal('snan'), 1.222)
3263
3264 def test_is_finite(self):
3265 Decimal = self.decimal.Decimal
3266 Context = self.decimal.Context
3267
3268 c = Context()
3269 d = c.is_finite(Decimal(10))
3270 self.assertEqual(c.is_finite(10), d)
3271 self.assertRaises(TypeError, c.is_finite, '10')
3272
3273 def test_is_infinite(self):
3274 Decimal = self.decimal.Decimal
3275 Context = self.decimal.Context
3276
3277 c = Context()
3278 d = c.is_infinite(Decimal(10))
3279 self.assertEqual(c.is_infinite(10), d)
3280 self.assertRaises(TypeError, c.is_infinite, '10')
3281
3282 def test_is_nan(self):
3283 Decimal = self.decimal.Decimal
3284 Context = self.decimal.Context
3285
3286 c = Context()
3287 d = c.is_nan(Decimal(10))
3288 self.assertEqual(c.is_nan(10), d)
3289 self.assertRaises(TypeError, c.is_nan, '10')
3290
3291 def test_is_normal(self):
3292 Decimal = self.decimal.Decimal
3293 Context = self.decimal.Context
3294
3295 c = Context()
3296 d = c.is_normal(Decimal(10))
3297 self.assertEqual(c.is_normal(10), d)
3298 self.assertRaises(TypeError, c.is_normal, '10')
3299
3300 def test_is_qnan(self):
3301 Decimal = self.decimal.Decimal
3302 Context = self.decimal.Context
3303
3304 c = Context()
3305 d = c.is_qnan(Decimal(10))
3306 self.assertEqual(c.is_qnan(10), d)
3307 self.assertRaises(TypeError, c.is_qnan, '10')
3308
3309 def test_is_signed(self):
3310 Decimal = self.decimal.Decimal
3311 Context = self.decimal.Context
3312
3313 c = Context()
3314 d = c.is_signed(Decimal(10))
3315 self.assertEqual(c.is_signed(10), d)
3316 self.assertRaises(TypeError, c.is_signed, '10')
3317
3318 def test_is_snan(self):
3319 Decimal = self.decimal.Decimal
3320 Context = self.decimal.Context
3321
3322 c = Context()
3323 d = c.is_snan(Decimal(10))
3324 self.assertEqual(c.is_snan(10), d)
3325 self.assertRaises(TypeError, c.is_snan, '10')
3326
3327 def test_is_subnormal(self):
3328 Decimal = self.decimal.Decimal
3329 Context = self.decimal.Context
3330
3331 c = Context()
3332 d = c.is_subnormal(Decimal(10))
3333 self.assertEqual(c.is_subnormal(10), d)
3334 self.assertRaises(TypeError, c.is_subnormal, '10')
3335
3336 def test_is_zero(self):
3337 Decimal = self.decimal.Decimal
3338 Context = self.decimal.Context
3339
3340 c = Context()
3341 d = c.is_zero(Decimal(10))
3342 self.assertEqual(c.is_zero(10), d)
3343 self.assertRaises(TypeError, c.is_zero, '10')
3344
3345 def test_ln(self):
3346 Decimal = self.decimal.Decimal
3347 Context = self.decimal.Context
3348
3349 c = Context()
3350 d = c.ln(Decimal(10))
3351 self.assertEqual(c.ln(10), d)
3352 self.assertRaises(TypeError, c.ln, '10')
3353
3354 def test_log10(self):
3355 Decimal = self.decimal.Decimal
3356 Context = self.decimal.Context
3357
3358 c = Context()
3359 d = c.log10(Decimal(10))
3360 self.assertEqual(c.log10(10), d)
3361 self.assertRaises(TypeError, c.log10, '10')
3362
3363 def test_logb(self):
3364 Decimal = self.decimal.Decimal
3365 Context = self.decimal.Context
3366
3367 c = Context()
3368 d = c.logb(Decimal(10))
3369 self.assertEqual(c.logb(10), d)
3370 self.assertRaises(TypeError, c.logb, '10')
3371
3372 def test_logical_and(self):
3373 Decimal = self.decimal.Decimal
3374 Context = self.decimal.Context
3375
3376 c = Context()
3377 d = c.logical_and(Decimal(1), Decimal(1))
3378 self.assertEqual(c.logical_and(1, 1), d)
3379 self.assertEqual(c.logical_and(Decimal(1), 1), d)
3380 self.assertEqual(c.logical_and(1, Decimal(1)), d)
3381 self.assertRaises(TypeError, c.logical_and, '1', 1)
3382 self.assertRaises(TypeError, c.logical_and, 1, '1')
3383
3384 def test_logical_invert(self):
3385 Decimal = self.decimal.Decimal
3386 Context = self.decimal.Context
3387
3388 c = Context()
3389 d = c.logical_invert(Decimal(1000))
3390 self.assertEqual(c.logical_invert(1000), d)
3391 self.assertRaises(TypeError, c.logical_invert, '1000')
3392
3393 def test_logical_or(self):
3394 Decimal = self.decimal.Decimal
3395 Context = self.decimal.Context
3396
3397 c = Context()
3398 d = c.logical_or(Decimal(1), Decimal(1))
3399 self.assertEqual(c.logical_or(1, 1), d)
3400 self.assertEqual(c.logical_or(Decimal(1), 1), d)
3401 self.assertEqual(c.logical_or(1, Decimal(1)), d)
3402 self.assertRaises(TypeError, c.logical_or, '1', 1)
3403 self.assertRaises(TypeError, c.logical_or, 1, '1')
3404
3405 def test_logical_xor(self):
3406 Decimal = self.decimal.Decimal
3407 Context = self.decimal.Context
3408
3409 c = Context()
3410 d = c.logical_xor(Decimal(1), Decimal(1))
3411 self.assertEqual(c.logical_xor(1, 1), d)
3412 self.assertEqual(c.logical_xor(Decimal(1), 1), d)
3413 self.assertEqual(c.logical_xor(1, Decimal(1)), d)
3414 self.assertRaises(TypeError, c.logical_xor, '1', 1)
3415 self.assertRaises(TypeError, c.logical_xor, 1, '1')
3416
3417 def test_max(self):
3418 Decimal = self.decimal.Decimal
3419 Context = self.decimal.Context
3420
3421 c = Context()
3422 d = c.max(Decimal(1), Decimal(2))
3423 self.assertEqual(c.max(1, 2), d)
3424 self.assertEqual(c.max(Decimal(1), 2), d)
3425 self.assertEqual(c.max(1, Decimal(2)), d)
3426 self.assertRaises(TypeError, c.max, '1', 2)
3427 self.assertRaises(TypeError, c.max, 1, '2')
3428
3429 def test_max_mag(self):
3430 Decimal = self.decimal.Decimal
3431 Context = self.decimal.Context
3432
3433 c = Context()
3434 d = c.max_mag(Decimal(1), Decimal(2))
3435 self.assertEqual(c.max_mag(1, 2), d)
3436 self.assertEqual(c.max_mag(Decimal(1), 2), d)
3437 self.assertEqual(c.max_mag(1, Decimal(2)), d)
3438 self.assertRaises(TypeError, c.max_mag, '1', 2)
3439 self.assertRaises(TypeError, c.max_mag, 1, '2')
3440
3441 def test_min(self):
3442 Decimal = self.decimal.Decimal
3443 Context = self.decimal.Context
3444
3445 c = Context()
3446 d = c.min(Decimal(1), Decimal(2))
3447 self.assertEqual(c.min(1, 2), d)
3448 self.assertEqual(c.min(Decimal(1), 2), d)
3449 self.assertEqual(c.min(1, Decimal(2)), d)
3450 self.assertRaises(TypeError, c.min, '1', 2)
3451 self.assertRaises(TypeError, c.min, 1, '2')
3452
3453 def test_min_mag(self):
3454 Decimal = self.decimal.Decimal
3455 Context = self.decimal.Context
3456
3457 c = Context()
3458 d = c.min_mag(Decimal(1), Decimal(2))
3459 self.assertEqual(c.min_mag(1, 2), d)
3460 self.assertEqual(c.min_mag(Decimal(1), 2), d)
3461 self.assertEqual(c.min_mag(1, Decimal(2)), d)
3462 self.assertRaises(TypeError, c.min_mag, '1', 2)
3463 self.assertRaises(TypeError, c.min_mag, 1, '2')
3464
3465 def test_minus(self):
3466 Decimal = self.decimal.Decimal
3467 Context = self.decimal.Context
3468
3469 c = Context()
3470 d = c.minus(Decimal(10))
3471 self.assertEqual(c.minus(10), d)
3472 self.assertRaises(TypeError, c.minus, '10')
3473
3474 def test_multiply(self):
3475 Decimal = self.decimal.Decimal
3476 Context = self.decimal.Context
3477
3478 c = Context()
3479 d = c.multiply(Decimal(1), Decimal(2))
3480 self.assertEqual(c.multiply(1, 2), d)
3481 self.assertEqual(c.multiply(Decimal(1), 2), d)
3482 self.assertEqual(c.multiply(1, Decimal(2)), d)
3483 self.assertRaises(TypeError, c.multiply, '1', 2)
3484 self.assertRaises(TypeError, c.multiply, 1, '2')
3485
3486 def test_next_minus(self):
3487 Decimal = self.decimal.Decimal
3488 Context = self.decimal.Context
3489
3490 c = Context()
3491 d = c.next_minus(Decimal(10))
3492 self.assertEqual(c.next_minus(10), d)
3493 self.assertRaises(TypeError, c.next_minus, '10')
3494
3495 def test_next_plus(self):
3496 Decimal = self.decimal.Decimal
3497 Context = self.decimal.Context
3498
3499 c = Context()
3500 d = c.next_plus(Decimal(10))
3501 self.assertEqual(c.next_plus(10), d)
3502 self.assertRaises(TypeError, c.next_plus, '10')
3503
3504 def test_next_toward(self):
3505 Decimal = self.decimal.Decimal
3506 Context = self.decimal.Context
3507
3508 c = Context()
3509 d = c.next_toward(Decimal(1), Decimal(2))
3510 self.assertEqual(c.next_toward(1, 2), d)
3511 self.assertEqual(c.next_toward(Decimal(1), 2), d)
3512 self.assertEqual(c.next_toward(1, Decimal(2)), d)
3513 self.assertRaises(TypeError, c.next_toward, '1', 2)
3514 self.assertRaises(TypeError, c.next_toward, 1, '2')
3515
3516 def test_normalize(self):
3517 Decimal = self.decimal.Decimal
3518 Context = self.decimal.Context
3519
3520 c = Context()
3521 d = c.normalize(Decimal(10))
3522 self.assertEqual(c.normalize(10), d)
3523 self.assertRaises(TypeError, c.normalize, '10')
3524
3525 def test_number_class(self):
3526 Decimal = self.decimal.Decimal
3527 Context = self.decimal.Context
3528
3529 c = Context()
3530 self.assertEqual(c.number_class(123), c.number_class(Decimal(123)))
3531 self.assertEqual(c.number_class(0), c.number_class(Decimal(0)))
3532 self.assertEqual(c.number_class(-45), c.number_class(Decimal(-45)))
3533
3534 def test_plus(self):
3535 Decimal = self.decimal.Decimal
3536 Context = self.decimal.Context
3537
3538 c = Context()
3539 d = c.plus(Decimal(10))
3540 self.assertEqual(c.plus(10), d)
3541 self.assertRaises(TypeError, c.plus, '10')
3542
3543 def test_power(self):
3544 Decimal = self.decimal.Decimal
3545 Context = self.decimal.Context
3546
3547 c = Context()
3548 d = c.power(Decimal(1), Decimal(4))
3549 self.assertEqual(c.power(1, 4), d)
3550 self.assertEqual(c.power(Decimal(1), 4), d)
3551 self.assertEqual(c.power(1, Decimal(4)), d)
3552 self.assertEqual(c.power(Decimal(1), Decimal(4)), d)
3553 self.assertRaises(TypeError, c.power, '1', 4)
3554 self.assertRaises(TypeError, c.power, 1, '4')
3555 self.assertEqual(c.power(modulo=5, b=8, a=2), 1)
3556
3557 def test_quantize(self):
3558 Decimal = self.decimal.Decimal
3559 Context = self.decimal.Context
3560
3561 c = Context()
3562 d = c.quantize(Decimal(1), Decimal(2))
3563 self.assertEqual(c.quantize(1, 2), d)
3564 self.assertEqual(c.quantize(Decimal(1), 2), d)
3565 self.assertEqual(c.quantize(1, Decimal(2)), d)
3566 self.assertRaises(TypeError, c.quantize, '1', 2)
3567 self.assertRaises(TypeError, c.quantize, 1, '2')
3568
3569 def test_remainder(self):
3570 Decimal = self.decimal.Decimal
3571 Context = self.decimal.Context
3572
3573 c = Context()
3574 d = c.remainder(Decimal(1), Decimal(2))
3575 self.assertEqual(c.remainder(1, 2), d)
3576 self.assertEqual(c.remainder(Decimal(1), 2), d)
3577 self.assertEqual(c.remainder(1, Decimal(2)), d)
3578 self.assertRaises(TypeError, c.remainder, '1', 2)
3579 self.assertRaises(TypeError, c.remainder, 1, '2')
3580
3581 def test_remainder_near(self):
3582 Decimal = self.decimal.Decimal
3583 Context = self.decimal.Context
3584
3585 c = Context()
3586 d = c.remainder_near(Decimal(1), Decimal(2))
3587 self.assertEqual(c.remainder_near(1, 2), d)
3588 self.assertEqual(c.remainder_near(Decimal(1), 2), d)
3589 self.assertEqual(c.remainder_near(1, Decimal(2)), d)
3590 self.assertRaises(TypeError, c.remainder_near, '1', 2)
3591 self.assertRaises(TypeError, c.remainder_near, 1, '2')
3592
3593 def test_rotate(self):
3594 Decimal = self.decimal.Decimal
3595 Context = self.decimal.Context
3596
3597 c = Context()
3598 d = c.rotate(Decimal(1), Decimal(2))
3599 self.assertEqual(c.rotate(1, 2), d)
3600 self.assertEqual(c.rotate(Decimal(1), 2), d)
3601 self.assertEqual(c.rotate(1, Decimal(2)), d)
3602 self.assertRaises(TypeError, c.rotate, '1', 2)
3603 self.assertRaises(TypeError, c.rotate, 1, '2')
3604
3605 def test_sqrt(self):
3606 Decimal = self.decimal.Decimal
3607 Context = self.decimal.Context
3608
3609 c = Context()
3610 d = c.sqrt(Decimal(10))
3611 self.assertEqual(c.sqrt(10), d)
3612 self.assertRaises(TypeError, c.sqrt, '10')
3613
3614 def test_same_quantum(self):
3615 Decimal = self.decimal.Decimal
3616 Context = self.decimal.Context
3617
3618 c = Context()
3619 d = c.same_quantum(Decimal(1), Decimal(2))
3620 self.assertEqual(c.same_quantum(1, 2), d)
3621 self.assertEqual(c.same_quantum(Decimal(1), 2), d)
3622 self.assertEqual(c.same_quantum(1, Decimal(2)), d)
3623 self.assertRaises(TypeError, c.same_quantum, '1', 2)
3624 self.assertRaises(TypeError, c.same_quantum, 1, '2')
3625
3626 def test_scaleb(self):
3627 Decimal = self.decimal.Decimal
3628 Context = self.decimal.Context
3629
3630 c = Context()
3631 d = c.scaleb(Decimal(1), Decimal(2))
3632 self.assertEqual(c.scaleb(1, 2), d)
3633 self.assertEqual(c.scaleb(Decimal(1), 2), d)
3634 self.assertEqual(c.scaleb(1, Decimal(2)), d)
3635 self.assertRaises(TypeError, c.scaleb, '1', 2)
3636 self.assertRaises(TypeError, c.scaleb, 1, '2')
3637
3638 def test_shift(self):
3639 Decimal = self.decimal.Decimal
3640 Context = self.decimal.Context
3641
3642 c = Context()
3643 d = c.shift(Decimal(1), Decimal(2))
3644 self.assertEqual(c.shift(1, 2), d)
3645 self.assertEqual(c.shift(Decimal(1), 2), d)
3646 self.assertEqual(c.shift(1, Decimal(2)), d)
3647 self.assertRaises(TypeError, c.shift, '1', 2)
3648 self.assertRaises(TypeError, c.shift, 1, '2')
3649
3650 def test_subtract(self):
3651 Decimal = self.decimal.Decimal
3652 Context = self.decimal.Context
3653
3654 c = Context()
3655 d = c.subtract(Decimal(1), Decimal(2))
3656 self.assertEqual(c.subtract(1, 2), d)
3657 self.assertEqual(c.subtract(Decimal(1), 2), d)
3658 self.assertEqual(c.subtract(1, Decimal(2)), d)
3659 self.assertRaises(TypeError, c.subtract, '1', 2)
3660 self.assertRaises(TypeError, c.subtract, 1, '2')
3661
3662 def test_to_eng_string(self):
3663 Decimal = self.decimal.Decimal
3664 Context = self.decimal.Context
3665
3666 c = Context()
3667 d = c.to_eng_string(Decimal(10))
3668 self.assertEqual(c.to_eng_string(10), d)
3669 self.assertRaises(TypeError, c.to_eng_string, '10')
3670
3671 def test_to_sci_string(self):
3672 Decimal = self.decimal.Decimal
3673 Context = self.decimal.Context
3674
3675 c = Context()
3676 d = c.to_sci_string(Decimal(10))
3677 self.assertEqual(c.to_sci_string(10), d)
3678 self.assertRaises(TypeError, c.to_sci_string, '10')
3679
3680 def test_to_integral_exact(self):
3681 Decimal = self.decimal.Decimal
3682 Context = self.decimal.Context
3683
3684 c = Context()
3685 d = c.to_integral_exact(Decimal(10))
3686 self.assertEqual(c.to_integral_exact(10), d)
3687 self.assertRaises(TypeError, c.to_integral_exact, '10')
3688
3689 def test_to_integral_value(self):
3690 Decimal = self.decimal.Decimal
3691 Context = self.decimal.Context
3692
3693 c = Context()
3694 d = c.to_integral_value(Decimal(10))
3695 self.assertEqual(c.to_integral_value(10), d)
3696 self.assertRaises(TypeError, c.to_integral_value, '10')
3697 self.assertRaises(TypeError, c.to_integral_value, 10, 'x')
3698
3699 @requires_cdecimal
3700 class CContextAPItests(ContextAPItests, unittest.TestCase):
3701 decimal = C
3702 class PyContextAPItests(ContextAPItests, unittest.TestCase):
3703 decimal = P
3704
3705 class ContextWithStatement:
3706 # Can't do these as docstrings until Python 2.6
3707 # as doctest can't handle __future__ statements
3708
3709 def test_localcontext(self):
3710 # Use a copy of the current context in the block
3711 getcontext = self.decimal.getcontext
3712 localcontext = self.decimal.localcontext
3713
3714 orig_ctx = getcontext()
3715 with localcontext() as enter_ctx:
3716 set_ctx = getcontext()
3717 final_ctx = getcontext()
3718 self.assertIs(orig_ctx, final_ctx, 'did not restore context correctly')
3719 self.assertIsNot(orig_ctx, set_ctx, 'did not copy the context')
3720 self.assertIs(set_ctx, enter_ctx, '__enter__ returned wrong context')
3721
3722 def test_localcontextarg(self):
3723 # Use a copy of the supplied context in the block
3724 Context = self.decimal.Context
3725 getcontext = self.decimal.getcontext
3726 localcontext = self.decimal.localcontext
3727
3728 localcontext = self.decimal.localcontext
3729 orig_ctx = getcontext()
3730 new_ctx = Context(prec=42)
3731 with localcontext(new_ctx) as enter_ctx:
3732 set_ctx = getcontext()
3733 final_ctx = getcontext()
3734 self.assertIs(orig_ctx, final_ctx, 'did not restore context correctly')
3735 self.assertEqual(set_ctx.prec, new_ctx.prec, 'did not set correct context')
3736 self.assertIsNot(new_ctx, set_ctx, 'did not copy the context')
3737 self.assertIs(set_ctx, enter_ctx, '__enter__ returned wrong context')
3738
3739 def test_localcontext_kwargs(self):
3740 with self.decimal.localcontext(
3741 prec=10, rounding=ROUND_HALF_DOWN,
3742 Emin=-20, Emax=20, capitals=0,
3743 clamp=1
3744 ) as ctx:
3745 self.assertEqual(ctx.prec, 10)
3746 self.assertEqual(ctx.rounding, self.decimal.ROUND_HALF_DOWN)
3747 self.assertEqual(ctx.Emin, -20)
3748 self.assertEqual(ctx.Emax, 20)
3749 self.assertEqual(ctx.capitals, 0)
3750 self.assertEqual(ctx.clamp, 1)
3751
3752 self.assertRaises(TypeError, self.decimal.localcontext, precision=10)
3753
3754 self.assertRaises(ValueError, self.decimal.localcontext, Emin=1)
3755 self.assertRaises(ValueError, self.decimal.localcontext, Emax=-1)
3756 self.assertRaises(ValueError, self.decimal.localcontext, capitals=2)
3757 self.assertRaises(ValueError, self.decimal.localcontext, clamp=2)
3758
3759 self.assertRaises(TypeError, self.decimal.localcontext, rounding="")
3760 self.assertRaises(TypeError, self.decimal.localcontext, rounding=1)
3761
3762 self.assertRaises(TypeError, self.decimal.localcontext, flags="")
3763 self.assertRaises(TypeError, self.decimal.localcontext, traps="")
3764 self.assertRaises(TypeError, self.decimal.localcontext, Emin="")
3765 self.assertRaises(TypeError, self.decimal.localcontext, Emax="")
3766
3767 def test_local_context_kwargs_does_not_overwrite_existing_argument(self):
3768 ctx = self.decimal.getcontext()
3769 orig_prec = ctx.prec
3770 with self.decimal.localcontext(prec=10) as ctx2:
3771 self.assertEqual(ctx2.prec, 10)
3772 self.assertEqual(ctx.prec, orig_prec)
3773 with self.decimal.localcontext(prec=20) as ctx2:
3774 self.assertEqual(ctx2.prec, 20)
3775 self.assertEqual(ctx.prec, orig_prec)
3776
3777 def test_nested_with_statements(self):
3778 # Use a copy of the supplied context in the block
3779 Decimal = self.decimal.Decimal
3780 Context = self.decimal.Context
3781 getcontext = self.decimal.getcontext
3782 localcontext = self.decimal.localcontext
3783 Clamped = self.decimal.Clamped
3784 Overflow = self.decimal.Overflow
3785
3786 orig_ctx = getcontext()
3787 orig_ctx.clear_flags()
3788 new_ctx = Context(Emax=384)
3789 with localcontext() as c1:
3790 self.assertEqual(c1.flags, orig_ctx.flags)
3791 self.assertEqual(c1.traps, orig_ctx.traps)
3792 c1.traps[Clamped] = True
3793 c1.Emin = -383
3794 self.assertNotEqual(orig_ctx.Emin, -383)
3795 self.assertRaises(Clamped, c1.create_decimal, '0e-999')
3796 self.assertTrue(c1.flags[Clamped])
3797 with localcontext(new_ctx) as c2:
3798 self.assertEqual(c2.flags, new_ctx.flags)
3799 self.assertEqual(c2.traps, new_ctx.traps)
3800 self.assertRaises(Overflow, c2.power, Decimal('3.4e200'), 2)
3801 self.assertFalse(c2.flags[Clamped])
3802 self.assertTrue(c2.flags[Overflow])
3803 del c2
3804 self.assertFalse(c1.flags[Overflow])
3805 del c1
3806 self.assertNotEqual(orig_ctx.Emin, -383)
3807 self.assertFalse(orig_ctx.flags[Clamped])
3808 self.assertFalse(orig_ctx.flags[Overflow])
3809 self.assertFalse(new_ctx.flags[Clamped])
3810 self.assertFalse(new_ctx.flags[Overflow])
3811
3812 def test_with_statements_gc1(self):
3813 localcontext = self.decimal.localcontext
3814
3815 with localcontext() as c1:
3816 del c1
3817 with localcontext() as c2:
3818 del c2
3819 with localcontext() as c3:
3820 del c3
3821 with localcontext() as c4:
3822 del c4
3823
3824 def test_with_statements_gc2(self):
3825 localcontext = self.decimal.localcontext
3826
3827 with localcontext() as c1:
3828 with localcontext(c1) as c2:
3829 del c1
3830 with localcontext(c2) as c3:
3831 del c2
3832 with localcontext(c3) as c4:
3833 del c3
3834 del c4
3835
3836 def test_with_statements_gc3(self):
3837 Context = self.decimal.Context
3838 localcontext = self.decimal.localcontext
3839 getcontext = self.decimal.getcontext
3840 setcontext = self.decimal.setcontext
3841
3842 with localcontext() as c1:
3843 del c1
3844 n1 = Context(prec=1)
3845 setcontext(n1)
3846 with localcontext(n1) as c2:
3847 del n1
3848 self.assertEqual(c2.prec, 1)
3849 del c2
3850 n2 = Context(prec=2)
3851 setcontext(n2)
3852 del n2
3853 self.assertEqual(getcontext().prec, 2)
3854 n3 = Context(prec=3)
3855 setcontext(n3)
3856 self.assertEqual(getcontext().prec, 3)
3857 with localcontext(n3) as c3:
3858 del n3
3859 self.assertEqual(c3.prec, 3)
3860 del c3
3861 n4 = Context(prec=4)
3862 setcontext(n4)
3863 del n4
3864 self.assertEqual(getcontext().prec, 4)
3865 with localcontext() as c4:
3866 self.assertEqual(c4.prec, 4)
3867 del c4
3868
3869 @requires_cdecimal
3870 class CContextWithStatement(ContextWithStatement, unittest.TestCase):
3871 decimal = C
3872 class PyContextWithStatement(ContextWithStatement, unittest.TestCase):
3873 decimal = P
3874
3875 class ContextFlags:
3876
3877 def test_flags_irrelevant(self):
3878 # check that the result (numeric result + flags raised) of an
3879 # arithmetic operation doesn't depend on the current flags
3880 Decimal = self.decimal.Decimal
3881 Context = self.decimal.Context
3882 Inexact = self.decimal.Inexact
3883 Rounded = self.decimal.Rounded
3884 Underflow = self.decimal.Underflow
3885 Clamped = self.decimal.Clamped
3886 Subnormal = self.decimal.Subnormal
3887
3888 def raise_error(context, flag):
3889 if self.decimal == C:
3890 context.flags[flag] = True
3891 if context.traps[flag]:
3892 raise flag
3893 else:
3894 context._raise_error(flag)
3895
3896 context = Context(prec=9, Emin = -425000000, Emax = 425000000,
3897 rounding=ROUND_HALF_EVEN, traps=[], flags=[])
3898
3899 # operations that raise various flags, in the form (function, arglist)
3900 operations = [
3901 (context._apply, [Decimal("100E-425000010")]),
3902 (context.sqrt, [Decimal(2)]),
3903 (context.add, [Decimal("1.23456789"), Decimal("9.87654321")]),
3904 (context.multiply, [Decimal("1.23456789"), Decimal("9.87654321")]),
3905 (context.subtract, [Decimal("1.23456789"), Decimal("9.87654321")]),
3906 ]
3907
3908 # try various flags individually, then a whole lot at once
3909 flagsets = [[Inexact], [Rounded], [Underflow], [Clamped], [Subnormal],
3910 [Inexact, Rounded, Underflow, Clamped, Subnormal]]
3911
3912 for fn, args in operations:
3913 # find answer and flags raised using a clean context
3914 context.clear_flags()
3915 ans = fn(*args)
3916 flags = [k for k, v in context.flags.items() if v]
3917
3918 for extra_flags in flagsets:
3919 # set flags, before calling operation
3920 context.clear_flags()
3921 for flag in extra_flags:
3922 raise_error(context, flag)
3923 new_ans = fn(*args)
3924
3925 # flags that we expect to be set after the operation
3926 expected_flags = list(flags)
3927 for flag in extra_flags:
3928 if flag not in expected_flags:
3929 expected_flags.append(flag)
3930 expected_flags.sort(key=id)
3931
3932 # flags we actually got
3933 new_flags = [k for k,v in context.flags.items() if v]
3934 new_flags.sort(key=id)
3935
3936 self.assertEqual(ans, new_ans,
3937 "operation produces different answers depending on flags set: " +
3938 "expected %s, got %s." % (ans, new_ans))
3939 self.assertEqual(new_flags, expected_flags,
3940 "operation raises different flags depending on flags set: " +
3941 "expected %s, got %s" % (expected_flags, new_flags))
3942
3943 def test_flag_comparisons(self):
3944 Context = self.decimal.Context
3945 Inexact = self.decimal.Inexact
3946 Rounded = self.decimal.Rounded
3947
3948 c = Context()
3949
3950 # Valid SignalDict
3951 self.assertNotEqual(c.flags, c.traps)
3952 self.assertNotEqual(c.traps, c.flags)
3953
3954 c.flags = c.traps
3955 self.assertEqual(c.flags, c.traps)
3956 self.assertEqual(c.traps, c.flags)
3957
3958 c.flags[Rounded] = True
3959 c.traps = c.flags
3960 self.assertEqual(c.flags, c.traps)
3961 self.assertEqual(c.traps, c.flags)
3962
3963 d = {}
3964 d.update(c.flags)
3965 self.assertEqual(d, c.flags)
3966 self.assertEqual(c.flags, d)
3967
3968 d[Inexact] = True
3969 self.assertNotEqual(d, c.flags)
3970 self.assertNotEqual(c.flags, d)
3971
3972 # Invalid SignalDict
3973 d = {Inexact:False}
3974 self.assertNotEqual(d, c.flags)
3975 self.assertNotEqual(c.flags, d)
3976
3977 d = ["xyz"]
3978 self.assertNotEqual(d, c.flags)
3979 self.assertNotEqual(c.flags, d)
3980
3981 @requires_IEEE_754
3982 def test_float_operation(self):
3983 Decimal = self.decimal.Decimal
3984 FloatOperation = self.decimal.FloatOperation
3985 localcontext = self.decimal.localcontext
3986
3987 with localcontext() as c:
3988 ##### trap is off by default
3989 self.assertFalse(c.traps[FloatOperation])
3990
3991 # implicit conversion sets the flag
3992 c.clear_flags()
3993 self.assertEqual(Decimal(7.5), 7.5)
3994 self.assertTrue(c.flags[FloatOperation])
3995
3996 c.clear_flags()
3997 self.assertEqual(c.create_decimal(7.5), 7.5)
3998 self.assertTrue(c.flags[FloatOperation])
3999
4000 # explicit conversion does not set the flag
4001 c.clear_flags()
4002 x = Decimal.from_float(7.5)
4003 self.assertFalse(c.flags[FloatOperation])
4004 # comparison sets the flag
4005 self.assertEqual(x, 7.5)
4006 self.assertTrue(c.flags[FloatOperation])
4007
4008 c.clear_flags()
4009 x = c.create_decimal_from_float(7.5)
4010 self.assertFalse(c.flags[FloatOperation])
4011 self.assertEqual(x, 7.5)
4012 self.assertTrue(c.flags[FloatOperation])
4013
4014 ##### set the trap
4015 c.traps[FloatOperation] = True
4016
4017 # implicit conversion raises
4018 c.clear_flags()
4019 self.assertRaises(FloatOperation, Decimal, 7.5)
4020 self.assertTrue(c.flags[FloatOperation])
4021
4022 c.clear_flags()
4023 self.assertRaises(FloatOperation, c.create_decimal, 7.5)
4024 self.assertTrue(c.flags[FloatOperation])
4025
4026 # explicit conversion is silent
4027 c.clear_flags()
4028 x = Decimal.from_float(7.5)
4029 self.assertFalse(c.flags[FloatOperation])
4030
4031 c.clear_flags()
4032 x = c.create_decimal_from_float(7.5)
4033 self.assertFalse(c.flags[FloatOperation])
4034
4035 def test_float_comparison(self):
4036 Decimal = self.decimal.Decimal
4037 Context = self.decimal.Context
4038 FloatOperation = self.decimal.FloatOperation
4039 localcontext = self.decimal.localcontext
4040
4041 def assert_attr(a, b, attr, context, signal=None):
4042 context.clear_flags()
4043 f = getattr(a, attr)
4044 if signal == FloatOperation:
4045 self.assertRaises(signal, f, b)
4046 else:
4047 self.assertIs(f(b), True)
4048 self.assertTrue(context.flags[FloatOperation])
4049
4050 small_d = Decimal('0.25')
4051 big_d = Decimal('3.0')
4052 small_f = 0.25
4053 big_f = 3.0
4054
4055 zero_d = Decimal('0.0')
4056 neg_zero_d = Decimal('-0.0')
4057 zero_f = 0.0
4058 neg_zero_f = -0.0
4059
4060 inf_d = Decimal('Infinity')
4061 neg_inf_d = Decimal('-Infinity')
4062 inf_f = float('inf')
4063 neg_inf_f = float('-inf')
4064
4065 def doit(c, signal=None):
4066 # Order
4067 for attr in '__lt__', '__le__':
4068 assert_attr(small_d, big_f, attr, c, signal)
4069
4070 for attr in '__gt__', '__ge__':
4071 assert_attr(big_d, small_f, attr, c, signal)
4072
4073 # Equality
4074 assert_attr(small_d, small_f, '__eq__', c, None)
4075
4076 assert_attr(neg_zero_d, neg_zero_f, '__eq__', c, None)
4077 assert_attr(neg_zero_d, zero_f, '__eq__', c, None)
4078
4079 assert_attr(zero_d, neg_zero_f, '__eq__', c, None)
4080 assert_attr(zero_d, zero_f, '__eq__', c, None)
4081
4082 assert_attr(neg_inf_d, neg_inf_f, '__eq__', c, None)
4083 assert_attr(inf_d, inf_f, '__eq__', c, None)
4084
4085 # Inequality
4086 assert_attr(small_d, big_f, '__ne__', c, None)
4087
4088 assert_attr(Decimal('0.1'), 0.1, '__ne__', c, None)
4089
4090 assert_attr(neg_inf_d, inf_f, '__ne__', c, None)
4091 assert_attr(inf_d, neg_inf_f, '__ne__', c, None)
4092
4093 assert_attr(Decimal('NaN'), float('nan'), '__ne__', c, None)
4094
4095 def test_containers(c, signal=None):
4096 c.clear_flags()
4097 s = set([100.0, Decimal('100.0')])
4098 self.assertEqual(len(s), 1)
4099 self.assertTrue(c.flags[FloatOperation])
4100
4101 c.clear_flags()
4102 if signal:
4103 self.assertRaises(signal, sorted, [1.0, Decimal('10.0')])
4104 else:
4105 s = sorted([10.0, Decimal('10.0')])
4106 self.assertTrue(c.flags[FloatOperation])
4107
4108 c.clear_flags()
4109 b = 10.0 in [Decimal('10.0'), 1.0]
4110 self.assertTrue(c.flags[FloatOperation])
4111
4112 c.clear_flags()
4113 b = 10.0 in {Decimal('10.0'):'a', 1.0:'b'}
4114 self.assertTrue(c.flags[FloatOperation])
4115
4116 nc = Context()
4117 with localcontext(nc) as c:
4118 self.assertFalse(c.traps[FloatOperation])
4119 doit(c, signal=None)
4120 test_containers(c, signal=None)
4121
4122 c.traps[FloatOperation] = True
4123 doit(c, signal=FloatOperation)
4124 test_containers(c, signal=FloatOperation)
4125
4126 def test_float_operation_default(self):
4127 Decimal = self.decimal.Decimal
4128 Context = self.decimal.Context
4129 Inexact = self.decimal.Inexact
4130 FloatOperation= self.decimal.FloatOperation
4131
4132 context = Context()
4133 self.assertFalse(context.flags[FloatOperation])
4134 self.assertFalse(context.traps[FloatOperation])
4135
4136 context.clear_traps()
4137 context.traps[Inexact] = True
4138 context.traps[FloatOperation] = True
4139 self.assertTrue(context.traps[FloatOperation])
4140 self.assertTrue(context.traps[Inexact])
4141
4142 @requires_cdecimal
4143 class CContextFlags(ContextFlags, unittest.TestCase):
4144 decimal = C
4145 class PyContextFlags(ContextFlags, unittest.TestCase):
4146 decimal = P
4147
4148 class SpecialContexts:
4149 """Test the context templates."""
4150
4151 def test_context_templates(self):
4152 BasicContext = self.decimal.BasicContext
4153 ExtendedContext = self.decimal.ExtendedContext
4154 getcontext = self.decimal.getcontext
4155 setcontext = self.decimal.setcontext
4156 InvalidOperation = self.decimal.InvalidOperation
4157 DivisionByZero = self.decimal.DivisionByZero
4158 Overflow = self.decimal.Overflow
4159 Underflow = self.decimal.Underflow
4160 Clamped = self.decimal.Clamped
4161
4162 assert_signals(self, BasicContext, 'traps',
4163 [InvalidOperation, DivisionByZero, Overflow, Underflow, Clamped]
4164 )
4165
4166 savecontext = getcontext().copy()
4167 basic_context_prec = BasicContext.prec
4168 extended_context_prec = ExtendedContext.prec
4169
4170 ex = None
4171 try:
4172 BasicContext.prec = ExtendedContext.prec = 441
4173 for template in BasicContext, ExtendedContext:
4174 setcontext(template)
4175 c = getcontext()
4176 self.assertIsNot(c, template)
4177 self.assertEqual(c.prec, 441)
4178 except Exception as e:
4179 ex = e.__class__
4180 finally:
4181 BasicContext.prec = basic_context_prec
4182 ExtendedContext.prec = extended_context_prec
4183 setcontext(savecontext)
4184 if ex:
4185 raise ex
4186
4187 def test_default_context(self):
4188 DefaultContext = self.decimal.DefaultContext
4189 BasicContext = self.decimal.BasicContext
4190 ExtendedContext = self.decimal.ExtendedContext
4191 getcontext = self.decimal.getcontext
4192 setcontext = self.decimal.setcontext
4193 InvalidOperation = self.decimal.InvalidOperation
4194 DivisionByZero = self.decimal.DivisionByZero
4195 Overflow = self.decimal.Overflow
4196
4197 self.assertEqual(BasicContext.prec, 9)
4198 self.assertEqual(ExtendedContext.prec, 9)
4199
4200 assert_signals(self, DefaultContext, 'traps',
4201 [InvalidOperation, DivisionByZero, Overflow]
4202 )
4203
4204 savecontext = getcontext().copy()
4205 default_context_prec = DefaultContext.prec
4206
4207 ex = None
4208 try:
4209 c = getcontext()
4210 saveprec = c.prec
4211
4212 DefaultContext.prec = 961
4213 c = getcontext()
4214 self.assertEqual(c.prec, saveprec)
4215
4216 setcontext(DefaultContext)
4217 c = getcontext()
4218 self.assertIsNot(c, DefaultContext)
4219 self.assertEqual(c.prec, 961)
4220 except Exception as e:
4221 ex = e.__class__
4222 finally:
4223 DefaultContext.prec = default_context_prec
4224 setcontext(savecontext)
4225 if ex:
4226 raise ex
4227
4228 @requires_cdecimal
4229 class CSpecialContexts(SpecialContexts, unittest.TestCase):
4230 decimal = C
4231 class PySpecialContexts(SpecialContexts, unittest.TestCase):
4232 decimal = P
4233
4234 class ContextInputValidation:
4235
4236 def test_invalid_context(self):
4237 Context = self.decimal.Context
4238 DefaultContext = self.decimal.DefaultContext
4239
4240 c = DefaultContext.copy()
4241
4242 # prec, Emax
4243 for attr in ['prec', 'Emax']:
4244 setattr(c, attr, 999999)
4245 self.assertEqual(getattr(c, attr), 999999)
4246 self.assertRaises(ValueError, setattr, c, attr, -1)
4247 self.assertRaises(TypeError, setattr, c, attr, 'xyz')
4248
4249 # Emin
4250 setattr(c, 'Emin', -999999)
4251 self.assertEqual(getattr(c, 'Emin'), -999999)
4252 self.assertRaises(ValueError, setattr, c, 'Emin', 1)
4253 self.assertRaises(TypeError, setattr, c, 'Emin', (1,2,3))
4254
4255 self.assertRaises(TypeError, setattr, c, 'rounding', -1)
4256 self.assertRaises(TypeError, setattr, c, 'rounding', 9)
4257 self.assertRaises(TypeError, setattr, c, 'rounding', 1.0)
4258 self.assertRaises(TypeError, setattr, c, 'rounding', 'xyz')
4259
4260 # capitals, clamp
4261 for attr in ['capitals', 'clamp']:
4262 self.assertRaises(ValueError, setattr, c, attr, -1)
4263 self.assertRaises(ValueError, setattr, c, attr, 2)
4264 self.assertRaises(TypeError, setattr, c, attr, [1,2,3])
4265
4266 # Invalid attribute
4267 self.assertRaises(AttributeError, setattr, c, 'emax', 100)
4268
4269 # Invalid signal dict
4270 self.assertRaises(TypeError, setattr, c, 'flags', [])
4271 self.assertRaises(KeyError, setattr, c, 'flags', {})
4272 self.assertRaises(KeyError, setattr, c, 'traps',
4273 {'InvalidOperation':0})
4274
4275 # Attributes cannot be deleted
4276 for attr in ['prec', 'Emax', 'Emin', 'rounding', 'capitals', 'clamp',
4277 'flags', 'traps']:
4278 self.assertRaises(AttributeError, c.__delattr__, attr)
4279
4280 # Invalid attributes
4281 self.assertRaises(TypeError, getattr, c, 9)
4282 self.assertRaises(TypeError, setattr, c, 9)
4283
4284 # Invalid values in constructor
4285 self.assertRaises(TypeError, Context, rounding=999999)
4286 self.assertRaises(TypeError, Context, rounding='xyz')
4287 self.assertRaises(ValueError, Context, clamp=2)
4288 self.assertRaises(ValueError, Context, capitals=-1)
4289 self.assertRaises(KeyError, Context, flags=["P"])
4290 self.assertRaises(KeyError, Context, traps=["Q"])
4291
4292 # Type error in conversion
4293 self.assertRaises(TypeError, Context, flags=(0,1))
4294 self.assertRaises(TypeError, Context, traps=(1,0))
4295
4296 @requires_cdecimal
4297 class CContextInputValidation(ContextInputValidation, unittest.TestCase):
4298 decimal = C
4299 class PyContextInputValidation(ContextInputValidation, unittest.TestCase):
4300 decimal = P
4301
4302 class ContextSubclassing:
4303
4304 def test_context_subclassing(self):
4305 decimal = self.decimal
4306 Decimal = decimal.Decimal
4307 Context = decimal.Context
4308 Clamped = decimal.Clamped
4309 DivisionByZero = decimal.DivisionByZero
4310 Inexact = decimal.Inexact
4311 Overflow = decimal.Overflow
4312 Rounded = decimal.Rounded
4313 Subnormal = decimal.Subnormal
4314 Underflow = decimal.Underflow
4315 InvalidOperation = decimal.InvalidOperation
4316
4317 class MyContext(Context):
4318 def __init__(self, prec=None, rounding=None, Emin=None, Emax=None,
4319 capitals=None, clamp=None, flags=None,
4320 traps=None):
4321 Context.__init__(self)
4322 if prec is not None:
4323 self.prec = prec
4324 if rounding is not None:
4325 self.rounding = rounding
4326 if Emin is not None:
4327 self.Emin = Emin
4328 if Emax is not None:
4329 self.Emax = Emax
4330 if capitals is not None:
4331 self.capitals = capitals
4332 if clamp is not None:
4333 self.clamp = clamp
4334 if flags is not None:
4335 if isinstance(flags, list):
4336 flags = {v:(v in flags) for v in OrderedSignals[decimal] + flags}
4337 self.flags = flags
4338 if traps is not None:
4339 if isinstance(traps, list):
4340 traps = {v:(v in traps) for v in OrderedSignals[decimal] + traps}
4341 self.traps = traps
4342
4343 c = Context()
4344 d = MyContext()
4345 for attr in ('prec', 'rounding', 'Emin', 'Emax', 'capitals', 'clamp',
4346 'flags', 'traps'):
4347 self.assertEqual(getattr(c, attr), getattr(d, attr))
4348
4349 # prec
4350 self.assertRaises(ValueError, MyContext, **{'prec':-1})
4351 c = MyContext(prec=1)
4352 self.assertEqual(c.prec, 1)
4353 self.assertRaises(InvalidOperation, c.quantize, Decimal('9e2'), 0)
4354
4355 # rounding
4356 self.assertRaises(TypeError, MyContext, **{'rounding':'XYZ'})
4357 c = MyContext(rounding=ROUND_DOWN, prec=1)
4358 self.assertEqual(c.rounding, ROUND_DOWN)
4359 self.assertEqual(c.plus(Decimal('9.9')), 9)
4360
4361 # Emin
4362 self.assertRaises(ValueError, MyContext, **{'Emin':5})
4363 c = MyContext(Emin=-1, prec=1)
4364 self.assertEqual(c.Emin, -1)
4365 x = c.add(Decimal('1e-99'), Decimal('2.234e-2000'))
4366 self.assertEqual(x, Decimal('0.0'))
4367 for signal in (Inexact, Underflow, Subnormal, Rounded, Clamped):
4368 self.assertTrue(c.flags[signal])
4369
4370 # Emax
4371 self.assertRaises(ValueError, MyContext, **{'Emax':-1})
4372 c = MyContext(Emax=1, prec=1)
4373 self.assertEqual(c.Emax, 1)
4374 self.assertRaises(Overflow, c.add, Decimal('1e99'), Decimal('2.234e2000'))
4375 if self.decimal == C:
4376 for signal in (Inexact, Overflow, Rounded):
4377 self.assertTrue(c.flags[signal])
4378
4379 # capitals
4380 self.assertRaises(ValueError, MyContext, **{'capitals':-1})
4381 c = MyContext(capitals=0)
4382 self.assertEqual(c.capitals, 0)
4383 x = c.create_decimal('1E222')
4384 self.assertEqual(c.to_sci_string(x), '1e+222')
4385
4386 # clamp
4387 self.assertRaises(ValueError, MyContext, **{'clamp':2})
4388 c = MyContext(clamp=1, Emax=99)
4389 self.assertEqual(c.clamp, 1)
4390 x = c.plus(Decimal('1e99'))
4391 self.assertEqual(str(x), '1.000000000000000000000000000E+99')
4392
4393 # flags
4394 self.assertRaises(TypeError, MyContext, **{'flags':'XYZ'})
4395 c = MyContext(flags=[Rounded, DivisionByZero])
4396 for signal in (Rounded, DivisionByZero):
4397 self.assertTrue(c.flags[signal])
4398 c.clear_flags()
4399 for signal in OrderedSignals[decimal]:
4400 self.assertFalse(c.flags[signal])
4401
4402 # traps
4403 self.assertRaises(TypeError, MyContext, **{'traps':'XYZ'})
4404 c = MyContext(traps=[Rounded, DivisionByZero])
4405 for signal in (Rounded, DivisionByZero):
4406 self.assertTrue(c.traps[signal])
4407 c.clear_traps()
4408 for signal in OrderedSignals[decimal]:
4409 self.assertFalse(c.traps[signal])
4410
4411 @requires_cdecimal
4412 class CContextSubclassing(ContextSubclassing, unittest.TestCase):
4413 decimal = C
4414 class PyContextSubclassing(ContextSubclassing, unittest.TestCase):
4415 decimal = P
4416
4417 class IEEEContexts:
4418
4419 def test_ieee_context(self):
4420 # issue 8786: Add support for IEEE 754 contexts to decimal module.
4421 IEEEContext = self.decimal.IEEEContext
4422
4423 def assert_rest(self, context):
4424 self.assertEqual(context.clamp, 1)
4425 assert_signals(self, context, 'traps', [])
4426 assert_signals(self, context, 'flags', [])
4427
4428 c = IEEEContext(32)
4429 self.assertEqual(c.prec, 7)
4430 self.assertEqual(c.Emax, 96)
4431 self.assertEqual(c.Emin, -95)
4432 assert_rest(self, c)
4433
4434 c = IEEEContext(64)
4435 self.assertEqual(c.prec, 16)
4436 self.assertEqual(c.Emax, 384)
4437 self.assertEqual(c.Emin, -383)
4438 assert_rest(self, c)
4439
4440 c = IEEEContext(128)
4441 self.assertEqual(c.prec, 34)
4442 self.assertEqual(c.Emax, 6144)
4443 self.assertEqual(c.Emin, -6143)
4444 assert_rest(self, c)
4445
4446 # Invalid values
4447 self.assertRaises(ValueError, IEEEContext, -1)
4448 self.assertRaises(ValueError, IEEEContext, 123)
4449 self.assertRaises(ValueError, IEEEContext, 1024)
4450
4451 def test_constants(self):
4452 # IEEEContext
4453 IEEE_CONTEXT_MAX_BITS = self.decimal.IEEE_CONTEXT_MAX_BITS
4454 self.assertIn(IEEE_CONTEXT_MAX_BITS, {256, 512})
4455
4456 @requires_cdecimal
4457 class CIEEEContexts(IEEEContexts, unittest.TestCase):
4458 decimal = C
4459 class PyIEEEContexts(IEEEContexts, unittest.TestCase):
4460 decimal = P
4461
4462 @skip_if_extra_functionality
4463 @requires_cdecimal
4464 class CheckAttributes(unittest.TestCase):
4465
4466 def test_module_attributes(self):
4467
4468 # Architecture dependent context limits
4469 self.assertEqual(C.MAX_PREC, P.MAX_PREC)
4470 self.assertEqual(C.MAX_EMAX, P.MAX_EMAX)
4471 self.assertEqual(C.MIN_EMIN, P.MIN_EMIN)
4472 self.assertEqual(C.MIN_ETINY, P.MIN_ETINY)
4473 self.assertEqual(C.IEEE_CONTEXT_MAX_BITS, P.IEEE_CONTEXT_MAX_BITS)
4474
4475 self.assertTrue(C.HAVE_THREADS is True or C.HAVE_THREADS is False)
4476 self.assertTrue(P.HAVE_THREADS is True or P.HAVE_THREADS is False)
4477
4478 self.assertEqual(C.__version__, P.__version__)
4479
4480 self.assertLessEqual(set(dir(C)), set(dir(P)))
4481 self.assertEqual([n for n in dir(C) if n[:2] != '__'], sorted(P.__all__))
4482
4483 def test_context_attributes(self):
4484
4485 x = [s for s in dir(C.Context()) if '__' in s or not s.startswith('_')]
4486 y = [s for s in dir(P.Context()) if '__' in s or not s.startswith('_')]
4487 self.assertEqual(set(x) - set(y), set())
4488
4489 def test_decimal_attributes(self):
4490
4491 x = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4492 y = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4493 self.assertEqual(set(x) - set(y), set())
4494
4495 class Coverage:
4496
4497 def test_adjusted(self):
4498 Decimal = self.decimal.Decimal
4499
4500 self.assertEqual(Decimal('1234e9999').adjusted(), 10002)
4501 # XXX raise?
4502 self.assertEqual(Decimal('nan').adjusted(), 0)
4503 self.assertEqual(Decimal('inf').adjusted(), 0)
4504
4505 def test_canonical(self):
4506 Decimal = self.decimal.Decimal
4507 getcontext = self.decimal.getcontext
4508
4509 x = Decimal(9).canonical()
4510 self.assertEqual(x, 9)
4511
4512 c = getcontext()
4513 x = c.canonical(Decimal(9))
4514 self.assertEqual(x, 9)
4515
4516 def test_context_repr(self):
4517 c = self.decimal.DefaultContext.copy()
4518
4519 c.prec = 425000000
4520 c.Emax = 425000000
4521 c.Emin = -425000000
4522 c.rounding = ROUND_HALF_DOWN
4523 c.capitals = 0
4524 c.clamp = 1
4525 for sig in OrderedSignals[self.decimal]:
4526 c.flags[sig] = False
4527 c.traps[sig] = False
4528
4529 s = c.__repr__()
4530 t = "Context(prec=425000000, rounding=ROUND_HALF_DOWN, " \
4531 "Emin=-425000000, Emax=425000000, capitals=0, clamp=1, " \
4532 "flags=[], traps=[])"
4533 self.assertEqual(s, t)
4534
4535 def test_implicit_context(self):
4536 Decimal = self.decimal.Decimal
4537 localcontext = self.decimal.localcontext
4538
4539 with localcontext() as c:
4540 c.prec = 1
4541 c.Emax = 1
4542 c.Emin = -1
4543
4544 # abs
4545 self.assertEqual(abs(Decimal("-10")), 10)
4546 # add
4547 self.assertEqual(Decimal("7") + 1, 8)
4548 # divide
4549 self.assertEqual(Decimal("10") / 5, 2)
4550 # divide_int
4551 self.assertEqual(Decimal("10") // 7, 1)
4552 # fma
4553 self.assertEqual(Decimal("1.2").fma(Decimal("0.01"), 1), 1)
4554 self.assertIs(Decimal("NaN").fma(7, 1).is_nan(), True)
4555 # three arg power
4556 self.assertEqual(pow(Decimal(10), 2, 7), 2)
4557 self.assertEqual(pow(10, Decimal(2), 7), 2)
4558 if self.decimal == C:
4559 self.assertEqual(pow(10, 2, Decimal(7)), 2)
4560 else:
4561 # XXX: There is no special method to dispatch on the
4562 # third arg of three-arg power.
4563 self.assertRaises(TypeError, pow, 10, 2, Decimal(7))
4564 # exp
4565 self.assertEqual(Decimal("1.01").exp(), 3)
4566 # is_normal
4567 self.assertIs(Decimal("0.01").is_normal(), False)
4568 # is_subnormal
4569 self.assertIs(Decimal("0.01").is_subnormal(), True)
4570 # ln
4571 self.assertEqual(Decimal("20").ln(), 3)
4572 # log10
4573 self.assertEqual(Decimal("20").log10(), 1)
4574 # logb
4575 self.assertEqual(Decimal("580").logb(), 2)
4576 # logical_invert
4577 self.assertEqual(Decimal("10").logical_invert(), 1)
4578 # minus
4579 self.assertEqual(-Decimal("-10"), 10)
4580 # multiply
4581 self.assertEqual(Decimal("2") * 4, 8)
4582 # next_minus
4583 self.assertEqual(Decimal("10").next_minus(), 9)
4584 # next_plus
4585 self.assertEqual(Decimal("10").next_plus(), Decimal('2E+1'))
4586 # normalize
4587 self.assertEqual(Decimal("-10").normalize(), Decimal('-1E+1'))
4588 # number_class
4589 self.assertEqual(Decimal("10").number_class(), '+Normal')
4590 # plus
4591 self.assertEqual(+Decimal("-1"), -1)
4592 # remainder
4593 self.assertEqual(Decimal("10") % 7, 3)
4594 # subtract
4595 self.assertEqual(Decimal("10") - 7, 3)
4596 # to_integral_exact
4597 self.assertEqual(Decimal("1.12345").to_integral_exact(), 1)
4598
4599 # Boolean functions
4600 self.assertTrue(Decimal("1").is_canonical())
4601 self.assertTrue(Decimal("1").is_finite())
4602 self.assertTrue(Decimal("1").is_finite())
4603 self.assertTrue(Decimal("snan").is_snan())
4604 self.assertTrue(Decimal("-1").is_signed())
4605 self.assertTrue(Decimal("0").is_zero())
4606 self.assertTrue(Decimal("0").is_zero())
4607
4608 # Copy
4609 with localcontext() as c:
4610 c.prec = 10000
4611 x = 1228 ** 1523
4612 y = -Decimal(x)
4613
4614 z = y.copy_abs()
4615 self.assertEqual(z, x)
4616
4617 z = y.copy_negate()
4618 self.assertEqual(z, x)
4619
4620 z = y.copy_sign(Decimal(1))
4621 self.assertEqual(z, x)
4622
4623 def test_divmod(self):
4624 Decimal = self.decimal.Decimal
4625 localcontext = self.decimal.localcontext
4626 InvalidOperation = self.decimal.InvalidOperation
4627 DivisionByZero = self.decimal.DivisionByZero
4628
4629 with localcontext() as c:
4630 q, r = divmod(Decimal("10912837129"), 1001)
4631 self.assertEqual(q, Decimal('10901935'))
4632 self.assertEqual(r, Decimal('194'))
4633
4634 q, r = divmod(Decimal("NaN"), 7)
4635 self.assertTrue(q.is_nan() and r.is_nan())
4636
4637 c.traps[InvalidOperation] = False
4638 q, r = divmod(Decimal("NaN"), 7)
4639 self.assertTrue(q.is_nan() and r.is_nan())
4640
4641 c.traps[InvalidOperation] = False
4642 c.clear_flags()
4643 q, r = divmod(Decimal("inf"), Decimal("inf"))
4644 self.assertTrue(q.is_nan() and r.is_nan())
4645 self.assertTrue(c.flags[InvalidOperation])
4646
4647 c.clear_flags()
4648 q, r = divmod(Decimal("inf"), 101)
4649 self.assertTrue(q.is_infinite() and r.is_nan())
4650 self.assertTrue(c.flags[InvalidOperation])
4651
4652 c.clear_flags()
4653 q, r = divmod(Decimal(0), 0)
4654 self.assertTrue(q.is_nan() and r.is_nan())
4655 self.assertTrue(c.flags[InvalidOperation])
4656
4657 c.traps[DivisionByZero] = False
4658 c.clear_flags()
4659 q, r = divmod(Decimal(11), 0)
4660 self.assertTrue(q.is_infinite() and r.is_nan())
4661 self.assertTrue(c.flags[InvalidOperation] and
4662 c.flags[DivisionByZero])
4663
4664 def test_power(self):
4665 Decimal = self.decimal.Decimal
4666 localcontext = self.decimal.localcontext
4667 Overflow = self.decimal.Overflow
4668 Rounded = self.decimal.Rounded
4669
4670 with localcontext() as c:
4671 c.prec = 3
4672 c.clear_flags()
4673 self.assertEqual(Decimal("1.0") ** 100, Decimal('1.00'))
4674 self.assertTrue(c.flags[Rounded])
4675
4676 c.prec = 1
4677 c.Emax = 1
4678 c.Emin = -1
4679 c.clear_flags()
4680 c.traps[Overflow] = False
4681 self.assertEqual(Decimal(10000) ** Decimal("0.5"), Decimal('inf'))
4682 self.assertTrue(c.flags[Overflow])
4683
4684 def test_quantize(self):
4685 Decimal = self.decimal.Decimal
4686 localcontext = self.decimal.localcontext
4687 InvalidOperation = self.decimal.InvalidOperation
4688
4689 with localcontext() as c:
4690 c.prec = 1
4691 c.Emax = 1
4692 c.Emin = -1
4693 c.traps[InvalidOperation] = False
4694 x = Decimal(99).quantize(Decimal("1e1"))
4695 self.assertTrue(x.is_nan())
4696
4697 def test_radix(self):
4698 Decimal = self.decimal.Decimal
4699 getcontext = self.decimal.getcontext
4700
4701 c = getcontext()
4702 self.assertEqual(Decimal("1").radix(), 10)
4703 self.assertEqual(c.radix(), 10)
4704
4705 def test_rop(self):
4706 Decimal = self.decimal.Decimal
4707
4708 for attr in ('__radd__', '__rsub__', '__rmul__', '__rtruediv__',
4709 '__rdivmod__', '__rmod__', '__rfloordiv__', '__rpow__'):
4710 self.assertIs(getattr(Decimal("1"), attr)("xyz"), NotImplemented)
4711
4712 def test_round(self):
4713 # Python3 behavior: round() returns Decimal
4714 Decimal = self.decimal.Decimal
4715 localcontext = self.decimal.localcontext
4716
4717 with localcontext() as c:
4718 c.prec = 28
4719
4720 self.assertEqual(str(Decimal("9.99").__round__()), "10")
4721 self.assertEqual(str(Decimal("9.99e-5").__round__()), "0")
4722 self.assertEqual(str(Decimal("1.23456789").__round__(5)), "1.23457")
4723 self.assertEqual(str(Decimal("1.2345").__round__(10)), "1.2345000000")
4724 self.assertEqual(str(Decimal("1.2345").__round__(-10)), "0E+10")
4725
4726 self.assertRaises(TypeError, Decimal("1.23").__round__, "5")
4727 self.assertRaises(TypeError, Decimal("1.23").__round__, 5, 8)
4728
4729 def test_create_decimal(self):
4730 c = self.decimal.Context()
4731 self.assertRaises(ValueError, c.create_decimal, ["%"])
4732
4733 def test_int(self):
4734 Decimal = self.decimal.Decimal
4735 localcontext = self.decimal.localcontext
4736
4737 with localcontext() as c:
4738 c.prec = 9999
4739 x = Decimal(1221**1271) / 10**3923
4740 self.assertEqual(int(x), 1)
4741 self.assertEqual(x.to_integral(), 2)
4742
4743 def test_copy(self):
4744 Context = self.decimal.Context
4745
4746 c = Context()
4747 c.prec = 10000
4748 x = -(1172 ** 1712)
4749
4750 y = c.copy_abs(x)
4751 self.assertEqual(y, -x)
4752
4753 y = c.copy_negate(x)
4754 self.assertEqual(y, -x)
4755
4756 y = c.copy_sign(x, 1)
4757 self.assertEqual(y, -x)
4758
4759 @requires_cdecimal
4760 class CCoverage(Coverage, unittest.TestCase):
4761 decimal = C
4762 class PyCoverage(Coverage, unittest.TestCase):
4763 decimal = P
4764
4765 def setUp(self):
4766 super().setUp()
4767 self._previous_int_limit = sys.get_int_max_str_digits()
4768 sys.set_int_max_str_digits(7000)
4769
4770 def tearDown(self):
4771 sys.set_int_max_str_digits(self._previous_int_limit)
4772 super().tearDown()
4773
4774 class PyFunctionality(unittest.TestCase):
4775 """Extra functionality in decimal.py"""
4776
4777 def test_py_alternate_formatting(self):
4778 # triples giving a format, a Decimal, and the expected result
4779 Decimal = P.Decimal
4780 localcontext = P.localcontext
4781
4782 test_values = [
4783 # Issue 7094: Alternate formatting (specified by #)
4784 ('.0e', '1.0', '1e+0'),
4785 ('#.0e', '1.0', '1.e+0'),
4786 ('.0f', '1.0', '1'),
4787 ('#.0f', '1.0', '1.'),
4788 ('g', '1.1', '1.1'),
4789 ('#g', '1.1', '1.1'),
4790 ('.0g', '1', '1'),
4791 ('#.0g', '1', '1.'),
4792 ('.0%', '1.0', '100%'),
4793 ('#.0%', '1.0', '100.%'),
4794 ]
4795 for fmt, d, result in test_values:
4796 self.assertEqual(format(Decimal(d), fmt), result)
4797
4798 class PyWhitebox(unittest.TestCase):
4799 """White box testing for decimal.py"""
4800
4801 def test_py_exact_power(self):
4802 # Rarely exercised lines in _power_exact.
4803 Decimal = P.Decimal
4804 localcontext = P.localcontext
4805
4806 with localcontext() as c:
4807 c.prec = 8
4808 x = Decimal(2**16) ** Decimal("-0.5")
4809 self.assertEqual(x, Decimal('0.00390625'))
4810
4811 x = Decimal(2**16) ** Decimal("-0.6")
4812 self.assertEqual(x, Decimal('0.0012885819'))
4813
4814 x = Decimal("256e7") ** Decimal("-0.5")
4815
4816 x = Decimal(152587890625) ** Decimal('-0.0625')
4817 self.assertEqual(x, Decimal("0.2"))
4818
4819 x = Decimal("152587890625e7") ** Decimal('-0.0625')
4820
4821 x = Decimal(5**2659) ** Decimal('-0.0625')
4822
4823 c.prec = 1
4824 x = Decimal("152587890625") ** Decimal('-0.5')
4825 self.assertEqual(x, Decimal('3e-6'))
4826 c.prec = 2
4827 x = Decimal("152587890625") ** Decimal('-0.5')
4828 self.assertEqual(x, Decimal('2.6e-6'))
4829 c.prec = 3
4830 x = Decimal("152587890625") ** Decimal('-0.5')
4831 self.assertEqual(x, Decimal('2.56e-6'))
4832 c.prec = 28
4833 x = Decimal("152587890625") ** Decimal('-0.5')
4834 self.assertEqual(x, Decimal('2.56e-6'))
4835
4836 c.prec = 201
4837 x = Decimal(2**578) ** Decimal("-0.5")
4838
4839 # See https://github.com/python/cpython/issues/118027
4840 # Testing for an exact power could appear to hang, in the Python
4841 # version, as it attempted to compute 10**(MAX_EMAX + 1).
4842 # Fixed via https://github.com/python/cpython/pull/118503.
4843 c.prec = P.MAX_PREC
4844 c.Emax = P.MAX_EMAX
4845 c.Emin = P.MIN_EMIN
4846 c.traps[P.Inexact] = 1
4847 D2 = Decimal(2)
4848 # If the bug is still present, the next statement won't complete.
4849 res = D2 ** 117
4850 self.assertEqual(res, 1 << 117)
4851
4852 def test_py_immutability_operations(self):
4853 # Do operations and check that it didn't change internal objects.
4854 Decimal = P.Decimal
4855 DefaultContext = P.DefaultContext
4856 setcontext = P.setcontext
4857
4858 c = DefaultContext.copy()
4859 c.traps = dict((s, 0) for s in OrderedSignals[P])
4860 setcontext(c)
4861
4862 d1 = Decimal('-25e55')
4863 b1 = Decimal('-25e55')
4864 d2 = Decimal('33e+33')
4865 b2 = Decimal('33e+33')
4866
4867 def checkSameDec(operation, useOther=False):
4868 if useOther:
4869 eval("d1." + operation + "(d2)")
4870 self.assertEqual(d1._sign, b1._sign)
4871 self.assertEqual(d1._int, b1._int)
4872 self.assertEqual(d1._exp, b1._exp)
4873 self.assertEqual(d2._sign, b2._sign)
4874 self.assertEqual(d2._int, b2._int)
4875 self.assertEqual(d2._exp, b2._exp)
4876 else:
4877 eval("d1." + operation + "()")
4878 self.assertEqual(d1._sign, b1._sign)
4879 self.assertEqual(d1._int, b1._int)
4880 self.assertEqual(d1._exp, b1._exp)
4881
4882 Decimal(d1)
4883 self.assertEqual(d1._sign, b1._sign)
4884 self.assertEqual(d1._int, b1._int)
4885 self.assertEqual(d1._exp, b1._exp)
4886
4887 checkSameDec("__abs__")
4888 checkSameDec("__add__", True)
4889 checkSameDec("__divmod__", True)
4890 checkSameDec("__eq__", True)
4891 checkSameDec("__ne__", True)
4892 checkSameDec("__le__", True)
4893 checkSameDec("__lt__", True)
4894 checkSameDec("__ge__", True)
4895 checkSameDec("__gt__", True)
4896 checkSameDec("__float__")
4897 checkSameDec("__floordiv__", True)
4898 checkSameDec("__hash__")
4899 checkSameDec("__int__")
4900 checkSameDec("__trunc__")
4901 checkSameDec("__mod__", True)
4902 checkSameDec("__mul__", True)
4903 checkSameDec("__neg__")
4904 checkSameDec("__bool__")
4905 checkSameDec("__pos__")
4906 checkSameDec("__pow__", True)
4907 checkSameDec("__radd__", True)
4908 checkSameDec("__rdivmod__", True)
4909 checkSameDec("__repr__")
4910 checkSameDec("__rfloordiv__", True)
4911 checkSameDec("__rmod__", True)
4912 checkSameDec("__rmul__", True)
4913 checkSameDec("__rpow__", True)
4914 checkSameDec("__rsub__", True)
4915 checkSameDec("__str__")
4916 checkSameDec("__sub__", True)
4917 checkSameDec("__truediv__", True)
4918 checkSameDec("adjusted")
4919 checkSameDec("as_tuple")
4920 checkSameDec("compare", True)
4921 checkSameDec("max", True)
4922 checkSameDec("min", True)
4923 checkSameDec("normalize")
4924 checkSameDec("quantize", True)
4925 checkSameDec("remainder_near", True)
4926 checkSameDec("same_quantum", True)
4927 checkSameDec("sqrt")
4928 checkSameDec("to_eng_string")
4929 checkSameDec("to_integral")
4930
4931 def test_py_decimal_id(self):
4932 Decimal = P.Decimal
4933
4934 d = Decimal(45)
4935 e = Decimal(d)
4936 self.assertEqual(str(e), '45')
4937 self.assertNotEqual(id(d), id(e))
4938
4939 def test_py_rescale(self):
4940 # Coverage
4941 Decimal = P.Decimal
4942 localcontext = P.localcontext
4943
4944 with localcontext() as c:
4945 x = Decimal("NaN")._rescale(3, ROUND_UP)
4946 self.assertTrue(x.is_nan())
4947
4948 def test_py__round(self):
4949 # Coverage
4950 Decimal = P.Decimal
4951
4952 self.assertRaises(ValueError, Decimal("3.1234")._round, 0, ROUND_UP)
4953
4954 class CFunctionality(unittest.TestCase):
4955 """Extra functionality in _decimal"""
4956
4957 @requires_extra_functionality
4958 def test_c_context(self):
4959 Context = C.Context
4960
4961 c = Context(flags=C.DecClamped, traps=C.DecRounded)
4962 self.assertEqual(c._flags, C.DecClamped)
4963 self.assertEqual(c._traps, C.DecRounded)
4964
4965 @requires_extra_functionality
4966 def test_constants(self):
4967 # Condition flags
4968 cond = (
4969 C.DecClamped, C.DecConversionSyntax, C.DecDivisionByZero,
4970 C.DecDivisionImpossible, C.DecDivisionUndefined,
4971 C.DecFpuError, C.DecInexact, C.DecInvalidContext,
4972 C.DecInvalidOperation, C.DecMallocError,
4973 C.DecFloatOperation, C.DecOverflow, C.DecRounded,
4974 C.DecSubnormal, C.DecUnderflow
4975 )
4976
4977 # Conditions
4978 for i, v in enumerate(cond):
4979 self.assertEqual(v, 1<<i)
4980
4981 self.assertEqual(C.DecIEEEInvalidOperation,
4982 C.DecConversionSyntax|
4983 C.DecDivisionImpossible|
4984 C.DecDivisionUndefined|
4985 C.DecFpuError|
4986 C.DecInvalidContext|
4987 C.DecInvalidOperation|
4988 C.DecMallocError)
4989
4990 self.assertEqual(C.DecErrors,
4991 C.DecIEEEInvalidOperation|
4992 C.DecDivisionByZero)
4993
4994 self.assertEqual(C.DecTraps,
4995 C.DecErrors|C.DecOverflow|C.DecUnderflow)
4996
4997 @requires_cdecimal
4998 class CWhitebox(unittest.TestCase):
4999 """Whitebox testing for _decimal"""
5000
5001 def test_bignum(self):
5002 # Not exactly whitebox, but too slow with pydecimal.
5003
5004 Decimal = C.Decimal
5005 localcontext = C.localcontext
5006
5007 b1 = 10**35
5008 b2 = 10**36
5009 with localcontext() as c:
5010 c.prec = 1000000
5011 for i in range(5):
5012 a = random.randrange(b1, b2)
5013 b = random.randrange(1000, 1200)
5014 x = a ** b
5015 y = Decimal(a) ** Decimal(b)
5016 self.assertEqual(x, y)
5017
5018 def test_invalid_construction(self):
5019 self.assertRaises(TypeError, C.Decimal, 9, "xyz")
5020
5021 def test_c_input_restriction(self):
5022 # Too large for _decimal to be converted exactly
5023 Decimal = C.Decimal
5024 InvalidOperation = C.InvalidOperation
5025 Context = C.Context
5026 localcontext = C.localcontext
5027
5028 with localcontext(Context()):
5029 self.assertRaises(InvalidOperation, Decimal,
5030 "1e9999999999999999999")
5031
5032 def test_c_context_repr(self):
5033 # This test is _decimal-only because flags are not printed
5034 # in the same order.
5035 DefaultContext = C.DefaultContext
5036 FloatOperation = C.FloatOperation
5037
5038 c = DefaultContext.copy()
5039
5040 c.prec = 425000000
5041 c.Emax = 425000000
5042 c.Emin = -425000000
5043 c.rounding = ROUND_HALF_DOWN
5044 c.capitals = 0
5045 c.clamp = 1
5046 for sig in OrderedSignals[C]:
5047 c.flags[sig] = True
5048 c.traps[sig] = True
5049 c.flags[FloatOperation] = True
5050 c.traps[FloatOperation] = True
5051
5052 s = c.__repr__()
5053 t = "Context(prec=425000000, rounding=ROUND_HALF_DOWN, " \
5054 "Emin=-425000000, Emax=425000000, capitals=0, clamp=1, " \
5055 "flags=[Clamped, InvalidOperation, DivisionByZero, Inexact, " \
5056 "FloatOperation, Overflow, Rounded, Subnormal, Underflow], " \
5057 "traps=[Clamped, InvalidOperation, DivisionByZero, Inexact, " \
5058 "FloatOperation, Overflow, Rounded, Subnormal, Underflow])"
5059 self.assertEqual(s, t)
5060
5061 def test_c_context_errors(self):
5062 Context = C.Context
5063 InvalidOperation = C.InvalidOperation
5064 Overflow = C.Overflow
5065 FloatOperation = C.FloatOperation
5066 localcontext = C.localcontext
5067 getcontext = C.getcontext
5068 setcontext = C.setcontext
5069 HAVE_CONFIG_64 = (C.MAX_PREC > 425000000)
5070
5071 c = Context()
5072
5073 # SignalDict: input validation
5074 self.assertRaises(KeyError, c.flags.__setitem__, 801, 0)
5075 self.assertRaises(KeyError, c.traps.__setitem__, 801, 0)
5076 self.assertRaises(ValueError, c.flags.__delitem__, Overflow)
5077 self.assertRaises(ValueError, c.traps.__delitem__, InvalidOperation)
5078 self.assertRaises(TypeError, setattr, c, 'flags', ['x'])
5079 self.assertRaises(TypeError, setattr, c,'traps', ['y'])
5080 self.assertRaises(KeyError, setattr, c, 'flags', {0:1})
5081 self.assertRaises(KeyError, setattr, c, 'traps', {0:1})
5082
5083 # Test assignment from a signal dict with the correct length but
5084 # one invalid key.
5085 d = c.flags.copy()
5086 del d[FloatOperation]
5087 d["XYZ"] = 91283719
5088 self.assertRaises(KeyError, setattr, c, 'flags', d)
5089 self.assertRaises(KeyError, setattr, c, 'traps', d)
5090
5091 # Input corner cases
5092 int_max = 2**63-1 if HAVE_CONFIG_64 else 2**31-1
5093 gt_max_emax = 10**18 if HAVE_CONFIG_64 else 10**9
5094
5095 # prec, Emax, Emin
5096 for attr in ['prec', 'Emax']:
5097 self.assertRaises(ValueError, setattr, c, attr, gt_max_emax)
5098 self.assertRaises(ValueError, setattr, c, 'Emin', -gt_max_emax)
5099
5100 # prec, Emax, Emin in context constructor
5101 self.assertRaises(ValueError, Context, prec=gt_max_emax)
5102 self.assertRaises(ValueError, Context, Emax=gt_max_emax)
5103 self.assertRaises(ValueError, Context, Emin=-gt_max_emax)
5104
5105 # Overflow in conversion
5106 self.assertRaises(OverflowError, Context, prec=int_max+1)
5107 self.assertRaises(OverflowError, Context, Emax=int_max+1)
5108 self.assertRaises(OverflowError, Context, Emin=-int_max-2)
5109 self.assertRaises(OverflowError, Context, clamp=int_max+1)
5110 self.assertRaises(OverflowError, Context, capitals=int_max+1)
5111
5112 # OverflowError, general ValueError
5113 for attr in ('prec', 'Emin', 'Emax', 'capitals', 'clamp'):
5114 self.assertRaises(OverflowError, setattr, c, attr, int_max+1)
5115 self.assertRaises(OverflowError, setattr, c, attr, -int_max-2)
5116 if sys.platform != 'win32':
5117 self.assertRaises(ValueError, setattr, c, attr, int_max)
5118 self.assertRaises(ValueError, setattr, c, attr, -int_max-1)
5119
5120 # OverflowError: _unsafe_setprec, _unsafe_setemin, _unsafe_setemax
5121 if C.MAX_PREC == 425000000:
5122 self.assertRaises(OverflowError, getattr(c, '_unsafe_setprec'),
5123 int_max+1)
5124 self.assertRaises(OverflowError, getattr(c, '_unsafe_setemax'),
5125 int_max+1)
5126 self.assertRaises(OverflowError, getattr(c, '_unsafe_setemin'),
5127 -int_max-2)
5128
5129 # ValueError: _unsafe_setprec, _unsafe_setemin, _unsafe_setemax
5130 if C.MAX_PREC == 425000000:
5131 self.assertRaises(ValueError, getattr(c, '_unsafe_setprec'), 0)
5132 self.assertRaises(ValueError, getattr(c, '_unsafe_setprec'),
5133 1070000001)
5134 self.assertRaises(ValueError, getattr(c, '_unsafe_setemax'), -1)
5135 self.assertRaises(ValueError, getattr(c, '_unsafe_setemax'),
5136 1070000001)
5137 self.assertRaises(ValueError, getattr(c, '_unsafe_setemin'),
5138 -1070000001)
5139 self.assertRaises(ValueError, getattr(c, '_unsafe_setemin'), 1)
5140
5141 # capitals, clamp
5142 for attr in ['capitals', 'clamp']:
5143 self.assertRaises(ValueError, setattr, c, attr, -1)
5144 self.assertRaises(ValueError, setattr, c, attr, 2)
5145 self.assertRaises(TypeError, setattr, c, attr, [1,2,3])
5146 if HAVE_CONFIG_64:
5147 self.assertRaises(ValueError, setattr, c, attr, 2**32)
5148 self.assertRaises(ValueError, setattr, c, attr, 2**32+1)
5149
5150 # Invalid local context
5151 self.assertRaises(TypeError, exec, 'with localcontext("xyz"): pass',
5152 locals())
5153 self.assertRaises(TypeError, exec,
5154 'with localcontext(context=getcontext()): pass',
5155 locals())
5156
5157 # setcontext
5158 saved_context = getcontext()
5159 self.assertRaises(TypeError, setcontext, "xyz")
5160 setcontext(saved_context)
5161
5162 def test_rounding_strings_interned(self):
5163
5164 self.assertIs(C.ROUND_UP, P.ROUND_UP)
5165 self.assertIs(C.ROUND_DOWN, P.ROUND_DOWN)
5166 self.assertIs(C.ROUND_CEILING, P.ROUND_CEILING)
5167 self.assertIs(C.ROUND_FLOOR, P.ROUND_FLOOR)
5168 self.assertIs(C.ROUND_HALF_UP, P.ROUND_HALF_UP)
5169 self.assertIs(C.ROUND_HALF_DOWN, P.ROUND_HALF_DOWN)
5170 self.assertIs(C.ROUND_HALF_EVEN, P.ROUND_HALF_EVEN)
5171 self.assertIs(C.ROUND_05UP, P.ROUND_05UP)
5172
5173 @requires_extra_functionality
5174 def test_c_context_errors_extra(self):
5175 Context = C.Context
5176 InvalidOperation = C.InvalidOperation
5177 Overflow = C.Overflow
5178 localcontext = C.localcontext
5179 getcontext = C.getcontext
5180 setcontext = C.setcontext
5181 HAVE_CONFIG_64 = (C.MAX_PREC > 425000000)
5182
5183 c = Context()
5184
5185 # Input corner cases
5186 int_max = 2**63-1 if HAVE_CONFIG_64 else 2**31-1
5187
5188 # OverflowError, general ValueError
5189 self.assertRaises(OverflowError, setattr, c, '_allcr', int_max+1)
5190 self.assertRaises(OverflowError, setattr, c, '_allcr', -int_max-2)
5191 if sys.platform != 'win32':
5192 self.assertRaises(ValueError, setattr, c, '_allcr', int_max)
5193 self.assertRaises(ValueError, setattr, c, '_allcr', -int_max-1)
5194
5195 # OverflowError, general TypeError
5196 for attr in ('_flags', '_traps'):
5197 self.assertRaises(OverflowError, setattr, c, attr, int_max+1)
5198 self.assertRaises(OverflowError, setattr, c, attr, -int_max-2)
5199 if sys.platform != 'win32':
5200 self.assertRaises(TypeError, setattr, c, attr, int_max)
5201 self.assertRaises(TypeError, setattr, c, attr, -int_max-1)
5202
5203 # _allcr
5204 self.assertRaises(ValueError, setattr, c, '_allcr', -1)
5205 self.assertRaises(ValueError, setattr, c, '_allcr', 2)
5206 self.assertRaises(TypeError, setattr, c, '_allcr', [1,2,3])
5207 if HAVE_CONFIG_64:
5208 self.assertRaises(ValueError, setattr, c, '_allcr', 2**32)
5209 self.assertRaises(ValueError, setattr, c, '_allcr', 2**32+1)
5210
5211 # _flags, _traps
5212 for attr in ['_flags', '_traps']:
5213 self.assertRaises(TypeError, setattr, c, attr, 999999)
5214 self.assertRaises(TypeError, setattr, c, attr, 'x')
5215
5216 def test_c_valid_context(self):
5217 # These tests are for code coverage in _decimal.
5218 DefaultContext = C.DefaultContext
5219 Clamped = C.Clamped
5220 Underflow = C.Underflow
5221 Inexact = C.Inexact
5222 Rounded = C.Rounded
5223 Subnormal = C.Subnormal
5224
5225 c = DefaultContext.copy()
5226
5227 # Exercise all getters and setters
5228 c.prec = 34
5229 c.rounding = ROUND_HALF_UP
5230 c.Emax = 3000
5231 c.Emin = -3000
5232 c.capitals = 1
5233 c.clamp = 0
5234
5235 self.assertEqual(c.prec, 34)
5236 self.assertEqual(c.rounding, ROUND_HALF_UP)
5237 self.assertEqual(c.Emin, -3000)
5238 self.assertEqual(c.Emax, 3000)
5239 self.assertEqual(c.capitals, 1)
5240 self.assertEqual(c.clamp, 0)
5241
5242 self.assertEqual(c.Etiny(), -3033)
5243 self.assertEqual(c.Etop(), 2967)
5244
5245 # Exercise all unsafe setters
5246 if C.MAX_PREC == 425000000:
5247 c._unsafe_setprec(999999999)
5248 c._unsafe_setemax(999999999)
5249 c._unsafe_setemin(-999999999)
5250 self.assertEqual(c.prec, 999999999)
5251 self.assertEqual(c.Emax, 999999999)
5252 self.assertEqual(c.Emin, -999999999)
5253
5254 @requires_extra_functionality
5255 def test_c_valid_context_extra(self):
5256 DefaultContext = C.DefaultContext
5257
5258 c = DefaultContext.copy()
5259 self.assertEqual(c._allcr, 1)
5260 c._allcr = 0
5261 self.assertEqual(c._allcr, 0)
5262
5263 def test_c_round(self):
5264 # Restricted input.
5265 Decimal = C.Decimal
5266 InvalidOperation = C.InvalidOperation
5267 localcontext = C.localcontext
5268 MAX_EMAX = C.MAX_EMAX
5269 MIN_ETINY = C.MIN_ETINY
5270 int_max = 2**63-1 if C.MAX_PREC > 425000000 else 2**31-1
5271
5272 with localcontext() as c:
5273 c.traps[InvalidOperation] = True
5274 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5275 -int_max-1)
5276 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5277 int_max)
5278 self.assertRaises(InvalidOperation, Decimal("1").__round__,
5279 int(MAX_EMAX+1))
5280 self.assertRaises(C.InvalidOperation, Decimal("1").__round__,
5281 -int(MIN_ETINY-1))
5282 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5283 -int_max-2)
5284 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5285 int_max+1)
5286
5287 def test_c_format(self):
5288 # Restricted input
5289 Decimal = C.Decimal
5290 HAVE_CONFIG_64 = (C.MAX_PREC > 425000000)
5291
5292 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", [], 9)
5293 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", 9)
5294 self.assertRaises(TypeError, Decimal(1).__format__, [])
5295
5296 self.assertRaises(ValueError, Decimal(1).__format__, "<>=10.10")
5297 maxsize = 2**63-1 if HAVE_CONFIG_64 else 2**31-1
5298 self.assertRaises(ValueError, Decimal("1.23456789").__format__,
5299 "=%d.1" % maxsize)
5300
5301 def test_c_integral(self):
5302 Decimal = C.Decimal
5303 Inexact = C.Inexact
5304 localcontext = C.localcontext
5305
5306 x = Decimal(10)
5307 self.assertEqual(x.to_integral(), 10)
5308 self.assertRaises(TypeError, x.to_integral, '10')
5309 self.assertRaises(TypeError, x.to_integral, 10, 'x')
5310 self.assertRaises(TypeError, x.to_integral, 10)
5311
5312 self.assertEqual(x.to_integral_value(), 10)
5313 self.assertRaises(TypeError, x.to_integral_value, '10')
5314 self.assertRaises(TypeError, x.to_integral_value, 10, 'x')
5315 self.assertRaises(TypeError, x.to_integral_value, 10)
5316
5317 self.assertEqual(x.to_integral_exact(), 10)
5318 self.assertRaises(TypeError, x.to_integral_exact, '10')
5319 self.assertRaises(TypeError, x.to_integral_exact, 10, 'x')
5320 self.assertRaises(TypeError, x.to_integral_exact, 10)
5321
5322 with localcontext() as c:
5323 x = Decimal("99999999999999999999999999.9").to_integral_value(ROUND_UP)
5324 self.assertEqual(x, Decimal('100000000000000000000000000'))
5325
5326 x = Decimal("99999999999999999999999999.9").to_integral_exact(ROUND_UP)
5327 self.assertEqual(x, Decimal('100000000000000000000000000'))
5328
5329 c.traps[Inexact] = True
5330 self.assertRaises(Inexact, Decimal("999.9").to_integral_exact, ROUND_UP)
5331
5332 def test_c_funcs(self):
5333 # Invalid arguments
5334 Decimal = C.Decimal
5335 InvalidOperation = C.InvalidOperation
5336 DivisionByZero = C.DivisionByZero
5337 getcontext = C.getcontext
5338 localcontext = C.localcontext
5339
5340 self.assertEqual(Decimal('9.99e10').to_eng_string(), '99.9E+9')
5341
5342 self.assertRaises(TypeError, pow, Decimal(1), 2, "3")
5343 self.assertRaises(TypeError, Decimal(9).number_class, "x", "y")
5344 self.assertRaises(TypeError, Decimal(9).same_quantum, 3, "x", "y")
5345
5346 self.assertRaises(
5347 TypeError,
5348 Decimal("1.23456789").quantize, Decimal('1e-100000'), []
5349 )
5350 self.assertRaises(
5351 TypeError,
5352 Decimal("1.23456789").quantize, Decimal('1e-100000'), getcontext()
5353 )
5354 self.assertRaises(
5355 TypeError,
5356 Decimal("1.23456789").quantize, Decimal('1e-100000'), 10
5357 )
5358 self.assertRaises(
5359 TypeError,
5360 Decimal("1.23456789").quantize, Decimal('1e-100000'), ROUND_UP, 1000
5361 )
5362
5363 with localcontext() as c:
5364 c.clear_traps()
5365
5366 # Invalid arguments
5367 self.assertRaises(TypeError, c.copy_sign, Decimal(1), "x", "y")
5368 self.assertRaises(TypeError, c.canonical, 200)
5369 self.assertRaises(TypeError, c.is_canonical, 200)
5370 self.assertRaises(TypeError, c.divmod, 9, 8, "x", "y")
5371 self.assertRaises(TypeError, c.same_quantum, 9, 3, "x", "y")
5372
5373 self.assertEqual(str(c.canonical(Decimal(200))), '200')
5374 self.assertEqual(c.radix(), 10)
5375
5376 c.traps[DivisionByZero] = True
5377 self.assertRaises(DivisionByZero, Decimal(9).__divmod__, 0)
5378 self.assertRaises(DivisionByZero, c.divmod, 9, 0)
5379 self.assertTrue(c.flags[InvalidOperation])
5380
5381 c.clear_flags()
5382 c.traps[InvalidOperation] = True
5383 self.assertRaises(InvalidOperation, Decimal(9).__divmod__, 0)
5384 self.assertRaises(InvalidOperation, c.divmod, 9, 0)
5385 self.assertTrue(c.flags[DivisionByZero])
5386
5387 c.traps[InvalidOperation] = True
5388 c.prec = 2
5389 self.assertRaises(InvalidOperation, pow, Decimal(1000), 1, 501)
5390
5391 def test_va_args_exceptions(self):
5392 Decimal = C.Decimal
5393 Context = C.Context
5394
5395 x = Decimal("10001111111")
5396
5397 for attr in ['exp', 'is_normal', 'is_subnormal', 'ln', 'log10',
5398 'logb', 'logical_invert', 'next_minus', 'next_plus',
5399 'normalize', 'number_class', 'sqrt', 'to_eng_string']:
5400 func = getattr(x, attr)
5401 self.assertRaises(TypeError, func, context="x")
5402 self.assertRaises(TypeError, func, "x", context=None)
5403
5404 for attr in ['compare', 'compare_signal', 'logical_and',
5405 'logical_or', 'max', 'max_mag', 'min', 'min_mag',
5406 'remainder_near', 'rotate', 'scaleb', 'shift']:
5407 func = getattr(x, attr)
5408 self.assertRaises(TypeError, func, context="x")
5409 self.assertRaises(TypeError, func, "x", context=None)
5410
5411 self.assertRaises(TypeError, x.to_integral, rounding=None, context=[])
5412 self.assertRaises(TypeError, x.to_integral, rounding={}, context=[])
5413 self.assertRaises(TypeError, x.to_integral, [], [])
5414
5415 self.assertRaises(TypeError, x.to_integral_value, rounding=None, context=[])
5416 self.assertRaises(TypeError, x.to_integral_value, rounding={}, context=[])
5417 self.assertRaises(TypeError, x.to_integral_value, [], [])
5418
5419 self.assertRaises(TypeError, x.to_integral_exact, rounding=None, context=[])
5420 self.assertRaises(TypeError, x.to_integral_exact, rounding={}, context=[])
5421 self.assertRaises(TypeError, x.to_integral_exact, [], [])
5422
5423 self.assertRaises(TypeError, x.fma, 1, 2, context="x")
5424 self.assertRaises(TypeError, x.fma, 1, 2, "x", context=None)
5425
5426 self.assertRaises(TypeError, x.quantize, 1, [], context=None)
5427 self.assertRaises(TypeError, x.quantize, 1, [], rounding=None)
5428 self.assertRaises(TypeError, x.quantize, 1, [], [])
5429
5430 c = Context()
5431 self.assertRaises(TypeError, c.power, 1, 2, mod="x")
5432 self.assertRaises(TypeError, c.power, 1, "x", mod=None)
5433 self.assertRaises(TypeError, c.power, "x", 2, mod=None)
5434
5435 @requires_extra_functionality
5436 def test_c_context_templates(self):
5437 self.assertEqual(
5438 C.BasicContext._traps,
5439 C.DecIEEEInvalidOperation|C.DecDivisionByZero|C.DecOverflow|
5440 C.DecUnderflow|C.DecClamped
5441 )
5442 self.assertEqual(
5443 C.DefaultContext._traps,
5444 C.DecIEEEInvalidOperation|C.DecDivisionByZero|C.DecOverflow
5445 )
5446
5447 @requires_extra_functionality
5448 def test_c_signal_dict(self):
5449
5450 # SignalDict coverage
5451 Context = C.Context
5452 DefaultContext = C.DefaultContext
5453
5454 InvalidOperation = C.InvalidOperation
5455 FloatOperation = C.FloatOperation
5456 DivisionByZero = C.DivisionByZero
5457 Overflow = C.Overflow
5458 Subnormal = C.Subnormal
5459 Underflow = C.Underflow
5460 Rounded = C.Rounded
5461 Inexact = C.Inexact
5462 Clamped = C.Clamped
5463
5464 DecClamped = C.DecClamped
5465 DecInvalidOperation = C.DecInvalidOperation
5466 DecIEEEInvalidOperation = C.DecIEEEInvalidOperation
5467
5468 def assertIsExclusivelySet(signal, signal_dict):
5469 for sig in signal_dict:
5470 if sig == signal:
5471 self.assertTrue(signal_dict[sig])
5472 else:
5473 self.assertFalse(signal_dict[sig])
5474
5475 c = DefaultContext.copy()
5476
5477 # Signal dict methods
5478 self.assertTrue(Overflow in c.traps)
5479 c.clear_traps()
5480 for k in c.traps.keys():
5481 c.traps[k] = True
5482 for v in c.traps.values():
5483 self.assertTrue(v)
5484 c.clear_traps()
5485 for k, v in c.traps.items():
5486 self.assertFalse(v)
5487
5488 self.assertFalse(c.flags.get(Overflow))
5489 self.assertIs(c.flags.get("x"), None)
5490 self.assertEqual(c.flags.get("x", "y"), "y")
5491 self.assertRaises(TypeError, c.flags.get, "x", "y", "z")
5492
5493 self.assertEqual(len(c.flags), len(c.traps))
5494 s = sys.getsizeof(c.flags)
5495 s = sys.getsizeof(c.traps)
5496 s = c.flags.__repr__()
5497
5498 # Set flags/traps.
5499 c.clear_flags()
5500 c._flags = DecClamped
5501 self.assertTrue(c.flags[Clamped])
5502
5503 c.clear_traps()
5504 c._traps = DecInvalidOperation
5505 self.assertTrue(c.traps[InvalidOperation])
5506
5507 # Set flags/traps from dictionary.
5508 c.clear_flags()
5509 d = c.flags.copy()
5510 d[DivisionByZero] = True
5511 c.flags = d
5512 assertIsExclusivelySet(DivisionByZero, c.flags)
5513
5514 c.clear_traps()
5515 d = c.traps.copy()
5516 d[Underflow] = True
5517 c.traps = d
5518 assertIsExclusivelySet(Underflow, c.traps)
5519
5520 # Random constructors
5521 IntSignals = {
5522 Clamped: C.DecClamped,
5523 Rounded: C.DecRounded,
5524 Inexact: C.DecInexact,
5525 Subnormal: C.DecSubnormal,
5526 Underflow: C.DecUnderflow,
5527 Overflow: C.DecOverflow,
5528 DivisionByZero: C.DecDivisionByZero,
5529 FloatOperation: C.DecFloatOperation,
5530 InvalidOperation: C.DecIEEEInvalidOperation
5531 }
5532 IntCond = [
5533 C.DecDivisionImpossible, C.DecDivisionUndefined, C.DecFpuError,
5534 C.DecInvalidContext, C.DecInvalidOperation, C.DecMallocError,
5535 C.DecConversionSyntax,
5536 ]
5537
5538 lim = len(OrderedSignals[C])
5539 for r in range(lim):
5540 for t in range(lim):
5541 for round in RoundingModes:
5542 flags = random.sample(OrderedSignals[C], r)
5543 traps = random.sample(OrderedSignals[C], t)
5544 prec = random.randrange(1, 10000)
5545 emin = random.randrange(-10000, 0)
5546 emax = random.randrange(0, 10000)
5547 clamp = random.randrange(0, 2)
5548 caps = random.randrange(0, 2)
5549 cr = random.randrange(0, 2)
5550 c = Context(prec=prec, rounding=round, Emin=emin, Emax=emax,
5551 capitals=caps, clamp=clamp, flags=list(flags),
5552 traps=list(traps))
5553
5554 self.assertEqual(c.prec, prec)
5555 self.assertEqual(c.rounding, round)
5556 self.assertEqual(c.Emin, emin)
5557 self.assertEqual(c.Emax, emax)
5558 self.assertEqual(c.capitals, caps)
5559 self.assertEqual(c.clamp, clamp)
5560
5561 f = 0
5562 for x in flags:
5563 f |= IntSignals[x]
5564 self.assertEqual(c._flags, f)
5565
5566 f = 0
5567 for x in traps:
5568 f |= IntSignals[x]
5569 self.assertEqual(c._traps, f)
5570
5571 for cond in IntCond:
5572 c._flags = cond
5573 self.assertTrue(c._flags&DecIEEEInvalidOperation)
5574 assertIsExclusivelySet(InvalidOperation, c.flags)
5575
5576 for cond in IntCond:
5577 c._traps = cond
5578 self.assertTrue(c._traps&DecIEEEInvalidOperation)
5579 assertIsExclusivelySet(InvalidOperation, c.traps)
5580
5581 def test_invalid_override(self):
5582 Decimal = C.Decimal
5583
5584 try:
5585 from locale import CHAR_MAX
5586 except ImportError:
5587 self.skipTest('locale.CHAR_MAX not available')
5588
5589 def make_grouping(lst):
5590 return ''.join([chr(x) for x in lst])
5591
5592 def get_fmt(x, override=None, fmt='n'):
5593 return Decimal(x).__format__(fmt, override)
5594
5595 invalid_grouping = {
5596 'decimal_point' : ',',
5597 'grouping' : make_grouping([255, 255, 0]),
5598 'thousands_sep' : ','
5599 }
5600 invalid_dot = {
5601 'decimal_point' : 'xxxxx',
5602 'grouping' : make_grouping([3, 3, 0]),
5603 'thousands_sep' : ','
5604 }
5605 invalid_sep = {
5606 'decimal_point' : '.',
5607 'grouping' : make_grouping([3, 3, 0]),
5608 'thousands_sep' : 'yyyyy'
5609 }
5610
5611 if CHAR_MAX == 127: # negative grouping in override
5612 self.assertRaises(ValueError, get_fmt, 12345,
5613 invalid_grouping, 'g')
5614
5615 self.assertRaises(ValueError, get_fmt, 12345, invalid_dot, 'g')
5616 self.assertRaises(ValueError, get_fmt, 12345, invalid_sep, 'g')
5617
5618 def test_exact_conversion(self):
5619 Decimal = C.Decimal
5620 localcontext = C.localcontext
5621 InvalidOperation = C.InvalidOperation
5622
5623 with localcontext() as c:
5624
5625 c.traps[InvalidOperation] = True
5626
5627 # Clamped
5628 x = "0e%d" % sys.maxsize
5629 self.assertRaises(InvalidOperation, Decimal, x)
5630
5631 x = "0e%d" % (-sys.maxsize-1)
5632 self.assertRaises(InvalidOperation, Decimal, x)
5633
5634 # Overflow
5635 x = "1e%d" % sys.maxsize
5636 self.assertRaises(InvalidOperation, Decimal, x)
5637
5638 # Underflow
5639 x = "1e%d" % (-sys.maxsize-1)
5640 self.assertRaises(InvalidOperation, Decimal, x)
5641
5642 def test_from_tuple(self):
5643 Decimal = C.Decimal
5644 localcontext = C.localcontext
5645 InvalidOperation = C.InvalidOperation
5646 Overflow = C.Overflow
5647 Underflow = C.Underflow
5648
5649 with localcontext() as c:
5650
5651 c.prec = 9
5652 c.traps[InvalidOperation] = True
5653 c.traps[Overflow] = True
5654 c.traps[Underflow] = True
5655
5656 # SSIZE_MAX
5657 x = (1, (), sys.maxsize)
5658 self.assertEqual(str(c.create_decimal(x)), '-0E+999999')
5659 self.assertRaises(InvalidOperation, Decimal, x)
5660
5661 x = (1, (0, 1, 2), sys.maxsize)
5662 self.assertRaises(Overflow, c.create_decimal, x)
5663 self.assertRaises(InvalidOperation, Decimal, x)
5664
5665 # SSIZE_MIN
5666 x = (1, (), -sys.maxsize-1)
5667 self.assertEqual(str(c.create_decimal(x)), '-0E-1000007')
5668 self.assertRaises(InvalidOperation, Decimal, x)
5669
5670 x = (1, (0, 1, 2), -sys.maxsize-1)
5671 self.assertRaises(Underflow, c.create_decimal, x)
5672 self.assertRaises(InvalidOperation, Decimal, x)
5673
5674 # OverflowError
5675 x = (1, (), sys.maxsize+1)
5676 self.assertRaises(OverflowError, c.create_decimal, x)
5677 self.assertRaises(OverflowError, Decimal, x)
5678
5679 x = (1, (), -sys.maxsize-2)
5680 self.assertRaises(OverflowError, c.create_decimal, x)
5681 self.assertRaises(OverflowError, Decimal, x)
5682
5683 # Specials
5684 x = (1, (), "N")
5685 self.assertEqual(str(Decimal(x)), '-sNaN')
5686 x = (1, (0,), "N")
5687 self.assertEqual(str(Decimal(x)), '-sNaN')
5688 x = (1, (0, 1), "N")
5689 self.assertEqual(str(Decimal(x)), '-sNaN1')
5690
5691 def test_sizeof(self):
5692 Decimal = C.Decimal
5693 HAVE_CONFIG_64 = (C.MAX_PREC > 425000000)
5694
5695 self.assertGreater(Decimal(0).__sizeof__(), 0)
5696 if HAVE_CONFIG_64:
5697 x = Decimal(10**(19*24)).__sizeof__()
5698 y = Decimal(10**(19*25)).__sizeof__()
5699 self.assertEqual(y, x+8)
5700 else:
5701 x = Decimal(10**(9*24)).__sizeof__()
5702 y = Decimal(10**(9*25)).__sizeof__()
5703 self.assertEqual(y, x+4)
5704
5705 def test_internal_use_of_overridden_methods(self):
5706 Decimal = C.Decimal
5707
5708 # Unsound subtyping
5709 class X(float):
5710 def as_integer_ratio(self):
5711 return 1
5712 def __abs__(self):
5713 return self
5714
5715 class Y(float):
5716 def __abs__(self):
5717 return [1]*200
5718
5719 class I(int):
5720 def bit_length(self):
5721 return [1]*200
5722
5723 class Z(float):
5724 def as_integer_ratio(self):
5725 return (I(1), I(1))
5726 def __abs__(self):
5727 return self
5728
5729 for cls in X, Y, Z:
5730 self.assertEqual(Decimal.from_float(cls(101.1)),
5731 Decimal.from_float(101.1))
5732
5733 def test_c_immutable_types(self):
5734 SignalDict = type(C.Context().flags)
5735 SignalDictMixin = SignalDict.__bases__[0]
5736 ContextManager = type(C.localcontext())
5737 types = (
5738 SignalDictMixin,
5739 ContextManager,
5740 C.Decimal,
5741 C.Context,
5742 )
5743 for tp in types:
5744 with self.subTest(tp=tp):
5745 with self.assertRaisesRegex(TypeError, "immutable"):
5746 tp.foo = 1
5747
5748 def test_c_disallow_instantiation(self):
5749 ContextManager = type(C.localcontext())
5750 check_disallow_instantiation(self, ContextManager)
5751
5752 def test_c_signaldict_segfault(self):
5753 # See gh-106263 for details.
5754 SignalDict = type(C.Context().flags)
5755 sd = SignalDict()
5756 err_msg = "invalid signal dict"
5757
5758 with self.assertRaisesRegex(ValueError, err_msg):
5759 len(sd)
5760
5761 with self.assertRaisesRegex(ValueError, err_msg):
5762 iter(sd)
5763
5764 with self.assertRaisesRegex(ValueError, err_msg):
5765 repr(sd)
5766
5767 with self.assertRaisesRegex(ValueError, err_msg):
5768 sd[C.InvalidOperation] = True
5769
5770 with self.assertRaisesRegex(ValueError, err_msg):
5771 sd[C.InvalidOperation]
5772
5773 with self.assertRaisesRegex(ValueError, err_msg):
5774 sd == C.Context().flags
5775
5776 with self.assertRaisesRegex(ValueError, err_msg):
5777 C.Context().flags == sd
5778
5779 with self.assertRaisesRegex(ValueError, err_msg):
5780 sd.copy()
5781
5782 def test_format_fallback_capitals(self):
5783 # Fallback to _pydecimal formatting (triggered by `#` format which
5784 # is unsupported by mpdecimal) should honor the current context.
5785 x = C.Decimal('6.09e+23')
5786 self.assertEqual(format(x, '#'), '6.09E+23')
5787 with C.localcontext(capitals=0):
5788 self.assertEqual(format(x, '#'), '6.09e+23')
5789
5790 def test_format_fallback_rounding(self):
5791 y = C.Decimal('6.09')
5792 self.assertEqual(format(y, '#.1f'), '6.1')
5793 with C.localcontext(rounding=C.ROUND_DOWN):
5794 self.assertEqual(format(y, '#.1f'), '6.0')
5795
5796 @requires_docstrings
5797 @requires_cdecimal
5798 class SignatureTest(unittest.TestCase):
5799 """Function signatures"""
5800
5801 def test_inspect_module(self):
5802 for attr in dir(P):
5803 if attr.startswith('_'):
5804 continue
5805 p_func = getattr(P, attr)
5806 c_func = getattr(C, attr)
5807 if (attr == 'Decimal' or attr == 'Context' or
5808 inspect.isfunction(p_func)):
5809 p_sig = inspect.signature(p_func)
5810 c_sig = inspect.signature(c_func)
5811
5812 # parameter names:
5813 c_names = list(c_sig.parameters.keys())
5814 p_names = [x for x in p_sig.parameters.keys() if not
5815 x.startswith('_')]
5816
5817 self.assertEqual(c_names, p_names,
5818 msg="parameter name mismatch in %s" % p_func)
5819
5820 c_kind = [x.kind for x in c_sig.parameters.values()]
5821 p_kind = [x[1].kind for x in p_sig.parameters.items() if not
5822 x[0].startswith('_')]
5823
5824 # parameters:
5825 if attr != 'setcontext':
5826 self.assertEqual(c_kind, p_kind,
5827 msg="parameter kind mismatch in %s" % p_func)
5828
5829 def test_inspect_types(self):
5830
5831 POS = inspect._ParameterKind.POSITIONAL_ONLY
5832 POS_KWD = inspect._ParameterKind.POSITIONAL_OR_KEYWORD
5833
5834 # Type heuristic (type annotations would help!):
5835 pdict = {C: {'other': C.Decimal(1),
5836 'third': C.Decimal(1),
5837 'x': C.Decimal(1),
5838 'y': C.Decimal(1),
5839 'z': C.Decimal(1),
5840 'a': C.Decimal(1),
5841 'b': C.Decimal(1),
5842 'c': C.Decimal(1),
5843 'exp': C.Decimal(1),
5844 'modulo': C.Decimal(1),
5845 'num': "1",
5846 'f': 1.0,
5847 'rounding': C.ROUND_HALF_UP,
5848 'context': C.getcontext()},
5849 P: {'other': P.Decimal(1),
5850 'third': P.Decimal(1),
5851 'a': P.Decimal(1),
5852 'b': P.Decimal(1),
5853 'c': P.Decimal(1),
5854 'exp': P.Decimal(1),
5855 'modulo': P.Decimal(1),
5856 'num': "1",
5857 'f': 1.0,
5858 'rounding': P.ROUND_HALF_UP,
5859 'context': P.getcontext()}}
5860
5861 def mkargs(module, sig):
5862 args = []
5863 kwargs = {}
5864 for name, param in sig.parameters.items():
5865 if name == 'self': continue
5866 if param.kind == POS:
5867 args.append(pdict[module][name])
5868 elif param.kind == POS_KWD:
5869 kwargs[name] = pdict[module][name]
5870 else:
5871 raise TestFailed("unexpected parameter kind")
5872 return args, kwargs
5873
5874 def tr(s):
5875 """The C Context docstrings use 'x' in order to prevent confusion
5876 with the article 'a' in the descriptions."""
5877 if s == 'x': return 'a'
5878 if s == 'y': return 'b'
5879 if s == 'z': return 'c'
5880 return s
5881
5882 def doit(ty):
5883 p_type = getattr(P, ty)
5884 c_type = getattr(C, ty)
5885 for attr in dir(p_type):
5886 if attr.startswith('_'):
5887 continue
5888 p_func = getattr(p_type, attr)
5889 c_func = getattr(c_type, attr)
5890 if inspect.isfunction(p_func):
5891 p_sig = inspect.signature(p_func)
5892 c_sig = inspect.signature(c_func)
5893
5894 # parameter names:
5895 p_names = list(p_sig.parameters.keys())
5896 c_names = [tr(x) for x in c_sig.parameters.keys()]
5897
5898 self.assertEqual(c_names, p_names,
5899 msg="parameter name mismatch in %s" % p_func)
5900
5901 p_kind = [x.kind for x in p_sig.parameters.values()]
5902 c_kind = [x.kind for x in c_sig.parameters.values()]
5903
5904 # 'self' parameter:
5905 self.assertIs(p_kind[0], POS_KWD)
5906 self.assertIs(c_kind[0], POS)
5907
5908 # remaining parameters:
5909 if ty == 'Decimal':
5910 self.assertEqual(c_kind[1:], p_kind[1:],
5911 msg="parameter kind mismatch in %s" % p_func)
5912 else: # Context methods are positional only in the C version.
5913 self.assertEqual(len(c_kind), len(p_kind),
5914 msg="parameter kind mismatch in %s" % p_func)
5915
5916 # Run the function:
5917 args, kwds = mkargs(C, c_sig)
5918 try:
5919 getattr(c_type(9), attr)(*args, **kwds)
5920 except Exception:
5921 raise TestFailed("invalid signature for %s: %s %s" % (c_func, args, kwds))
5922
5923 args, kwds = mkargs(P, p_sig)
5924 try:
5925 getattr(p_type(9), attr)(*args, **kwds)
5926 except Exception:
5927 raise TestFailed("invalid signature for %s: %s %s" % (p_func, args, kwds))
5928
5929 doit('Decimal')
5930 doit('Context')
5931
5932
5933 def load_tests(loader, tests, pattern):
5934 if TODO_TESTS is not None:
5935 # Run only Arithmetic tests
5936 tests = loader.suiteClass()
5937 # Dynamically build custom test definition for each file in the test
5938 # directory and add the definitions to the DecimalTest class. This
5939 # procedure insures that new files do not get skipped.
5940 for filename in os.listdir(directory):
5941 if '.decTest' not in filename or filename.startswith("."):
5942 continue
5943 head, tail = filename.split('.')
5944 if TODO_TESTS is not None and head not in TODO_TESTS:
5945 continue
5946 tester = lambda self, f=filename: self.eval_file(directory + f)
5947 setattr(IBMTestCases, 'test_' + head, tester)
5948 del filename, head, tail, tester
5949 for prefix, mod in ('C', C), ('Py', P):
5950 if not mod:
5951 continue
5952 test_class = type(prefix + 'IBMTestCases',
5953 (IBMTestCases, unittest.TestCase),
5954 {'decimal': mod})
5955 tests.addTest(loader.loadTestsFromTestCase(test_class))
5956
5957 if TODO_TESTS is None:
5958 from doctest import DocTestSuite, IGNORE_EXCEPTION_DETAIL
5959 orig_context = orig_sys_decimal.getcontext().copy()
5960 for mod in C, P:
5961 if not mod:
5962 continue
5963 def setUp(slf, mod=mod):
5964 sys.modules['decimal'] = mod
5965 init(mod)
5966 def tearDown(slf, mod=mod):
5967 sys.modules['decimal'] = orig_sys_decimal
5968 mod.setcontext(ORIGINAL_CONTEXT[mod].copy())
5969 orig_sys_decimal.setcontext(orig_context.copy())
5970 optionflags = IGNORE_EXCEPTION_DETAIL if mod is C else 0
5971 sys.modules['decimal'] = mod
5972 tests.addTest(DocTestSuite(mod, setUp=setUp, tearDown=tearDown,
5973 optionflags=optionflags))
5974 sys.modules['decimal'] = orig_sys_decimal
5975 return tests
5976
5977 def setUpModule():
5978 init(C)
5979 init(P)
5980 global TEST_ALL
5981 TEST_ALL = ARITH if ARITH is not None else is_resource_enabled('decimal')
5982
5983 def tearDownModule():
5984 if C: C.setcontext(ORIGINAL_CONTEXT[C].copy())
5985 P.setcontext(ORIGINAL_CONTEXT[P].copy())
5986 if not C:
5987 logging.getLogger(__name__).warning(
5988 'C tests skipped: no module named _decimal.'
5989 )
5990 if not orig_sys_decimal is sys.modules['decimal']:
5991 raise TestFailed("Internal error: unbalanced number of changes to "
5992 "sys.modules['decimal'].")
5993
5994
5995 ARITH = None
5996 TEST_ALL = True
5997 TODO_TESTS = None
5998 DEBUG = False
5999
6000 def test(arith=None, verbose=None, todo_tests=None, debug=None):
6001 """ Execute the tests.
6002
6003 Runs all arithmetic tests if arith is True or if the "decimal" resource
6004 is enabled in regrtest.py
6005 """
6006
6007 global ARITH, TODO_TESTS, DEBUG
6008 ARITH = arith
6009 TODO_TESTS = todo_tests
6010 DEBUG = debug
6011 unittest.main(__name__, verbosity=2 if verbose else 1, exit=False, argv=[__name__])
6012
6013
6014 if __name__ == '__main__':
6015 import optparse
6016 p = optparse.OptionParser("test_decimal.py [--debug] [{--skip | test1 [test2 [...]]}]")
6017 p.add_option('--debug', '-d', action='store_true', help='shows the test number and context before each test')
6018 p.add_option('--skip', '-s', action='store_true', help='skip over 90% of the arithmetic tests')
6019 (opt, args) = p.parse_args()
6020
6021 if opt.skip:
6022 test(arith=False, verbose=True)
6023 elif args:
6024 test(arith=True, verbose=True, todo_tests=args, debug=opt.debug)
6025 else:
6026 test(arith=True, verbose=True)