Python code coverage for Modules/_decimal/tests/deccheck.py

#	count	content
1	n/a	#
2	n/a	# Copyright (c) 2008-2012 Stefan Krah. All rights reserved.
3	n/a	#
4	n/a	# Redistribution and use in source and binary forms, with or without
5	n/a	# modification, are permitted provided that the following conditions
6	n/a	# are met:
7	n/a	#
8	n/a	# 1. Redistributions of source code must retain the above copyright
9	n/a	# notice, this list of conditions and the following disclaimer.
10	n/a	#
11	n/a	# 2. Redistributions in binary form must reproduce the above copyright
12	n/a	# notice, this list of conditions and the following disclaimer in the
13	n/a	# documentation and/or other materials provided with the distribution.
14	n/a	#
15	n/a	# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
16	n/a	# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	n/a	# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	n/a	# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19	n/a	# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20	n/a	# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21	n/a	# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22	n/a	# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23	n/a	# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24	n/a	# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25	n/a	# SUCH DAMAGE.
26	n/a	#
27	n/a
28	n/a	#
29	n/a	# Usage: python deccheck.py [--short\|--medium\|--long\|--all]
30	n/a	#
31	n/a
32	n/a	import sys, random
33	n/a	from copy import copy
34	n/a	from collections import defaultdict
35	n/a	from test.support import import_fresh_module
36	n/a	from randdec import randfloat, all_unary, all_binary, all_ternary
37	n/a	from randdec import unary_optarg, binary_optarg, ternary_optarg
38	n/a	from formathelper import rand_format, rand_locale
39	n/a	from _pydecimal import _dec_from_triple
40	n/a
41	n/a	C = import_fresh_module('decimal', fresh=['_decimal'])
42	n/a	P = import_fresh_module('decimal', blocked=['_decimal'])
43	n/a	EXIT_STATUS = 0
44	n/a
45	n/a
46	n/a	# Contains all categories of Decimal methods.
47	n/a	Functions = {
48	n/a	# Plain unary:
49	n/a	'unary': (
50	n/a	'__abs__', '__bool__', '__ceil__', '__complex__', '__copy__',
51	n/a	'__floor__', '__float__', '__hash__', '__int__', '__neg__',
52	n/a	'__pos__', '__reduce__', '__repr__', '__str__', '__trunc__',
53	n/a	'adjusted', 'as_integer_ratio', 'as_tuple', 'canonical', 'conjugate',
54	n/a	'copy_abs', 'copy_negate', 'is_canonical', 'is_finite', 'is_infinite',
55	n/a	'is_nan', 'is_qnan', 'is_signed', 'is_snan', 'is_zero', 'radix'
56	n/a	),
57	n/a	# Unary with optional context:
58	n/a	'unary_ctx': (
59	n/a	'exp', 'is_normal', 'is_subnormal', 'ln', 'log10', 'logb',
60	n/a	'logical_invert', 'next_minus', 'next_plus', 'normalize',
61	n/a	'number_class', 'sqrt', 'to_eng_string'
62	n/a	),
63	n/a	# Unary with optional rounding mode and context:
64	n/a	'unary_rnd_ctx': ('to_integral', 'to_integral_exact', 'to_integral_value'),
65	n/a	# Plain binary:
66	n/a	'binary': (
67	n/a	'__add__', '__divmod__', '__eq__', '__floordiv__', '__ge__', '__gt__',
68	n/a	'__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__pow__',
69	n/a	'__radd__', '__rdivmod__', '__rfloordiv__', '__rmod__', '__rmul__',
70	n/a	'__rpow__', '__rsub__', '__rtruediv__', '__sub__', '__truediv__',
71	n/a	'compare_total', 'compare_total_mag', 'copy_sign', 'quantize',
72	n/a	'same_quantum'
73	n/a	),
74	n/a	# Binary with optional context:
75	n/a	'binary_ctx': (
76	n/a	'compare', 'compare_signal', 'logical_and', 'logical_or', 'logical_xor',
77	n/a	'max', 'max_mag', 'min', 'min_mag', 'next_toward', 'remainder_near',
78	n/a	'rotate', 'scaleb', 'shift'
79	n/a	),
80	n/a	# Plain ternary:
81	n/a	'ternary': ('__pow__',),
82	n/a	# Ternary with optional context:
83	n/a	'ternary_ctx': ('fma',),
84	n/a	# Special:
85	n/a	'special': ('__format__', '__reduce_ex__', '__round__', 'from_float',
86	n/a	'quantize'),
87	n/a	# Properties:
88	n/a	'property': ('real', 'imag')
89	n/a	}
90	n/a
91	n/a	# Contains all categories of Context methods. The n-ary classification
92	n/a	# applies to the number of Decimal arguments.
93	n/a	ContextFunctions = {
94	n/a	# Plain nullary:
95	n/a	'nullary': ('context.__hash__', 'context.__reduce__', 'context.radix'),
96	n/a	# Plain unary:
97	n/a	'unary': ('context.abs', 'context.canonical', 'context.copy_abs',
98	n/a	'context.copy_decimal', 'context.copy_negate',
99	n/a	'context.create_decimal', 'context.exp', 'context.is_canonical',
100	n/a	'context.is_finite', 'context.is_infinite', 'context.is_nan',
101	n/a	'context.is_normal', 'context.is_qnan', 'context.is_signed',
102	n/a	'context.is_snan', 'context.is_subnormal', 'context.is_zero',
103	n/a	'context.ln', 'context.log10', 'context.logb',
104	n/a	'context.logical_invert', 'context.minus', 'context.next_minus',
105	n/a	'context.next_plus', 'context.normalize', 'context.number_class',
106	n/a	'context.plus', 'context.sqrt', 'context.to_eng_string',
107	n/a	'context.to_integral', 'context.to_integral_exact',
108	n/a	'context.to_integral_value', 'context.to_sci_string'
109	n/a	),
110	n/a	# Plain binary:
111	n/a	'binary': ('context.add', 'context.compare', 'context.compare_signal',
112	n/a	'context.compare_total', 'context.compare_total_mag',
113	n/a	'context.copy_sign', 'context.divide', 'context.divide_int',
114	n/a	'context.divmod', 'context.logical_and', 'context.logical_or',
115	n/a	'context.logical_xor', 'context.max', 'context.max_mag',
116	n/a	'context.min', 'context.min_mag', 'context.multiply',
117	n/a	'context.next_toward', 'context.power', 'context.quantize',
118	n/a	'context.remainder', 'context.remainder_near', 'context.rotate',
119	n/a	'context.same_quantum', 'context.scaleb', 'context.shift',
120	n/a	'context.subtract'
121	n/a	),
122	n/a	# Plain ternary:
123	n/a	'ternary': ('context.fma', 'context.power'),
124	n/a	# Special:
125	n/a	'special': ('context.__reduce_ex__', 'context.create_decimal_from_float')
126	n/a	}
127	n/a
128	n/a	# Functions that require a restricted exponent range for reasonable runtimes.
129	n/a	UnaryRestricted = [
130	n/a	'__ceil__', '__floor__', '__int__', '__trunc__',
131	n/a	'as_integer_ratio', 'to_integral', 'to_integral_value'
132	n/a	]
133	n/a
134	n/a	BinaryRestricted = ['__round__']
135	n/a
136	n/a	TernaryRestricted = ['__pow__', 'context.power']
137	n/a
138	n/a
139	n/a	# ======================================================================
140	n/a	# Unified Context
141	n/a	# ======================================================================
142	n/a
143	n/a	# Translate symbols.
144	n/a	CondMap = {
145	n/a	C.Clamped: P.Clamped,
146	n/a	C.ConversionSyntax: P.ConversionSyntax,
147	n/a	C.DivisionByZero: P.DivisionByZero,
148	n/a	C.DivisionImpossible: P.InvalidOperation,
149	n/a	C.DivisionUndefined: P.DivisionUndefined,
150	n/a	C.Inexact: P.Inexact,
151	n/a	C.InvalidContext: P.InvalidContext,
152	n/a	C.InvalidOperation: P.InvalidOperation,
153	n/a	C.Overflow: P.Overflow,
154	n/a	C.Rounded: P.Rounded,
155	n/a	C.Subnormal: P.Subnormal,
156	n/a	C.Underflow: P.Underflow,
157	n/a	C.FloatOperation: P.FloatOperation,
158	n/a	}
159	n/a
160	n/a	RoundModes = [C.ROUND_UP, C.ROUND_DOWN, C.ROUND_CEILING, C.ROUND_FLOOR,
161	n/a	C.ROUND_HALF_UP, C.ROUND_HALF_DOWN, C.ROUND_HALF_EVEN,
162	n/a	C.ROUND_05UP]
163	n/a
164	n/a
165	n/a	class Context(object):
166	n/a	"""Provides a convenient way of syncing the C and P contexts"""
167	n/a
168	n/a	__slots__ = ['c', 'p']
169	n/a
170	n/a	def __init__(self, c_ctx=None, p_ctx=None):
171	n/a	"""Initialization is from the C context"""
172	n/a	self.c = C.getcontext() if c_ctx is None else c_ctx
173	n/a	self.p = P.getcontext() if p_ctx is None else p_ctx
174	n/a	self.p.prec = self.c.prec
175	n/a	self.p.Emin = self.c.Emin
176	n/a	self.p.Emax = self.c.Emax
177	n/a	self.p.rounding = self.c.rounding
178	n/a	self.p.capitals = self.c.capitals
179	n/a	self.settraps([sig for sig in self.c.traps if self.c.traps[sig]])
180	n/a	self.setstatus([sig for sig in self.c.flags if self.c.flags[sig]])
181	n/a	self.p.clamp = self.c.clamp
182	n/a
183	n/a	def __str__(self):
184	n/a	return str(self.c) + '\n' + str(self.p)
185	n/a
186	n/a	def getprec(self):
187	n/a	assert(self.c.prec == self.p.prec)
188	n/a	return self.c.prec
189	n/a
190	n/a	def setprec(self, val):
191	n/a	self.c.prec = val
192	n/a	self.p.prec = val
193	n/a
194	n/a	def getemin(self):
195	n/a	assert(self.c.Emin == self.p.Emin)
196	n/a	return self.c.Emin
197	n/a
198	n/a	def setemin(self, val):
199	n/a	self.c.Emin = val
200	n/a	self.p.Emin = val
201	n/a
202	n/a	def getemax(self):
203	n/a	assert(self.c.Emax == self.p.Emax)
204	n/a	return self.c.Emax
205	n/a
206	n/a	def setemax(self, val):
207	n/a	self.c.Emax = val
208	n/a	self.p.Emax = val
209	n/a
210	n/a	def getround(self):
211	n/a	assert(self.c.rounding == self.p.rounding)
212	n/a	return self.c.rounding
213	n/a
214	n/a	def setround(self, val):
215	n/a	self.c.rounding = val
216	n/a	self.p.rounding = val
217	n/a
218	n/a	def getcapitals(self):
219	n/a	assert(self.c.capitals == self.p.capitals)
220	n/a	return self.c.capitals
221	n/a
222	n/a	def setcapitals(self, val):
223	n/a	self.c.capitals = val
224	n/a	self.p.capitals = val
225	n/a
226	n/a	def getclamp(self):
227	n/a	assert(self.c.clamp == self.p.clamp)
228	n/a	return self.c.clamp
229	n/a
230	n/a	def setclamp(self, val):
231	n/a	self.c.clamp = val
232	n/a	self.p.clamp = val
233	n/a
234	n/a	prec = property(getprec, setprec)
235	n/a	Emin = property(getemin, setemin)
236	n/a	Emax = property(getemax, setemax)
237	n/a	rounding = property(getround, setround)
238	n/a	clamp = property(getclamp, setclamp)
239	n/a	capitals = property(getcapitals, setcapitals)
240	n/a
241	n/a	def clear_traps(self):
242	n/a	self.c.clear_traps()
243	n/a	for trap in self.p.traps:
244	n/a	self.p.traps[trap] = False
245	n/a
246	n/a	def clear_status(self):
247	n/a	self.c.clear_flags()
248	n/a	self.p.clear_flags()
249	n/a
250	n/a	def settraps(self, lst):
251	n/a	"""lst: C signal list"""
252	n/a	self.clear_traps()
253	n/a	for signal in lst:
254	n/a	self.c.traps[signal] = True
255	n/a	self.p.traps[CondMap[signal]] = True
256	n/a
257	n/a	def setstatus(self, lst):
258	n/a	"""lst: C signal list"""
259	n/a	self.clear_status()
260	n/a	for signal in lst:
261	n/a	self.c.flags[signal] = True
262	n/a	self.p.flags[CondMap[signal]] = True
263	n/a
264	n/a	def assert_eq_status(self):
265	n/a	"""assert equality of C and P status"""
266	n/a	for signal in self.c.flags:
267	n/a	if self.c.flags[signal] == (not self.p.flags[CondMap[signal]]):
268	n/a	return False
269	n/a	return True
270	n/a
271	n/a
272	n/a	# We don't want exceptions so that we can compare the status flags.
273	n/a	context = Context()
274	n/a	context.Emin = C.MIN_EMIN
275	n/a	context.Emax = C.MAX_EMAX
276	n/a	context.clear_traps()
277	n/a
278	n/a	# When creating decimals, _decimal is ultimately limited by the maximum
279	n/a	# context values. We emulate this restriction for decimal.py.
280	n/a	maxcontext = P.Context(
281	n/a	prec=C.MAX_PREC,
282	n/a	Emin=C.MIN_EMIN,
283	n/a	Emax=C.MAX_EMAX,
284	n/a	rounding=P.ROUND_HALF_UP,
285	n/a	capitals=1
286	n/a	)
287	n/a	maxcontext.clamp = 0
288	n/a
289	n/a	def RestrictedDecimal(value):
290	n/a	maxcontext.traps = copy(context.p.traps)
291	n/a	maxcontext.clear_flags()
292	n/a	if isinstance(value, str):
293	n/a	value = value.strip()
294	n/a	dec = maxcontext.create_decimal(value)
295	n/a	if maxcontext.flags[P.Inexact] or \
296	n/a	maxcontext.flags[P.Rounded] or \
297	n/a	maxcontext.flags[P.Clamped] or \
298	n/a	maxcontext.flags[P.InvalidOperation]:
299	n/a	return context.p._raise_error(P.InvalidOperation)
300	n/a	if maxcontext.flags[P.FloatOperation]:
301	n/a	context.p.flags[P.FloatOperation] = True
302	n/a	return dec
303	n/a
304	n/a
305	n/a	# ======================================================================
306	n/a	# TestSet: Organize data and events during a single test case
307	n/a	# ======================================================================
308	n/a
309	n/a	class RestrictedList(list):
310	n/a	"""List that can only be modified by appending items."""
311	n/a	def __getattribute__(self, name):
312	n/a	if name != 'append':
313	n/a	raise AttributeError("unsupported operation")
314	n/a	return list.__getattribute__(self, name)
315	n/a	def unsupported(self, *_):
316	n/a	raise AttributeError("unsupported operation")
317	n/a	__add__ = __delattr__ = __delitem__ = __iadd__ = __imul__ = unsupported
318	n/a	__mul__ = __reversed__ = __rmul__ = __setattr__ = __setitem__ = unsupported
319	n/a
320	n/a	class TestSet(object):
321	n/a	"""A TestSet contains the original input operands, converted operands,
322	n/a	Python exceptions that occurred either during conversion or during
323	n/a	execution of the actual function, and the final results.
324	n/a
325	n/a	For safety, most attributes are lists that only support the append
326	n/a	operation.
327	n/a
328	n/a	If a function name is prefixed with 'context.', the corresponding
329	n/a	context method is called.
330	n/a	"""
331	n/a	def __init__(self, funcname, operands):
332	n/a	if funcname.startswith("context."):
333	n/a	self.funcname = funcname.replace("context.", "")
334	n/a	self.contextfunc = True
335	n/a	else:
336	n/a	self.funcname = funcname
337	n/a	self.contextfunc = False
338	n/a	self.op = operands # raw operand tuple
339	n/a	self.context = context # context used for the operation
340	n/a	self.cop = RestrictedList() # converted C.Decimal operands
341	n/a	self.cex = RestrictedList() # Python exceptions for C.Decimal
342	n/a	self.cresults = RestrictedList() # C.Decimal results
343	n/a	self.pop = RestrictedList() # converted P.Decimal operands
344	n/a	self.pex = RestrictedList() # Python exceptions for P.Decimal
345	n/a	self.presults = RestrictedList() # P.Decimal results
346	n/a
347	n/a
348	n/a	# ======================================================================
349	n/a	# SkipHandler: skip known discrepancies
350	n/a	# ======================================================================
351	n/a
352	n/a	class SkipHandler:
353	n/a	"""Handle known discrepancies between decimal.py and _decimal.so.
354	n/a	These are either ULP differences in the power function or
355	n/a	extremely minor issues."""
356	n/a
357	n/a	def __init__(self):
358	n/a	self.ulpdiff = 0
359	n/a	self.powmod_zeros = 0
360	n/a	self.maxctx = P.Context(Emax=1018, Emin=-1018)
361	n/a
362	n/a	def default(self, t):
363	n/a	return False
364	n/a	__ge__ = __gt__ = __le__ = __lt__ = __ne__ = __eq__ = default
365	n/a	__reduce__ = __format__ = __repr__ = __str__ = default
366	n/a
367	n/a	def harrison_ulp(self, dec):
368	n/a	"""ftp://ftp.inria.fr/INRIA/publication/publi-pdf/RR/RR-5504.pdf"""
369	n/a	a = dec.next_plus()
370	n/a	b = dec.next_minus()
371	n/a	return abs(a - b)
372	n/a
373	n/a	def standard_ulp(self, dec, prec):
374	n/a	return _dec_from_triple(0, '1', dec._exp+len(dec._int)-prec)
375	n/a
376	n/a	def rounding_direction(self, x, mode):
377	n/a	"""Determine the effective direction of the rounding when
378	n/a	the exact result x is rounded according to mode.
379	n/a	Return -1 for downwards, 0 for undirected, 1 for upwards,
380	n/a	2 for ROUND_05UP."""
381	n/a	cmp = 1 if x.compare_total(P.Decimal("+0")) >= 0 else -1
382	n/a
383	n/a	if mode in (P.ROUND_HALF_EVEN, P.ROUND_HALF_UP, P.ROUND_HALF_DOWN):
384	n/a	return 0
385	n/a	elif mode == P.ROUND_CEILING:
386	n/a	return 1
387	n/a	elif mode == P.ROUND_FLOOR:
388	n/a	return -1
389	n/a	elif mode == P.ROUND_UP:
390	n/a	return cmp
391	n/a	elif mode == P.ROUND_DOWN:
392	n/a	return -cmp
393	n/a	elif mode == P.ROUND_05UP:
394	n/a	return 2
395	n/a	else:
396	n/a	raise ValueError("Unexpected rounding mode: %s" % mode)
397	n/a
398	n/a	def check_ulpdiff(self, exact, rounded):
399	n/a	# current precision
400	n/a	p = context.p.prec
401	n/a
402	n/a	# Convert infinities to the largest representable number + 1.
403	n/a	x = exact
404	n/a	if exact.is_infinite():
405	n/a	x = _dec_from_triple(exact._sign, '10', context.p.Emax)
406	n/a	y = rounded
407	n/a	if rounded.is_infinite():
408	n/a	y = _dec_from_triple(rounded._sign, '10', context.p.Emax)
409	n/a
410	n/a	# err = (rounded - exact) / ulp(rounded)
411	n/a	self.maxctx.prec = p * 2
412	n/a	t = self.maxctx.subtract(y, x)
413	n/a	if context.c.flags[C.Clamped] or \
414	n/a	context.c.flags[C.Underflow]:
415	n/a	# The standard ulp does not work in Underflow territory.
416	n/a	ulp = self.harrison_ulp(y)
417	n/a	else:
418	n/a	ulp = self.standard_ulp(y, p)
419	n/a	# Error in ulps.
420	n/a	err = self.maxctx.divide(t, ulp)
421	n/a
422	n/a	dir = self.rounding_direction(x, context.p.rounding)
423	n/a	if dir == 0:
424	n/a	if P.Decimal("-0.6") < err < P.Decimal("0.6"):
425	n/a	return True
426	n/a	elif dir == 1: # directed, upwards
427	n/a	if P.Decimal("-0.1") < err < P.Decimal("1.1"):
428	n/a	return True
429	n/a	elif dir == -1: # directed, downwards
430	n/a	if P.Decimal("-1.1") < err < P.Decimal("0.1"):
431	n/a	return True
432	n/a	else: # ROUND_05UP
433	n/a	if P.Decimal("-1.1") < err < P.Decimal("1.1"):
434	n/a	return True
435	n/a
436	n/a	print("ulp: %s error: %s exact: %s c_rounded: %s"
437	n/a	% (ulp, err, exact, rounded))
438	n/a	return False
439	n/a
440	n/a	def bin_resolve_ulp(self, t):
441	n/a	"""Check if results of _decimal's power function are within the
442	n/a	allowed ulp ranges."""
443	n/a	# NaNs are beyond repair.
444	n/a	if t.rc.is_nan() or t.rp.is_nan():
445	n/a	return False
446	n/a
447	n/a	# "exact" result, double precision, half_even
448	n/a	self.maxctx.prec = context.p.prec * 2
449	n/a
450	n/a	op1, op2 = t.pop[0], t.pop[1]
451	n/a	if t.contextfunc:
452	n/a	exact = getattr(self.maxctx, t.funcname)(op1, op2)
453	n/a	else:
454	n/a	exact = getattr(op1, t.funcname)(op2, context=self.maxctx)
455	n/a
456	n/a	# _decimal's rounded result
457	n/a	rounded = P.Decimal(t.cresults[0])
458	n/a
459	n/a	self.ulpdiff += 1
460	n/a	return self.check_ulpdiff(exact, rounded)
461	n/a
462	n/a	############################ Correct rounding #############################
463	n/a	def resolve_underflow(self, t):
464	n/a	"""In extremely rare cases where the infinite precision result is just
465	n/a	below etiny, cdecimal does not set Subnormal/Underflow. Example:
466	n/a
467	n/a	setcontext(Context(prec=21, rounding=ROUND_UP, Emin=-55, Emax=85))
468	n/a	Decimal("1.00000000000000000000000000000000000000000000000"
469	n/a	"0000000100000000000000000000000000000000000000000"
470	n/a	"0000000000000025").ln()
471	n/a	"""
472	n/a	if t.cresults != t.presults:
473	n/a	return False # Results must be identical.
474	n/a	if context.c.flags[C.Rounded] and \
475	n/a	context.c.flags[C.Inexact] and \
476	n/a	context.p.flags[P.Rounded] and \
477	n/a	context.p.flags[P.Inexact]:
478	n/a	return True # Subnormal/Underflow may be missing.
479	n/a	return False
480	n/a
481	n/a	def exp(self, t):
482	n/a	"""Resolve Underflow or ULP difference."""
483	n/a	return self.resolve_underflow(t)
484	n/a
485	n/a	def log10(self, t):
486	n/a	"""Resolve Underflow or ULP difference."""
487	n/a	return self.resolve_underflow(t)
488	n/a
489	n/a	def ln(self, t):
490	n/a	"""Resolve Underflow or ULP difference."""
491	n/a	return self.resolve_underflow(t)
492	n/a
493	n/a	def __pow__(self, t):
494	n/a	"""Always calls the resolve function. C.Decimal does not have correct
495	n/a	rounding for the power function."""
496	n/a	if context.c.flags[C.Rounded] and \
497	n/a	context.c.flags[C.Inexact] and \
498	n/a	context.p.flags[P.Rounded] and \
499	n/a	context.p.flags[P.Inexact]:
500	n/a	return self.bin_resolve_ulp(t)
501	n/a	else:
502	n/a	return False
503	n/a	power = __rpow__ = __pow__
504	n/a
505	n/a	############################## Technicalities #############################
506	n/a	def __float__(self, t):
507	n/a	"""NaN comparison in the verify() function obviously gives an
508	n/a	incorrect answer: nan == nan -> False"""
509	n/a	if t.cop[0].is_nan() and t.pop[0].is_nan():
510	n/a	return True
511	n/a	return False
512	n/a	__complex__ = __float__
513	n/a
514	n/a	def __radd__(self, t):
515	n/a	"""decimal.py gives precedence to the first NaN; this is
516	n/a	not important, as __radd__ will not be called for
517	n/a	two decimal arguments."""
518	n/a	if t.rc.is_nan() and t.rp.is_nan():
519	n/a	return True
520	n/a	return False
521	n/a	__rmul__ = __radd__
522	n/a
523	n/a	################################ Various ##################################
524	n/a	def __round__(self, t):
525	n/a	"""Exception: Decimal('1').__round__(-100000000000000000000000000)
526	n/a	Should it really be InvalidOperation?"""
527	n/a	if t.rc is None and t.rp.is_nan():
528	n/a	return True
529	n/a	return False
530	n/a
531	n/a	shandler = SkipHandler()
532	n/a	def skip_error(t):
533	n/a	return getattr(shandler, t.funcname, shandler.default)(t)
534	n/a
535	n/a
536	n/a	# ======================================================================
537	n/a	# Handling verification errors
538	n/a	# ======================================================================
539	n/a
540	n/a	class VerifyError(Exception):
541	n/a	"""Verification failed."""
542	n/a	pass
543	n/a
544	n/a	def function_as_string(t):
545	n/a	if t.contextfunc:
546	n/a	cargs = t.cop
547	n/a	pargs = t.pop
548	n/a	cfunc = "c_func: %s(" % t.funcname
549	n/a	pfunc = "p_func: %s(" % t.funcname
550	n/a	else:
551	n/a	cself, cargs = t.cop[0], t.cop[1:]
552	n/a	pself, pargs = t.pop[0], t.pop[1:]
553	n/a	cfunc = "c_func: %s.%s(" % (repr(cself), t.funcname)
554	n/a	pfunc = "p_func: %s.%s(" % (repr(pself), t.funcname)
555	n/a
556	n/a	err = cfunc
557	n/a	for arg in cargs:
558	n/a	err += "%s, " % repr(arg)
559	n/a	err = err.rstrip(", ")
560	n/a	err += ")\n"
561	n/a
562	n/a	err += pfunc
563	n/a	for arg in pargs:
564	n/a	err += "%s, " % repr(arg)
565	n/a	err = err.rstrip(", ")
566	n/a	err += ")"
567	n/a
568	n/a	return err
569	n/a
570	n/a	def raise_error(t):
571	n/a	global EXIT_STATUS
572	n/a
573	n/a	if skip_error(t):
574	n/a	return
575	n/a	EXIT_STATUS = 1
576	n/a
577	n/a	err = "Error in %s:\n\n" % t.funcname
578	n/a	err += "input operands: %s\n\n" % (t.op,)
579	n/a	err += function_as_string(t)
580	n/a	err += "\n\nc_result: %s\np_result: %s\n\n" % (t.cresults, t.presults)
581	n/a	err += "c_exceptions: %s\np_exceptions: %s\n\n" % (t.cex, t.pex)
582	n/a	err += "%s\n\n" % str(t.context)
583	n/a
584	n/a	raise VerifyError(err)
585	n/a
586	n/a
587	n/a	# ======================================================================
588	n/a	# Main testing functions
589	n/a	#
590	n/a	# The procedure is always (t is the TestSet):
591	n/a	#
592	n/a	# convert(t) -> Initialize the TestSet as necessary.
593	n/a	#
594	n/a	# Return 0 for early abortion (e.g. if a TypeError
595	n/a	# occurs during conversion, there is nothing to test).
596	n/a	#
597	n/a	# Return 1 for continuing with the test case.
598	n/a	#
599	n/a	# callfuncs(t) -> Call the relevant function for each implementation
600	n/a	# and record the results in the TestSet.
601	n/a	#
602	n/a	# verify(t) -> Verify the results. If verification fails, details
603	n/a	# are printed to stdout.
604	n/a	# ======================================================================
605	n/a
606	n/a	def convert(t, convstr=True):
607	n/a	""" t is the testset. At this stage the testset contains a tuple of
608	n/a	operands t.op of various types. For decimal methods the first
609	n/a	operand (self) is always converted to Decimal. If 'convstr' is
610	n/a	true, string operands are converted as well.
611	n/a
612	n/a	Context operands are of type deccheck.Context, rounding mode
613	n/a	operands are given as a tuple (C.rounding, P.rounding).
614	n/a
615	n/a	Other types (float, int, etc.) are left unchanged.
616	n/a	"""
617	n/a	for i, op in enumerate(t.op):
618	n/a
619	n/a	context.clear_status()
620	n/a
621	n/a	if op in RoundModes:
622	n/a	t.cop.append(op)
623	n/a	t.pop.append(op)
624	n/a
625	n/a	elif not t.contextfunc and i == 0 or \
626	n/a	convstr and isinstance(op, str):
627	n/a	try:
628	n/a	c = C.Decimal(op)
629	n/a	cex = None
630	n/a	except (TypeError, ValueError, OverflowError) as e:
631	n/a	c = None
632	n/a	cex = e.__class__
633	n/a
634	n/a	try:
635	n/a	p = RestrictedDecimal(op)
636	n/a	pex = None
637	n/a	except (TypeError, ValueError, OverflowError) as e:
638	n/a	p = None
639	n/a	pex = e.__class__
640	n/a
641	n/a	t.cop.append(c)
642	n/a	t.cex.append(cex)
643	n/a	t.pop.append(p)
644	n/a	t.pex.append(pex)
645	n/a
646	n/a	if cex is pex:
647	n/a	if str(c) != str(p) or not context.assert_eq_status():
648	n/a	raise_error(t)
649	n/a	if cex and pex:
650	n/a	# nothing to test
651	n/a	return 0
652	n/a	else:
653	n/a	raise_error(t)
654	n/a
655	n/a	elif isinstance(op, Context):
656	n/a	t.context = op
657	n/a	t.cop.append(op.c)
658	n/a	t.pop.append(op.p)
659	n/a
660	n/a	else:
661	n/a	t.cop.append(op)
662	n/a	t.pop.append(op)
663	n/a
664	n/a	return 1
665	n/a
666	n/a	def callfuncs(t):
667	n/a	""" t is the testset. At this stage the testset contains operand lists
668	n/a	t.cop and t.pop for the C and Python versions of decimal.
669	n/a	For Decimal methods, the first operands are of type C.Decimal and
670	n/a	P.Decimal respectively. The remaining operands can have various types.
671	n/a	For Context methods, all operands can have any type.
672	n/a
673	n/a	t.rc and t.rp are the results of the operation.
674	n/a	"""
675	n/a	context.clear_status()
676	n/a
677	n/a	try:
678	n/a	if t.contextfunc:
679	n/a	cargs = t.cop
680	n/a	t.rc = getattr(context.c, t.funcname)(*cargs)
681	n/a	else:
682	n/a	cself = t.cop[0]
683	n/a	cargs = t.cop[1:]
684	n/a	t.rc = getattr(cself, t.funcname)(*cargs)
685	n/a	t.cex.append(None)
686	n/a	except (TypeError, ValueError, OverflowError, MemoryError) as e:
687	n/a	t.rc = None
688	n/a	t.cex.append(e.__class__)
689	n/a
690	n/a	try:
691	n/a	if t.contextfunc:
692	n/a	pargs = t.pop
693	n/a	t.rp = getattr(context.p, t.funcname)(*pargs)
694	n/a	else:
695	n/a	pself = t.pop[0]
696	n/a	pargs = t.pop[1:]
697	n/a	t.rp = getattr(pself, t.funcname)(*pargs)
698	n/a	t.pex.append(None)
699	n/a	except (TypeError, ValueError, OverflowError, MemoryError) as e:
700	n/a	t.rp = None
701	n/a	t.pex.append(e.__class__)
702	n/a
703	n/a	def verify(t, stat):
704	n/a	""" t is the testset. At this stage the testset contains the following
705	n/a	tuples:
706	n/a
707	n/a	t.op: original operands
708	n/a	t.cop: C.Decimal operands (see convert for details)
709	n/a	t.pop: P.Decimal operands (see convert for details)
710	n/a	t.rc: C result
711	n/a	t.rp: Python result
712	n/a
713	n/a	t.rc and t.rp can have various types.
714	n/a	"""
715	n/a	t.cresults.append(str(t.rc))
716	n/a	t.presults.append(str(t.rp))
717	n/a	if isinstance(t.rc, C.Decimal) and isinstance(t.rp, P.Decimal):
718	n/a	# General case: both results are Decimals.
719	n/a	t.cresults.append(t.rc.to_eng_string())
720	n/a	t.cresults.append(t.rc.as_tuple())
721	n/a	t.cresults.append(str(t.rc.imag))
722	n/a	t.cresults.append(str(t.rc.real))
723	n/a	t.presults.append(t.rp.to_eng_string())
724	n/a	t.presults.append(t.rp.as_tuple())
725	n/a	t.presults.append(str(t.rp.imag))
726	n/a	t.presults.append(str(t.rp.real))
727	n/a
728	n/a	nc = t.rc.number_class().lstrip('+-s')
729	n/a	stat[nc] += 1
730	n/a	else:
731	n/a	# Results from e.g. __divmod__ can only be compared as strings.
732	n/a	if not isinstance(t.rc, tuple) and not isinstance(t.rp, tuple):
733	n/a	if t.rc != t.rp:
734	n/a	raise_error(t)
735	n/a	stat[type(t.rc).__name__] += 1
736	n/a
737	n/a	# The return value lists must be equal.
738	n/a	if t.cresults != t.presults:
739	n/a	raise_error(t)
740	n/a	# The Python exception lists (TypeError, etc.) must be equal.
741	n/a	if t.cex != t.pex:
742	n/a	raise_error(t)
743	n/a	# The context flags must be equal.
744	n/a	if not t.context.assert_eq_status():
745	n/a	raise_error(t)
746	n/a
747	n/a
748	n/a	# ======================================================================
749	n/a	# Main test loops
750	n/a	#
751	n/a	# test_method(method, testspecs, testfunc) ->
752	n/a	#
753	n/a	# Loop through various context settings. The degree of
754	n/a	# thoroughness is determined by 'testspec'. For each
755	n/a	# setting, call 'testfunc'. Generally, 'testfunc' itself
756	n/a	# a loop, iterating through many test cases generated
757	n/a	# by the functions in randdec.py.
758	n/a	#
759	n/a	# test_n-ary(method, prec, exp_range, restricted_range, itr, stat) ->
760	n/a	#
761	n/a	# 'test_unary', 'test_binary' and 'test_ternary' are the
762	n/a	# main test functions passed to 'test_method'. They deal
763	n/a	# with the regular cases. The thoroughness of testing is
764	n/a	# determined by 'itr'.
765	n/a	#
766	n/a	# 'prec', 'exp_range' and 'restricted_range' are passed
767	n/a	# to the test-generating functions and limit the generated
768	n/a	# values. In some cases, for reasonable run times a
769	n/a	# maximum exponent of 9999 is required.
770	n/a	#
771	n/a	# The 'stat' parameter is passed down to the 'verify'
772	n/a	# function, which records statistics for the result values.
773	n/a	# ======================================================================
774	n/a
775	n/a	def log(fmt, args=None):
776	n/a	if args:
777	n/a	sys.stdout.write(''.join((fmt, '\n')) % args)
778	n/a	else:
779	n/a	sys.stdout.write(''.join((str(fmt), '\n')))
780	n/a	sys.stdout.flush()
781	n/a
782	n/a	def test_method(method, testspecs, testfunc):
783	n/a	"""Iterate a test function through many context settings."""
784	n/a	log("testing %s ...", method)
785	n/a	stat = defaultdict(int)
786	n/a	for spec in testspecs:
787	n/a	if 'samples' in spec:
788	n/a	spec['prec'] = sorted(random.sample(range(1, 101),
789	n/a	spec['samples']))
790	n/a	for prec in spec['prec']:
791	n/a	context.prec = prec
792	n/a	for expts in spec['expts']:
793	n/a	emin, emax = expts
794	n/a	if emin == 'rand':
795	n/a	context.Emin = random.randrange(-1000, 0)
796	n/a	context.Emax = random.randrange(prec, 1000)
797	n/a	else:
798	n/a	context.Emin, context.Emax = emin, emax
799	n/a	if prec > context.Emax: continue
800	n/a	log(" prec: %d emin: %d emax: %d",
801	n/a	(context.prec, context.Emin, context.Emax))
802	n/a	restr_range = 9999 if context.Emax > 9999 else context.Emax+99
803	n/a	for rounding in RoundModes:
804	n/a	context.rounding = rounding
805	n/a	context.capitals = random.randrange(2)
806	n/a	if spec['clamp'] == 'rand':
807	n/a	context.clamp = random.randrange(2)
808	n/a	else:
809	n/a	context.clamp = spec['clamp']
810	n/a	exprange = context.c.Emax
811	n/a	testfunc(method, prec, exprange, restr_range,
812	n/a	spec['iter'], stat)
813	n/a	log(" result types: %s" % sorted([t for t in stat.items()]))
814	n/a
815	n/a	def test_unary(method, prec, exp_range, restricted_range, itr, stat):
816	n/a	"""Iterate a unary function through many test cases."""
817	n/a	if method in UnaryRestricted:
818	n/a	exp_range = restricted_range
819	n/a	for op in all_unary(prec, exp_range, itr):
820	n/a	t = TestSet(method, op)
821	n/a	try:
822	n/a	if not convert(t):
823	n/a	continue
824	n/a	callfuncs(t)
825	n/a	verify(t, stat)
826	n/a	except VerifyError as err:
827	n/a	log(err)
828	n/a
829	n/a	if not method.startswith('__'):
830	n/a	for op in unary_optarg(prec, exp_range, itr):
831	n/a	t = TestSet(method, op)
832	n/a	try:
833	n/a	if not convert(t):
834	n/a	continue
835	n/a	callfuncs(t)
836	n/a	verify(t, stat)
837	n/a	except VerifyError as err:
838	n/a	log(err)
839	n/a
840	n/a	def test_binary(method, prec, exp_range, restricted_range, itr, stat):
841	n/a	"""Iterate a binary function through many test cases."""
842	n/a	if method in BinaryRestricted:
843	n/a	exp_range = restricted_range
844	n/a	for op in all_binary(prec, exp_range, itr):
845	n/a	t = TestSet(method, op)
846	n/a	try:
847	n/a	if not convert(t):
848	n/a	continue
849	n/a	callfuncs(t)
850	n/a	verify(t, stat)
851	n/a	except VerifyError as err:
852	n/a	log(err)
853	n/a
854	n/a	if not method.startswith('__'):
855	n/a	for op in binary_optarg(prec, exp_range, itr):
856	n/a	t = TestSet(method, op)
857	n/a	try:
858	n/a	if not convert(t):
859	n/a	continue
860	n/a	callfuncs(t)
861	n/a	verify(t, stat)
862	n/a	except VerifyError as err:
863	n/a	log(err)
864	n/a
865	n/a	def test_ternary(method, prec, exp_range, restricted_range, itr, stat):
866	n/a	"""Iterate a ternary function through many test cases."""
867	n/a	if method in TernaryRestricted:
868	n/a	exp_range = restricted_range
869	n/a	for op in all_ternary(prec, exp_range, itr):
870	n/a	t = TestSet(method, op)
871	n/a	try:
872	n/a	if not convert(t):
873	n/a	continue
874	n/a	callfuncs(t)
875	n/a	verify(t, stat)
876	n/a	except VerifyError as err:
877	n/a	log(err)
878	n/a
879	n/a	if not method.startswith('__'):
880	n/a	for op in ternary_optarg(prec, exp_range, itr):
881	n/a	t = TestSet(method, op)
882	n/a	try:
883	n/a	if not convert(t):
884	n/a	continue
885	n/a	callfuncs(t)
886	n/a	verify(t, stat)
887	n/a	except VerifyError as err:
888	n/a	log(err)
889	n/a
890	n/a	def test_format(method, prec, exp_range, restricted_range, itr, stat):
891	n/a	"""Iterate the __format__ method through many test cases."""
892	n/a	for op in all_unary(prec, exp_range, itr):
893	n/a	fmt1 = rand_format(chr(random.randrange(0, 128)), 'EeGgn')
894	n/a	fmt2 = rand_locale()
895	n/a	for fmt in (fmt1, fmt2):
896	n/a	fmtop = (op[0], fmt)
897	n/a	t = TestSet(method, fmtop)
898	n/a	try:
899	n/a	if not convert(t, convstr=False):
900	n/a	continue
901	n/a	callfuncs(t)
902	n/a	verify(t, stat)
903	n/a	except VerifyError as err:
904	n/a	log(err)
905	n/a	for op in all_unary(prec, 9999, itr):
906	n/a	fmt1 = rand_format(chr(random.randrange(0, 128)), 'Ff%')
907	n/a	fmt2 = rand_locale()
908	n/a	for fmt in (fmt1, fmt2):
909	n/a	fmtop = (op[0], fmt)
910	n/a	t = TestSet(method, fmtop)
911	n/a	try:
912	n/a	if not convert(t, convstr=False):
913	n/a	continue
914	n/a	callfuncs(t)
915	n/a	verify(t, stat)
916	n/a	except VerifyError as err:
917	n/a	log(err)
918	n/a
919	n/a	def test_round(method, prec, exprange, restricted_range, itr, stat):
920	n/a	"""Iterate the __round__ method through many test cases."""
921	n/a	for op in all_unary(prec, 9999, itr):
922	n/a	n = random.randrange(10)
923	n/a	roundop = (op[0], n)
924	n/a	t = TestSet(method, roundop)
925	n/a	try:
926	n/a	if not convert(t):
927	n/a	continue
928	n/a	callfuncs(t)
929	n/a	verify(t, stat)
930	n/a	except VerifyError as err:
931	n/a	log(err)
932	n/a
933	n/a	def test_from_float(method, prec, exprange, restricted_range, itr, stat):
934	n/a	"""Iterate the __float__ method through many test cases."""
935	n/a	for rounding in RoundModes:
936	n/a	context.rounding = rounding
937	n/a	for i in range(1000):
938	n/a	f = randfloat()
939	n/a	op = (f,) if method.startswith("context.") else ("sNaN", f)
940	n/a	t = TestSet(method, op)
941	n/a	try:
942	n/a	if not convert(t):
943	n/a	continue
944	n/a	callfuncs(t)
945	n/a	verify(t, stat)
946	n/a	except VerifyError as err:
947	n/a	log(err)
948	n/a
949	n/a	def randcontext(exprange):
950	n/a	c = Context(C.Context(), P.Context())
951	n/a	c.Emax = random.randrange(1, exprange+1)
952	n/a	c.Emin = random.randrange(-exprange, 0)
953	n/a	maxprec = 100 if c.Emax >= 100 else c.Emax
954	n/a	c.prec = random.randrange(1, maxprec+1)
955	n/a	c.clamp = random.randrange(2)
956	n/a	c.clear_traps()
957	n/a	return c
958	n/a
959	n/a	def test_quantize_api(method, prec, exprange, restricted_range, itr, stat):
960	n/a	"""Iterate the 'quantize' method through many test cases, using
961	n/a	the optional arguments."""
962	n/a	for op in all_binary(prec, restricted_range, itr):
963	n/a	for rounding in RoundModes:
964	n/a	c = randcontext(exprange)
965	n/a	quantizeop = (op[0], op[1], rounding, c)
966	n/a	t = TestSet(method, quantizeop)
967	n/a	try:
968	n/a	if not convert(t):
969	n/a	continue
970	n/a	callfuncs(t)
971	n/a	verify(t, stat)
972	n/a	except VerifyError as err:
973	n/a	log(err)
974	n/a
975	n/a
976	n/a	def check_untested(funcdict, c_cls, p_cls):
977	n/a	"""Determine untested, C-only and Python-only attributes.
978	n/a	Uncomment print lines for debugging."""
979	n/a	c_attr = set(dir(c_cls))
980	n/a	p_attr = set(dir(p_cls))
981	n/a	intersect = c_attr & p_attr
982	n/a
983	n/a	funcdict['c_only'] = tuple(sorted(c_attr-intersect))
984	n/a	funcdict['p_only'] = tuple(sorted(p_attr-intersect))
985	n/a
986	n/a	tested = set()
987	n/a	for lst in funcdict.values():
988	n/a	for v in lst:
989	n/a	v = v.replace("context.", "") if c_cls == C.Context else v
990	n/a	tested.add(v)
991	n/a
992	n/a	funcdict['untested'] = tuple(sorted(intersect-tested))
993	n/a
994	n/a	#for key in ('untested', 'c_only', 'p_only'):
995	n/a	# s = 'Context' if c_cls == C.Context else 'Decimal'
996	n/a	# print("\n%s %s:\n%s" % (s, key, funcdict[key]))
997	n/a
998	n/a
999	n/a	if __name__ == '__main__':
1000	n/a
1001	n/a	import time
1002	n/a
1003	n/a	randseed = int(time.time())
1004	n/a	random.seed(randseed)
1005	n/a
1006	n/a	# Set up the testspecs list. A testspec is simply a dictionary
1007	n/a	# that determines the amount of different contexts that 'test_method'
1008	n/a	# will generate.
1009	n/a	base_expts = [(C.MIN_EMIN, C.MAX_EMAX)]
1010	n/a	if C.MAX_EMAX == 999999999999999999:
1011	n/a	base_expts.append((-999999999, 999999999))
1012	n/a
1013	n/a	# Basic contexts.
1014	n/a	base = {
1015	n/a	'expts': base_expts,
1016	n/a	'prec': [],
1017	n/a	'clamp': 'rand',
1018	n/a	'iter': None,
1019	n/a	'samples': None,
1020	n/a	}
1021	n/a	# Contexts with small values for prec, emin, emax.
1022	n/a	small = {
1023	n/a	'prec': [1, 2, 3, 4, 5],
1024	n/a	'expts': [(-1, 1), (-2, 2), (-3, 3), (-4, 4), (-5, 5)],
1025	n/a	'clamp': 'rand',
1026	n/a	'iter': None
1027	n/a	}
1028	n/a	# IEEE interchange format.
1029	n/a	ieee = [
1030	n/a	# DECIMAL32
1031	n/a	{'prec': [7], 'expts': [(-95, 96)], 'clamp': 1, 'iter': None},
1032	n/a	# DECIMAL64
1033	n/a	{'prec': [16], 'expts': [(-383, 384)], 'clamp': 1, 'iter': None},
1034	n/a	# DECIMAL128
1035	n/a	{'prec': [34], 'expts': [(-6143, 6144)], 'clamp': 1, 'iter': None}
1036	n/a	]
1037	n/a
1038	n/a	if '--medium' in sys.argv:
1039	n/a	base['expts'].append(('rand', 'rand'))
1040	n/a	# 5 random precisions
1041	n/a	base['samples'] = 5
1042	n/a	testspecs = [small] + ieee + [base]
1043	n/a	if '--long' in sys.argv:
1044	n/a	base['expts'].append(('rand', 'rand'))
1045	n/a	# 10 random precisions
1046	n/a	base['samples'] = 10
1047	n/a	testspecs = [small] + ieee + [base]
1048	n/a	elif '--all' in sys.argv:
1049	n/a	base['expts'].append(('rand', 'rand'))
1050	n/a	# All precisions in [1, 100]
1051	n/a	base['samples'] = 100
1052	n/a	testspecs = [small] + ieee + [base]
1053	n/a	else: # --short
1054	n/a	rand_ieee = random.choice(ieee)
1055	n/a	base['iter'] = small['iter'] = rand_ieee['iter'] = 1
1056	n/a	# 1 random precision and exponent pair
1057	n/a	base['samples'] = 1
1058	n/a	base['expts'] = [random.choice(base_expts)]
1059	n/a	# 1 random precision and exponent pair
1060	n/a	prec = random.randrange(1, 6)
1061	n/a	small['prec'] = [prec]
1062	n/a	small['expts'] = [(-prec, prec)]
1063	n/a	testspecs = [small, rand_ieee, base]
1064	n/a
1065	n/a	check_untested(Functions, C.Decimal, P.Decimal)
1066	n/a	check_untested(ContextFunctions, C.Context, P.Context)
1067	n/a
1068	n/a
1069	n/a	log("\n\nRandom seed: %d\n\n", randseed)
1070	n/a
1071	n/a	# Decimal methods:
1072	n/a	for method in Functions['unary'] + Functions['unary_ctx'] + \
1073	n/a	Functions['unary_rnd_ctx']:
1074	n/a	test_method(method, testspecs, test_unary)
1075	n/a
1076	n/a	for method in Functions['binary'] + Functions['binary_ctx']:
1077	n/a	test_method(method, testspecs, test_binary)
1078	n/a
1079	n/a	for method in Functions['ternary'] + Functions['ternary_ctx']:
1080	n/a	test_method(method, testspecs, test_ternary)
1081	n/a
1082	n/a	test_method('__format__', testspecs, test_format)
1083	n/a	test_method('__round__', testspecs, test_round)
1084	n/a	test_method('from_float', testspecs, test_from_float)
1085	n/a	test_method('quantize', testspecs, test_quantize_api)
1086	n/a
1087	n/a	# Context methods:
1088	n/a	for method in ContextFunctions['unary']:
1089	n/a	test_method(method, testspecs, test_unary)
1090	n/a
1091	n/a	for method in ContextFunctions['binary']:
1092	n/a	test_method(method, testspecs, test_binary)
1093	n/a
1094	n/a	for method in ContextFunctions['ternary']:
1095	n/a	test_method(method, testspecs, test_ternary)
1096	n/a
1097	n/a	test_method('context.create_decimal_from_float', testspecs, test_from_float)
1098	n/a
1099	n/a
1100	n/a	sys.exit(EXIT_STATUS)