xfnw/plan9fox
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

remove python test cases

Browse source
This commit is contained in:
cinap_lenrek 2011-05-04 05:41:33 +00:00
parent 6c1b421882
commit b8436b026a
476 changed files with 0 additions and 133470 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
sys/lib/python/test/185test.db
View file

Binary file not shown.

423
sys/lib/python/test/README
View file

@ -1,423 +0,0 @@
+++++++++++++++++++++++++++++++
Writing Python Regression Tests
+++++++++++++++++++++++++++++++
:Author: Skip Montanaro
:Contact: skip@mojam.com
Introduction
============
If you add a new module to Python or modify the functionality of an existing
module, you should write one or more test cases to exercise that new
functionality. There are different ways to do this within the regression
testing facility provided with Python; any particular test should use only
one of these options. Each option requires writing a test module using the
conventions of the selected option:
- PyUnit_ based tests
- doctest_ based tests
- "traditional" Python test modules
Regardless of the mechanics of the testing approach you choose,
you will be writing unit tests (isolated tests of functions and objects
defined by the module) using white box techniques. Unlike black box
testing, where you only have the external interfaces to guide your test case
writing, in white box testing you can see the code being tested and tailor
your test cases to exercise it more completely. In particular, you will be
able to refer to the C and Python code in the CVS repository when writing
your regression test cases.
.. _PyUnit:
.. _unittest: http://www.python.org/doc/current/lib/module-unittest.html
.. _doctest: http://www.python.org/doc/current/lib/module-doctest.html
PyUnit based tests
------------------
The PyUnit_ framework is based on the ideas of unit testing as espoused
by Kent Beck and the `Extreme Programming`_ (XP) movement. The specific
interface provided by the framework is tightly based on the JUnit_
Java implementation of Beck's original SmallTalk test framework. Please
see the documentation of the unittest_ module for detailed information on
the interface and general guidelines on writing PyUnit based tests.
The test_support helper module provides two functions for use by
PyUnit based tests in the Python regression testing framework:
- ``run_unittest()`` takes a ``unittest.TestCase`` derived class as a
parameter and runs the tests defined in that class
- ``run_suite()`` takes a populated ``TestSuite`` instance and runs the
tests
``run_suite()`` is preferred because unittest files typically grow multiple
test classes, and you might as well be prepared.
All test methods in the Python regression framework have names that
start with "``test_``" and use lower-case names with words separated with
underscores.
Test methods should *not* have docstrings! The unittest module prints
the docstring if there is one, but otherwise prints the function name
and the full class name. When there's a problem with a test, the
latter information makes it easier to find the source for the test
than the docstring.
All PyUnit-based tests in the Python test suite use boilerplate that
looks like this (with minor variations)::
import unittest
from test import test_support
class MyTestCase1(unittest.TestCase):
# Define setUp and tearDown only if needed
def setUp(self):
unittest.TestCase.setUp(self)
... additional initialization...
def tearDown(self):
... additional finalization...
unittest.TestCase.tearDown(self)
def test_feature_one(self):
# Testing feature one
...unit test for feature one...
def test_feature_two(self):
# Testing feature two
...unit test for feature two...
...etc...
class MyTestCase2(unittest.TestCase):
...same structure as MyTestCase1...
...etc...
def test_main():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(MyTestCase1))
suite.addTest(unittest.makeSuite(MyTestCase2))
...add more suites...
test_support.run_suite(suite)
if __name__ == "__main__":
test_main()
This has the advantage that it allows the unittest module to be used
as a script to run individual tests as well as working well with the
regrtest framework.
.. _Extreme Programming: http://www.extremeprogramming.org/
.. _JUnit: http://www.junit.org/
doctest based tests
-------------------
Tests written to use doctest_ are actually part of the docstrings for
the module being tested. Each test is written as a display of an
interactive session, including the Python prompts, statements that would
be typed by the user, and the output of those statements (including
tracebacks, although only the exception msg needs to be retained then).
The module in the test package is simply a wrapper that causes doctest
to run over the tests in the module. The test for the difflib module
provides a convenient example::
import difflib
from test import test_support
test_support.run_doctest(difflib)
If the test is successful, nothing is written to stdout (so you should not
create a corresponding output/test_difflib file), but running regrtest
with -v will give a detailed report, the same as if passing -v to doctest.
A second argument can be passed to run_doctest to tell doctest to search
``sys.argv`` for -v instead of using test_support's idea of verbosity. This
is useful for writing doctest-based tests that aren't simply running a
doctest'ed Lib module, but contain the doctests themselves. Then at
times you may want to run such a test directly as a doctest, independent
of the regrtest framework. The tail end of test_descrtut.py is a good
example::
def test_main(verbose=None):
from test import test_support, test_descrtut
test_support.run_doctest(test_descrtut, verbose)
if __name__ == "__main__":
test_main(1)
If run via regrtest, ``test_main()`` is called (by regrtest) without
specifying verbose, and then test_support's idea of verbosity is used. But
when run directly, ``test_main(1)`` is called, and then doctest's idea of
verbosity is used.
See the documentation for the doctest module for information on
writing tests using the doctest framework.
"traditional" Python test modules
---------------------------------
The mechanics of how the "traditional" test system operates are fairly
straightforward. When a test case is run, the output is compared with the
expected output that is stored in .../Lib/test/output. If the test runs to
completion and the actual and expected outputs match, the test succeeds, if
not, it fails. If an ``ImportError`` or ``test_support.TestSkipped`` error
is raised, the test is not run.
Executing Test Cases
====================
If you are writing test cases for module spam, you need to create a file
in .../Lib/test named test_spam.py. In addition, if the tests are expected
to write to stdout during a successful run, you also need to create an
expected output file in .../Lib/test/output named test_spam ("..."
represents the top-level directory in the Python source tree, the directory
containing the configure script). If needed, generate the initial version
of the test output file by executing::
./python Lib/test/regrtest.py -g test_spam.py
from the top-level directory.
Any time you modify test_spam.py you need to generate a new expected
output file. Don't forget to desk check the generated output to make sure
it's really what you expected to find! All in all it's usually better
not to have an expected-out file (note that doctest- and unittest-based
tests do not).
To run a single test after modifying a module, simply run regrtest.py
without the -g flag::
./python Lib/test/regrtest.py test_spam.py
While debugging a regression test, you can of course execute it
independently of the regression testing framework and see what it prints::
./python Lib/test/test_spam.py
To run the entire test suite:
- [UNIX, + other platforms where "make" works] Make the "test" target at the
top level::
make test
- [WINDOWS] Run rt.bat from your PCBuild directory. Read the comments at
the top of rt.bat for the use of special -d, -O and -q options processed
by rt.bat.
- [OTHER] You can simply execute the two runs of regrtest (optimized and
non-optimized) directly::
./python Lib/test/regrtest.py
./python -O Lib/test/regrtest.py
But note that this way picks up whatever .pyc and .pyo files happen to be
around. The makefile and rt.bat ways run the tests twice, the first time
removing all .pyc and .pyo files from the subtree rooted at Lib/.
Test cases generate output based upon values computed by the test code.
When executed, regrtest.py compares the actual output generated by executing
the test case with the expected output and reports success or failure. It
stands to reason that if the actual and expected outputs are to match, they
must not contain any machine dependencies. This means your test cases
should not print out absolute machine addresses (e.g. the return value of
the id() builtin function) or floating point numbers with large numbers of
significant digits (unless you understand what you are doing!).
Test Case Writing Tips
======================
Writing good test cases is a skilled task and is too complex to discuss in
detail in this short document. Many books have been written on the subject.
I'll show my age by suggesting that Glenford Myers' `"The Art of Software
Testing"`_, published in 1979, is still the best introduction to the subject
available. It is short (177 pages), easy to read, and discusses the major
elements of software testing, though its publication predates the
object-oriented software revolution, so doesn't cover that subject at all.
Unfortunately, it is very expensive (about $100 new). If you can borrow it
or find it used (around $20), I strongly urge you to pick up a copy.
The most important goal when writing test cases is to break things. A test
case that doesn't uncover a bug is much less valuable than one that does.
In designing test cases you should pay attention to the following:
* Your test cases should exercise all the functions and objects defined
in the module, not just the ones meant to be called by users of your
module. This may require you to write test code that uses the module
in ways you don't expect (explicitly calling internal functions, for
example - see test_atexit.py).
* You should consider any boundary values that may tickle exceptional
conditions (e.g. if you were writing regression tests for division,
you might well want to generate tests with numerators and denominators
at the limits of floating point and integer numbers on the machine
performing the tests as well as a denominator of zero).
* You should exercise as many paths through the code as possible. This
may not always be possible, but is a goal to strive for. In
particular, when considering if statements (or their equivalent), you
want to create test cases that exercise both the true and false
branches. For loops, you should create test cases that exercise the
loop zero, one and multiple times.
* You should test with obviously invalid input. If you know that a
function requires an integer input, try calling it with other types of
objects to see how it responds.
* You should test with obviously out-of-range input. If the domain of a
function is only defined for positive integers, try calling it with a
negative integer.
* If you are going to fix a bug that wasn't uncovered by an existing
test, try to write a test case that exposes the bug (preferably before
fixing it).
* If you need to create a temporary file, you can use the filename in
``test_support.TESTFN`` to do so. It is important to remove the file
when done; other tests should be able to use the name without cleaning
up after your test.
.. _"The Art of Software Testing":
http://www.amazon.com/exec/obidos/ISBN=0471043281
Regression Test Writing Rules
=============================
Each test case is different. There is no "standard" form for a Python
regression test case, though there are some general rules (note that
these mostly apply only to the "classic" tests; unittest_- and doctest_-
based tests should follow the conventions natural to those frameworks)::
* If your test case detects a failure, raise ``TestFailed`` (found in
``test.test_support``).
* Import everything you'll need as early as possible.
* If you'll be importing objects from a module that is at least
partially platform-dependent, only import those objects you need for
the current test case to avoid spurious ``ImportError`` exceptions
that prevent the test from running to completion.
* Print all your test case results using the ``print`` statement. For
non-fatal errors, print an error message (or omit a successful
completion print) to indicate the failure, but proceed instead of
raising ``TestFailed``.
* Use ``assert`` sparingly, if at all. It's usually better to just print
what you got, and rely on regrtest's got-vs-expected comparison to
catch deviations from what you expect. ``assert`` statements aren't
executed at all when regrtest is run in -O mode; and, because they
cause the test to stop immediately, can lead to a long & tedious
test-fix, test-fix, test-fix, ... cycle when things are badly broken
(and note that "badly broken" often includes running the test suite
for the first time on new platforms or under new implementations of
the language).
Miscellaneous
=============
There is a test_support module in the test package you can import for
your test case. Import this module using either::
import test.test_support
or::
from test import test_support
test_support provides the following useful objects:
* ``TestFailed`` - raise this exception when your regression test detects
a failure.
* ``TestSkipped`` - raise this if the test could not be run because the
platform doesn't offer all the required facilities (like large
file support), even if all the required modules are available.
* ``ResourceDenied`` - this is raised when a test requires a resource that
is not available. Primarily used by 'requires'.
* ``verbose`` - you can use this variable to control print output. Many
modules use it. Search for "verbose" in the test_*.py files to see
lots of examples.
* ``forget(module_name)`` - attempts to cause Python to "forget" that it
loaded a module and erase any PYC files.
* ``is_resource_enabled(resource)`` - Returns a boolean based on whether
the resource is enabled or not.
* ``requires(resource [, msg])`` - if the required resource is not
available the ResourceDenied exception is raised.
* ``verify(condition, reason='test failed')``. Use this instead of::
assert condition[, reason]
``verify()`` has two advantages over ``assert``: it works even in -O
mode, and it raises ``TestFailed`` on failure instead of
``AssertionError``.
* ``have_unicode`` - true if Unicode is available, false otherwise.
* ``is_jython`` - true if the interpreter is Jython, false otherwise.
* ``TESTFN`` - a string that should always be used as the filename when
you need to create a temp file. Also use ``try``/``finally`` to
ensure that your temp files are deleted before your test completes.
Note that you cannot unlink an open file on all operating systems, so
also be sure to close temp files before trying to unlink them.
* ``sortdict(dict)`` - acts like ``repr(dict.items())``, but sorts the
items first. This is important when printing a dict value, because
the order of items produced by ``dict.items()`` is not defined by the
language.
* ``findfile(file)`` - you can call this function to locate a file
somewhere along sys.path or in the Lib/test tree - see
test_linuxaudiodev.py for an example of its use.
* ``fcmp(x,y)`` - you can call this function to compare two floating
point numbers when you expect them to only be approximately equal
withing a fuzz factor (``test_support.FUZZ``, which defaults to 1e-6).
* ``check_syntax(statement)`` - make sure that the statement is *not*
correct Python syntax.
Python and C statement coverage results are currently available at
http://www.musi-cal.com/~skip/python/Python/dist/src/
As of this writing (July, 2000) these results are being generated nightly.
You can refer to the summaries and the test coverage output files to see
where coverage is adequate or lacking and write test cases to beef up the
coverage.
Some Non-Obvious regrtest Features
==================================
* Automagic test detection: When you create a new test file
test_spam.py, you do not need to modify regrtest (or anything else)
to advertise its existence. regrtest searches for and runs all
modules in the test directory with names of the form test_xxx.py.
* Miranda output: If, when running test_spam.py, regrtest does not
find an expected-output file test/output/test_spam, regrtest
pretends that it did find one, containing the single line
test_spam
This allows new tests that don't expect to print anything to stdout
to not bother creating expected-output files.
* Two-stage testing: To run test_spam.py, regrtest imports test_spam
as a module. Most tests run to completion as a side-effect of
getting imported. After importing test_spam, regrtest also executes
``test_spam.test_main()``, if test_spam has a ``test_main`` attribute.
This is rarely required with the "traditional" Python tests, and
you shouldn't create a module global with name test_main unless
you're specifically exploiting this gimmick. This usage does
prove useful with PyUnit-based tests as well, however; defining
a ``test_main()`` which is run by regrtest and a script-stub in the
test module ("``if __name__ == '__main__': test_main()``") allows
the test to be used like any other Python test and also work
with the unittest.py-as-a-script approach, allowing a developer
to run specific tests from the command line.

1
sys/lib/python/test/__init__.py
View file

@ -1 +0,0 @@
# Dummy file to make this directory a package.

BIN
sys/lib/python/test/audiotest.au
View file

Binary file not shown.

6
sys/lib/python/test/autotest.py
View file

@ -1,6 +0,0 @@
# This should be equivalent to running regrtest.py from the cmdline.
# It can be especially handy if you're in an interactive shell, e.g.,
# from test import autotest.
from test import regrtest
regrtest.main()

1
sys/lib/python/test/bad_coding.py
View file

@ -1 +0,0 @@
# -*- coding: uft-8 -*-

2
sys/lib/python/test/bad_coding2.py
View file

@ -1,2 +0,0 @@
#coding: utf8
print '我'

10
sys/lib/python/test/badsyntax_future3.py
View file

@ -1,10 +0,0 @@
"""This is a test"""
from __future__ import nested_scopes
from __future__ import rested_snopes
def f(x):
def g(y):
return x + y
return g
result = f(2)(4)

10
sys/lib/python/test/badsyntax_future4.py
View file

@ -1,10 +0,0 @@
"""This is a test"""
import __future__
from __future__ import nested_scopes
def f(x):
def g(y):
return x + y
return g
result = f(2)(4)

12
sys/lib/python/test/badsyntax_future5.py
View file

@ -1,12 +0,0 @@
"""This is a test"""
from __future__ import nested_scopes
import foo
from __future__ import nested_scopes
def f(x):
def g(y):
return x + y
return g
result = f(2)(4)

10
sys/lib/python/test/badsyntax_future6.py
View file

@ -1,10 +0,0 @@
"""This is a test"""
"this isn't a doc string"
from __future__ import nested_scopes
def f(x):
def g(y):
return x + y
return g
result = f(2)(4)

11
sys/lib/python/test/badsyntax_future7.py
View file

@ -1,11 +0,0 @@
"""This is a test"""
from __future__ import nested_scopes; import string; from __future__ import \
nested_scopes
def f(x):
def g(y):
return x + y
return g
result = f(2)(4)

10
sys/lib/python/test/badsyntax_future8.py
View file

@ -1,10 +0,0 @@
"""This is a test"""
from __future__ import *
def f(x):
def g(y):
return x + y
return g
print f(2)(4)

10
sys/lib/python/test/badsyntax_future9.py
View file

@ -1,10 +0,0 @@
"""This is a test"""
from __future__ import nested_scopes, braces
def f(x):
def g(y):
return x + y
return g
print f(2)(4)

2
sys/lib/python/test/badsyntax_nocaret.py
View file

@ -1,2 +0,0 @@
def f(x):
[x for x in x] = x

13
sys/lib/python/test/check_soundcard.vbs
View file

@ -1,13 +0,0 @@
rem Check for a working sound-card - exit with 0 if OK, 1 otherwise.
set wmi = GetObject("winmgmts:")
set scs = wmi.InstancesOf("win32_sounddevice")
for each sc in scs
set status = sc.Properties_("Status")
wscript.Echo(sc.Properties_("Name") + "/" + status)
if status = "OK" then
wscript.Quit 0 rem normal exit
end if
next
rem No sound card found - exit with status code of 1
wscript.Quit 1

1004
sys/lib/python/test/cjkencodings_test.py
View file

File diff suppressed because it is too large Load diff

20
sys/lib/python/test/crashers/README
View file

@ -1,20 +0,0 @@
This directory only contains tests for outstanding bugs that cause
the interpreter to segfault. Ideally this directory should always
be empty. Sometimes it may not be easy to fix the underlying cause.
Each test should fail when run from the command line:
./python Lib/test/crashers/weakref_in_del.py
Each test should have a link to the bug report:
# http://python.org/sf/BUG#
Put as much info into a docstring or comments to help determine
the cause of the failure. Particularly note if the cause is
system or environment dependent and what the variables are.
Once the crash is fixed, the test case should be moved into an appropriate
test (even if it was originally from the test suite). This ensures the
regression doesn't happen again. And if it does, it should be easier
to track down.

19
sys/lib/python/test/crashers/bogus_code_obj.py
View file

@ -1,19 +0,0 @@
"""
Broken bytecode objects can easily crash the interpreter.
This is not going to be fixed. It is generally agreed that there is no
point in writing a bytecode verifier and putting it in CPython just for
this. Moreover, a verifier is bound to accept only a subset of all safe
bytecodes, so it could lead to unnecessary breakage.
For security purposes, "restricted" interpreters are not going to let
the user build or load random bytecodes anyway. Otherwise, this is a
"won't fix" case.
"""
import types
co = types.CodeType(0, 0, 0, 0, '\x04\x71\x00\x00', (),
(), (), '', '', 1, '')
exec co

29
sys/lib/python/test/crashers/borrowed_ref_1.py
View file

@ -1,29 +0,0 @@
"""
_PyType_Lookup() returns a borrowed reference.
This attacks the call in dictobject.c.
"""
class A(object):
pass
class B(object):
def __del__(self):
print 'hi'
del D.__missing__
class D(dict):
class __missing__:
def __init__(self, *args):
pass
d = D()
a = A()
a.cycle = a
a.other = B()
del a
prev = None
while 1:
d[5]
prev = (prev,)

38
sys/lib/python/test/crashers/borrowed_ref_2.py
View file

@ -1,38 +0,0 @@
"""
_PyType_Lookup() returns a borrowed reference.
This attacks PyObject_GenericSetAttr().
NB. on my machine this crashes in 2.5 debug but not release.
"""
class A(object):
pass
class B(object):
def __del__(self):
print "hi"
del C.d
class D(object):
def __set__(self, obj, value):
self.hello = 42
class C(object):
d = D()
def g():
pass
c = C()
a = A()
a.cycle = a
a.other = B()
lst = [None] * 1000000
i = 0
del a
while 1:
c.d = 42 # segfaults in PyMethod_New(im_func=D.__set__, im_self=d)
lst[i] = c.g # consume the free list of instancemethod objects
i += 1

12
sys/lib/python/test/crashers/dangerous_subclassing.py
View file

@ -1,12 +0,0 @@
# http://python.org/sf/1174712
import types
class X(types.ModuleType, str):
"""Such a subclassing is incorrectly allowed --
see the SF bug report for explanations"""
if __name__ == '__main__':
X('name') # segfault: ModuleType.__init__() reads
# the dict at the wrong offset

32
sys/lib/python/test/crashers/gc_inspection.py
View file

@ -1,32 +0,0 @@
"""
gc.get_referrers() can be used to see objects before they are fully built.
Note that this is only an example. There are many ways to crash Python
by using gc.get_referrers(), as well as many extension modules (even
when they are using perfectly documented patterns to build objects).
Identifying and removing all places that expose to the GC a
partially-built object is a long-term project. A patch was proposed on
SF specifically for this example but I consider fixing just this single
example a bit pointless (#1517042).
A fix would include a whole-scale code review, possibly with an API
change to decouple object creation and GC registration, and according
fixes to the documentation for extension module writers. It's unlikely
to happen, though. So this is currently classified as
"gc.get_referrers() is dangerous, use only for debugging".
"""
import gc
def g():
marker = object()
yield marker
# now the marker is in the tuple being constructed
[tup] = [x for x in gc.get_referrers(marker) if type(x) is tuple]
print tup
print tup[1]
tuple(g())

11
sys/lib/python/test/crashers/infinite_rec_1.py
View file

@ -1,11 +0,0 @@
# http://python.org/sf/1202533
import new, operator
class A:
pass
A.__mul__ = new.instancemethod(operator.mul, None, A)
if __name__ == '__main__':
A()*2 # segfault: infinite recursion in C

10
sys/lib/python/test/crashers/infinite_rec_2.py
View file

@ -1,10 +0,0 @@
# http://python.org/sf/1202533
class A(str):
__get__ = getattr
if __name__ == '__main__':
a = A('a')
A.a = a
a.a # segfault: infinite recursion in C

7
sys/lib/python/test/crashers/infinite_rec_4.py
View file

@ -1,7 +0,0 @@
# http://python.org/sf/1202533
if __name__ == '__main__':
lst = [apply]
lst.append(lst)
apply(*lst) # segfault: infinite recursion in C

10
sys/lib/python/test/crashers/infinite_rec_5.py
View file

@ -1,10 +0,0 @@
# http://python.org/sf/1267884
import types
class C:
__str__ = types.InstanceType.__str__
if __name__ == '__main__':
str(C()) # segfault: infinite recursion in C

21
sys/lib/python/test/crashers/loosing_dict_ref.py
View file

@ -1,21 +0,0 @@
# http://python.org/sf/1303614
class Strange(object):
def __hash__(self):
return hash('hello')
def __eq__(self, other):
x.__dict__ = {} # the old x.__dict__ is deallocated
return False
class X(object):
pass
if __name__ == '__main__':
v = 123
x = X()
x.__dict__ = {Strange(): 42,
'hello': v+456}
x.hello # segfault: the above dict is accessed after it's deallocated

19
sys/lib/python/test/crashers/modify_dict_attr.py
View file

@ -1,19 +0,0 @@
# http://python.org/sf/1303614
class Y(object):
pass
class type_with_modifiable_dict(Y, type):
pass
class MyClass(object):
"""This class has its __dict__ attribute completely exposed:
user code can read, reassign and even delete it.
"""
__metaclass__ = type_with_modifiable_dict
if __name__ == '__main__':
del MyClass.__dict__ # if we set tp_dict to NULL,
print MyClass # doing anything with MyClass segfaults

47
sys/lib/python/test/crashers/nasty_eq_vs_dict.py
View file

@ -1,47 +0,0 @@
# from http://mail.python.org/pipermail/python-dev/2001-June/015239.html
# if you keep changing a dictionary while looking up a key, you can
# provoke an infinite recursion in C
# At the time neither Tim nor Michael could be bothered to think of a
# way to fix it.
class Yuck:
def __init__(self):
self.i = 0
def make_dangerous(self):
self.i = 1
def __hash__(self):
# direct to slot 4 in table of size 8; slot 12 when size 16
return 4 + 8
def __eq__(self, other):
if self.i == 0:
# leave dict alone
pass
elif self.i == 1:
# fiddle to 16 slots
self.__fill_dict(6)
self.i = 2
else:
# fiddle to 8 slots
self.__fill_dict(4)
self.i = 1
return 1
def __fill_dict(self, n):
self.i = 0
dict.clear()
for i in range(n):
dict[i] = i
dict[self] = "OK!"
y = Yuck()
dict = {y: "OK!"}
z = Yuck()
y.make_dangerous()
print dict[z]

16
sys/lib/python/test/crashers/recursion_limit_too_high.py
View file

@ -1,16 +0,0 @@
# The following example may crash or not depending on the platform.
# E.g. on 32-bit Intel Linux in a "standard" configuration it seems to
# crash on Python 2.5 (but not 2.4 nor 2.3). On Windows the import
# eventually fails to find the module, possibly because we run out of
# file handles.
# The point of this example is to show that sys.setrecursionlimit() is a
# hack, and not a robust solution. This example simply exercices a path
# where it takes many C-level recursions, consuming a lot of stack
# space, for each Python-level recursion. So 1000 times this amount of
# stack space may be too much for standard platforms already.
import sys
if 'recursion_limit_too_high' in sys.modules:
del sys.modules['recursion_limit_too_high']
import recursion_limit_too_high

15
sys/lib/python/test/crashers/recursive_call.py
View file

@ -1,15 +0,0 @@
#!/usr/bin/env python
# No bug report AFAIK, mail on python-dev on 2006-01-10
# This is a "won't fix" case. It is known that setting a high enough
# recursion limit crashes by overflowing the stack. Unless this is
# redesigned somehow, it won't go away.
import sys
sys.setrecursionlimit(1 << 30)
f = lambda f:f(f)
if __name__ == '__main__':
f(f)

17
sys/lib/python/test/crashers/weakref_in_del.py
View file

@ -1,17 +0,0 @@
import weakref
# http://python.org/sf/1377858
# Fixed for new-style classes in 2.5c1.
ref = None
def test_weakref_in_del():
class Target():
def __del__(self):
global ref
ref = weakref.ref(self)
w = Target()
if __name__ == '__main__':
test_weakref_in_del()

161
sys/lib/python/test/decimaltestdata/abs.decTest
View file

@ -1,161 +0,0 @@
------------------------------------------------------------------------
-- abs.decTest -- decimal absolute value --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- This set of tests primarily tests the existence of the operator.
-- Additon, subtraction, rounding, and more overflows are tested
-- elsewhere.
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
extended: 1
absx001 abs '1' -> '1'
absx002 abs '-1' -> '1'
absx003 abs '1.00' -> '1.00'
absx004 abs '-1.00' -> '1.00'
absx005 abs '0' -> '0'
absx006 abs '0.00' -> '0.00'
absx007 abs '00.0' -> '0.0'
absx008 abs '00.00' -> '0.00'
absx009 abs '00' -> '0'
absx010 abs '-2' -> '2'
absx011 abs '2' -> '2'
absx012 abs '-2.00' -> '2.00'
absx013 abs '2.00' -> '2.00'
absx014 abs '-0' -> '0'
absx015 abs '-0.00' -> '0.00'
absx016 abs '-00.0' -> '0.0'
absx017 abs '-00.00' -> '0.00'
absx018 abs '-00' -> '0'
absx020 abs '-2000000' -> '2000000'
absx021 abs '2000000' -> '2000000'
precision: 7
absx022 abs '-2000000' -> '2000000'
absx023 abs '2000000' -> '2000000'
precision: 6
absx024 abs '-2000000' -> '2.00000E+6' Rounded
absx025 abs '2000000' -> '2.00000E+6' Rounded
precision: 3
absx026 abs '-2000000' -> '2.00E+6' Rounded
absx027 abs '2000000' -> '2.00E+6' Rounded
absx030 abs '+0.1' -> '0.1'
absx031 abs '-0.1' -> '0.1'
absx032 abs '+0.01' -> '0.01'
absx033 abs '-0.01' -> '0.01'
absx034 abs '+0.001' -> '0.001'
absx035 abs '-0.001' -> '0.001'
absx036 abs '+0.000001' -> '0.000001'
absx037 abs '-0.000001' -> '0.000001'
absx038 abs '+0.000000000001' -> '1E-12'
absx039 abs '-0.000000000001' -> '1E-12'
-- examples from decArith
precision: 9
absx040 abs '2.1' -> '2.1'
absx041 abs '-100' -> '100'
absx042 abs '101.5' -> '101.5'
absx043 abs '-101.5' -> '101.5'
-- more fixed, potential LHS swaps/overlays if done by subtract 0
precision: 9
absx060 abs '-56267E-10' -> '0.0000056267'
absx061 abs '-56267E-5' -> '0.56267'
absx062 abs '-56267E-2' -> '562.67'
absx063 abs '-56267E-1' -> '5626.7'
absx065 abs '-56267E-0' -> '56267'
-- overflow tests
maxexponent: 999999999
minexponent: -999999999
precision: 3
absx120 abs 9.999E+999999999 -> Infinity Inexact Overflow Rounded
-- subnormals and underflow
precision: 3
maxexponent: 999
minexponent: -999
absx210 abs 1.00E-999 -> 1.00E-999
absx211 abs 0.1E-999 -> 1E-1000 Subnormal
absx212 abs 0.10E-999 -> 1.0E-1000 Subnormal
absx213 abs 0.100E-999 -> 1.0E-1000 Subnormal Rounded
absx214 abs 0.01E-999 -> 1E-1001 Subnormal
-- next is rounded to Emin
absx215 abs 0.999E-999 -> 1.00E-999 Inexact Rounded Subnormal Underflow
absx216 abs 0.099E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow
absx217 abs 0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow
absx218 abs 0.001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
absx219 abs 0.0009E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
absx220 abs 0.0001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
absx230 abs -1.00E-999 -> 1.00E-999
absx231 abs -0.1E-999 -> 1E-1000 Subnormal
absx232 abs -0.10E-999 -> 1.0E-1000 Subnormal
absx233 abs -0.100E-999 -> 1.0E-1000 Subnormal Rounded
absx234 abs -0.01E-999 -> 1E-1001 Subnormal
-- next is rounded to Emin
absx235 abs -0.999E-999 -> 1.00E-999 Inexact Rounded Subnormal Underflow
absx236 abs -0.099E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow
absx237 abs -0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow
absx238 abs -0.001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
absx239 abs -0.0009E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
absx240 abs -0.0001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
-- long operand tests
maxexponent: 999
minexponent: -999
precision: 9
absx301 abs 12345678000 -> 1.23456780E+10 Rounded
absx302 abs 1234567800 -> 1.23456780E+9 Rounded
absx303 abs 1234567890 -> 1.23456789E+9 Rounded
absx304 abs 1234567891 -> 1.23456789E+9 Inexact Rounded
absx305 abs 12345678901 -> 1.23456789E+10 Inexact Rounded
absx306 abs 1234567896 -> 1.23456790E+9 Inexact Rounded
precision: 15
absx321 abs 12345678000 -> 12345678000
absx322 abs 1234567800 -> 1234567800
absx323 abs 1234567890 -> 1234567890
absx324 abs 1234567891 -> 1234567891
absx325 abs 12345678901 -> 12345678901
absx326 abs 1234567896 -> 1234567896
-- Specials
precision: 9
-- specials
absx520 abs 'Inf' -> 'Infinity'
absx521 abs '-Inf' -> 'Infinity'
absx522 abs NaN -> NaN
absx523 abs sNaN -> NaN Invalid_operation
absx524 abs NaN22 -> NaN22
absx525 abs sNaN33 -> NaN33 Invalid_operation
absx526 abs -NaN22 -> -NaN22
absx527 abs -sNaN33 -> -NaN33 Invalid_operation
-- Null tests
absx900 abs # -> NaN Invalid_operation

1127
sys/lib/python/test/decimaltestdata/add.decTest
View file

File diff suppressed because it is too large Load diff

1272
sys/lib/python/test/decimaltestdata/base.decTest
View file

File diff suppressed because it is too large Load diff

197
sys/lib/python/test/decimaltestdata/clamp.decTest
View file

@ -1,197 +0,0 @@
------------------------------------------------------------------------
-- clamp.decTest -- clamped exponent tests (format-independent) --
-- Copyright (c) IBM Corporation, 2000, 2003. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- This set of tests uses the same limits as the 8-byte concrete
-- representation, but applies clamping without using format-specific
-- conversions.
extended: 1
precision: 16
rounding: half_even
maxExponent: 384
minExponent: -383
clamp: 1
-- General testcases
-- Normality
clam010 apply 1234567890123456 -> 1234567890123456
clam011 apply 1234567890123456.0 -> 1234567890123456 Rounded
clam012 apply 1234567890123456.1 -> 1234567890123456 Rounded Inexact
clam013 apply -1234567890123456 -> -1234567890123456
clam014 apply -1234567890123456.0 -> -1234567890123456 Rounded
clam015 apply -1234567890123456.1 -> -1234567890123456 Rounded Inexact
-- Nmax and similar
clam022 apply 9.999999999999999E+384 -> 9.999999999999999E+384
clam024 apply 1.234567890123456E+384 -> 1.234567890123456E+384
-- fold-downs (more below)
clam030 apply 1.23E+384 -> 1.230000000000000E+384 Clamped
clam032 apply 1E+384 -> 1.000000000000000E+384 Clamped
clam051 apply 12345 -> 12345
clam053 apply 1234 -> 1234
clam055 apply 123 -> 123
clam057 apply 12 -> 12
clam059 apply 1 -> 1
clam061 apply 1.23 -> 1.23
clam063 apply 123.45 -> 123.45
-- Nmin and below
clam071 apply 1E-383 -> 1E-383
clam073 apply 1.000000000000000E-383 -> 1.000000000000000E-383
clam075 apply 1.000000000000001E-383 -> 1.000000000000001E-383
clam077 apply 0.100000000000000E-383 -> 1.00000000000000E-384 Subnormal
clam079 apply 0.000000000000010E-383 -> 1.0E-397 Subnormal
clam081 apply 0.00000000000001E-383 -> 1E-397 Subnormal
clam083 apply 0.000000000000001E-383 -> 1E-398 Subnormal
-- underflows
clam090 apply 1e-398 -> #0000000000000001 Subnormal
clam091 apply 1.9e-398 -> #0000000000000002 Subnormal Underflow Inexact Rounded
clam092 apply 1.1e-398 -> #0000000000000001 Subnormal Underflow Inexact Rounded
clam093 apply 1.00000000001e-398 -> #0000000000000001 Subnormal Underflow Inexact Rounded
clam094 apply 1.00000000000001e-398 -> #0000000000000001 Subnormal Underflow Inexact Rounded
clam095 apply 1.000000000000001e-398 -> #0000000000000001 Subnormal Underflow Inexact Rounded
clam096 apply 0.1e-398 -> #0000000000000000 Subnormal Underflow Inexact Rounded
clam097 apply 0.00000000001e-398 -> #0000000000000000 Subnormal Underflow Inexact Rounded
clam098 apply 0.00000000000001e-398 -> #0000000000000000 Subnormal Underflow Inexact Rounded
clam099 apply 0.000000000000001e-398 -> #0000000000000000 Subnormal Underflow Inexact Rounded
-- Same again, negatives
-- Nmax and similar
clam122 apply -9.999999999999999E+384 -> -9.999999999999999E+384
clam124 apply -1.234567890123456E+384 -> -1.234567890123456E+384
-- fold-downs (more below)
clam130 apply -1.23E+384 -> -1.230000000000000E+384 Clamped
clam132 apply -1E+384 -> -1.000000000000000E+384 Clamped
clam151 apply -12345 -> -12345
clam153 apply -1234 -> -1234
clam155 apply -123 -> -123
clam157 apply -12 -> -12
clam159 apply -1 -> -1
clam161 apply -1.23 -> -1.23
clam163 apply -123.45 -> -123.45
-- Nmin and below
clam171 apply -1E-383 -> -1E-383
clam173 apply -1.000000000000000E-383 -> -1.000000000000000E-383
clam175 apply -1.000000000000001E-383 -> -1.000000000000001E-383
clam177 apply -0.100000000000000E-383 -> -1.00000000000000E-384 Subnormal
clam179 apply -0.000000000000010E-383 -> -1.0E-397 Subnormal
clam181 apply -0.00000000000001E-383 -> -1E-397 Subnormal
clam183 apply -0.000000000000001E-383 -> -1E-398 Subnormal
-- underflows
clam189 apply -1e-398 -> #8000000000000001 Subnormal
clam190 apply -1.0e-398 -> #8000000000000001 Subnormal Rounded
clam191 apply -1.9e-398 -> #8000000000000002 Subnormal Underflow Inexact Rounded
clam192 apply -1.1e-398 -> #8000000000000001 Subnormal Underflow Inexact Rounded
clam193 apply -1.00000000001e-398 -> #8000000000000001 Subnormal Underflow Inexact Rounded
clam194 apply -1.00000000000001e-398 -> #8000000000000001 Subnormal Underflow Inexact Rounded
clam195 apply -1.000000000000001e-398 -> #8000000000000001 Subnormal Underflow Inexact Rounded
clam196 apply -0.1e-398 -> #8000000000000000 Subnormal Underflow Inexact Rounded
clam197 apply -0.00000000001e-398 -> #8000000000000000 Subnormal Underflow Inexact Rounded
clam198 apply -0.00000000000001e-398 -> #8000000000000000 Subnormal Underflow Inexact Rounded
clam199 apply -0.000000000000001e-398 -> #8000000000000000 Subnormal Underflow Inexact Rounded
-- zeros
clam401 apply 0E-500 -> 0E-398 Clamped
clam402 apply 0E-400 -> 0E-398 Clamped
clam403 apply 0E-398 -> 0E-398
clam404 apply 0.000000000000000E-383 -> 0E-398
clam405 apply 0E-2 -> 0.00
clam406 apply 0 -> 0
clam407 apply 0E+3 -> 0E+3
clam408 apply 0E+369 -> 0E+369
-- clamped zeros...
clam410 apply 0E+370 -> 0E+369 Clamped
clam411 apply 0E+384 -> 0E+369 Clamped
clam412 apply 0E+400 -> 0E+369 Clamped
clam413 apply 0E+500 -> 0E+369 Clamped
-- negative zeros
clam420 apply -0E-500 -> -0E-398 Clamped
clam421 apply -0E-400 -> -0E-398 Clamped
clam422 apply -0E-398 -> -0E-398
clam423 apply -0.000000000000000E-383 -> -0E-398
clam424 apply -0E-2 -> -0.00
clam425 apply -0 -> -0
clam426 apply -0E+3 -> -0E+3
clam427 apply -0E+369 -> -0E+369
-- clamped zeros...
clam431 apply -0E+370 -> -0E+369 Clamped
clam432 apply -0E+384 -> -0E+369 Clamped
clam433 apply -0E+400 -> -0E+369 Clamped
clam434 apply -0E+500 -> -0E+369 Clamped
-- fold-down full sequence
clam601 apply 1E+384 -> 1.000000000000000E+384 Clamped
clam603 apply 1E+383 -> 1.00000000000000E+383 Clamped
clam605 apply 1E+382 -> 1.0000000000000E+382 Clamped
clam607 apply 1E+381 -> 1.000000000000E+381 Clamped
clam609 apply 1E+380 -> 1.00000000000E+380 Clamped
clam611 apply 1E+379 -> 1.0000000000E+379 Clamped
clam613 apply 1E+378 -> 1.000000000E+378 Clamped
clam615 apply 1E+377 -> 1.00000000E+377 Clamped
clam617 apply 1E+376 -> 1.0000000E+376 Clamped
clam619 apply 1E+375 -> 1.000000E+375 Clamped
clam621 apply 1E+374 -> 1.00000E+374 Clamped
clam623 apply 1E+373 -> 1.0000E+373 Clamped
clam625 apply 1E+372 -> 1.000E+372 Clamped
clam627 apply 1E+371 -> 1.00E+371 Clamped
clam629 apply 1E+370 -> 1.0E+370 Clamped
clam631 apply 1E+369 -> 1E+369
clam633 apply 1E+368 -> 1E+368
-- same with 9s
clam641 apply 9E+384 -> 9.000000000000000E+384 Clamped
clam643 apply 9E+383 -> 9.00000000000000E+383 Clamped
clam645 apply 9E+382 -> 9.0000000000000E+382 Clamped
clam647 apply 9E+381 -> 9.000000000000E+381 Clamped
clam649 apply 9E+380 -> 9.00000000000E+380 Clamped
clam651 apply 9E+379 -> 9.0000000000E+379 Clamped
clam653 apply 9E+378 -> 9.000000000E+378 Clamped
clam655 apply 9E+377 -> 9.00000000E+377 Clamped
clam657 apply 9E+376 -> 9.0000000E+376 Clamped
clam659 apply 9E+375 -> 9.000000E+375 Clamped
clam661 apply 9E+374 -> 9.00000E+374 Clamped
clam663 apply 9E+373 -> 9.0000E+373 Clamped
clam665 apply 9E+372 -> 9.000E+372 Clamped
clam667 apply 9E+371 -> 9.00E+371 Clamped
clam669 apply 9E+370 -> 9.0E+370 Clamped
clam671 apply 9E+369 -> 9E+369
clam673 apply 9E+368 -> 9E+368
-- example from documentation
precision: 7
rounding: half_even
maxExponent: +96
minExponent: -95
clamp: 0
clam700 apply 1.23E+96 -> 1.23E+96
clamp: 1
clam701 apply 1.23E+96 -> 1.230000E+96 Clamped

717
sys/lib/python/test/decimaltestdata/compare.decTest
View file

@ -1,717 +0,0 @@
------------------------------------------------------------------------
-- compare.decTest -- decimal comparison --
-- Copyright (c) IBM Corporation, 1981, 2003. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- Note that we cannot assume add/subtract tests cover paths adequately,
-- here, because the code might be quite different (comparison cannot
-- overflow or underflow, so actual subtractions are not necesary).
extended: 1
precision: 9
rounding: half_up
maxExponent: 999
minexponent: -999
-- sanity checks
comx001 compare -2 -2 -> 0
comx002 compare -2 -1 -> -1
comx003 compare -2 0 -> -1
comx004 compare -2 1 -> -1
comx005 compare -2 2 -> -1
comx006 compare -1 -2 -> 1
comx007 compare -1 -1 -> 0
comx008 compare -1 0 -> -1
comx009 compare -1 1 -> -1
comx010 compare -1 2 -> -1
comx011 compare 0 -2 -> 1
comx012 compare 0 -1 -> 1
comx013 compare 0 0 -> 0
comx014 compare 0 1 -> -1
comx015 compare 0 2 -> -1
comx016 compare 1 -2 -> 1
comx017 compare 1 -1 -> 1
comx018 compare 1 0 -> 1
comx019 compare 1 1 -> 0
comx020 compare 1 2 -> -1
comx021 compare 2 -2 -> 1
comx022 compare 2 -1 -> 1
comx023 compare 2 0 -> 1
comx025 compare 2 1 -> 1
comx026 compare 2 2 -> 0
comx031 compare -20 -20 -> 0
comx032 compare -20 -10 -> -1
comx033 compare -20 00 -> -1
comx034 compare -20 10 -> -1
comx035 compare -20 20 -> -1
comx036 compare -10 -20 -> 1
comx037 compare -10 -10 -> 0
comx038 compare -10 00 -> -1
comx039 compare -10 10 -> -1
comx040 compare -10 20 -> -1
comx041 compare 00 -20 -> 1
comx042 compare 00 -10 -> 1
comx043 compare 00 00 -> 0
comx044 compare 00 10 -> -1
comx045 compare 00 20 -> -1
comx046 compare 10 -20 -> 1
comx047 compare 10 -10 -> 1
comx048 compare 10 00 -> 1
comx049 compare 10 10 -> 0
comx050 compare 10 20 -> -1
comx051 compare 20 -20 -> 1
comx052 compare 20 -10 -> 1
comx053 compare 20 00 -> 1
comx055 compare 20 10 -> 1
comx056 compare 20 20 -> 0
comx061 compare -2.0 -2.0 -> 0
comx062 compare -2.0 -1.0 -> -1
comx063 compare -2.0 0.0 -> -1
comx064 compare -2.0 1.0 -> -1
comx065 compare -2.0 2.0 -> -1
comx066 compare -1.0 -2.0 -> 1
comx067 compare -1.0 -1.0 -> 0
comx068 compare -1.0 0.0 -> -1
comx069 compare -1.0 1.0 -> -1
comx070 compare -1.0 2.0 -> -1
comx071 compare 0.0 -2.0 -> 1
comx072 compare 0.0 -1.0 -> 1
comx073 compare 0.0 0.0 -> 0
comx074 compare 0.0 1.0 -> -1
comx075 compare 0.0 2.0 -> -1
comx076 compare 1.0 -2.0 -> 1
comx077 compare 1.0 -1.0 -> 1
comx078 compare 1.0 0.0 -> 1
comx079 compare 1.0 1.0 -> 0
comx080 compare 1.0 2.0 -> -1
comx081 compare 2.0 -2.0 -> 1
comx082 compare 2.0 -1.0 -> 1
comx083 compare 2.0 0.0 -> 1
comx085 compare 2.0 1.0 -> 1
comx086 compare 2.0 2.0 -> 0
-- now some cases which might overflow if subtract were used
maxexponent: 999999999
minexponent: -999999999
comx090 compare 9.99999999E+999999999 9.99999999E+999999999 -> 0
comx091 compare -9.99999999E+999999999 9.99999999E+999999999 -> -1
comx092 compare 9.99999999E+999999999 -9.99999999E+999999999 -> 1
comx093 compare -9.99999999E+999999999 -9.99999999E+999999999 -> 0
-- some differing length/exponent cases
comx100 compare 7.0 7.0 -> 0
comx101 compare 7.0 7 -> 0
comx102 compare 7 7.0 -> 0
comx103 compare 7E+0 7.0 -> 0
comx104 compare 70E-1 7.0 -> 0
comx105 compare 0.7E+1 7 -> 0
comx106 compare 70E-1 7 -> 0
comx107 compare 7.0 7E+0 -> 0
comx108 compare 7.0 70E-1 -> 0
comx109 compare 7 0.7E+1 -> 0
comx110 compare 7 70E-1 -> 0
comx120 compare 8.0 7.0 -> 1
comx121 compare 8.0 7 -> 1
comx122 compare 8 7.0 -> 1
comx123 compare 8E+0 7.0 -> 1
comx124 compare 80E-1 7.0 -> 1
comx125 compare 0.8E+1 7 -> 1
comx126 compare 80E-1 7 -> 1
comx127 compare 8.0 7E+0 -> 1
comx128 compare 8.0 70E-1 -> 1
comx129 compare 8 0.7E+1 -> 1
comx130 compare 8 70E-1 -> 1
comx140 compare 8.0 9.0 -> -1
comx141 compare 8.0 9 -> -1
comx142 compare 8 9.0 -> -1
comx143 compare 8E+0 9.0 -> -1
comx144 compare 80E-1 9.0 -> -1
comx145 compare 0.8E+1 9 -> -1
comx146 compare 80E-1 9 -> -1
comx147 compare 8.0 9E+0 -> -1
comx148 compare 8.0 90E-1 -> -1
comx149 compare 8 0.9E+1 -> -1
comx150 compare 8 90E-1 -> -1
-- and again, with sign changes -+ ..
comx200 compare -7.0 7.0 -> -1
comx201 compare -7.0 7 -> -1
comx202 compare -7 7.0 -> -1
comx203 compare -7E+0 7.0 -> -1
comx204 compare -70E-1 7.0 -> -1
comx205 compare -0.7E+1 7 -> -1
comx206 compare -70E-1 7 -> -1
comx207 compare -7.0 7E+0 -> -1
comx208 compare -7.0 70E-1 -> -1
comx209 compare -7 0.7E+1 -> -1
comx210 compare -7 70E-1 -> -1
comx220 compare -8.0 7.0 -> -1
comx221 compare -8.0 7 -> -1
comx222 compare -8 7.0 -> -1
comx223 compare -8E+0 7.0 -> -1
comx224 compare -80E-1 7.0 -> -1
comx225 compare -0.8E+1 7 -> -1
comx226 compare -80E-1 7 -> -1
comx227 compare -8.0 7E+0 -> -1
comx228 compare -8.0 70E-1 -> -1
comx229 compare -8 0.7E+1 -> -1
comx230 compare -8 70E-1 -> -1
comx240 compare -8.0 9.0 -> -1
comx241 compare -8.0 9 -> -1
comx242 compare -8 9.0 -> -1
comx243 compare -8E+0 9.0 -> -1
comx244 compare -80E-1 9.0 -> -1
comx245 compare -0.8E+1 9 -> -1
comx246 compare -80E-1 9 -> -1
comx247 compare -8.0 9E+0 -> -1
comx248 compare -8.0 90E-1 -> -1
comx249 compare -8 0.9E+1 -> -1
comx250 compare -8 90E-1 -> -1
-- and again, with sign changes +- ..
comx300 compare 7.0 -7.0 -> 1
comx301 compare 7.0 -7 -> 1
comx302 compare 7 -7.0 -> 1
comx303 compare 7E+0 -7.0 -> 1
comx304 compare 70E-1 -7.0 -> 1
comx305 compare .7E+1 -7 -> 1
comx306 compare 70E-1 -7 -> 1
comx307 compare 7.0 -7E+0 -> 1
comx308 compare 7.0 -70E-1 -> 1
comx309 compare 7 -.7E+1 -> 1
comx310 compare 7 -70E-1 -> 1
comx320 compare 8.0 -7.0 -> 1
comx321 compare 8.0 -7 -> 1
comx322 compare 8 -7.0 -> 1
comx323 compare 8E+0 -7.0 -> 1
comx324 compare 80E-1 -7.0 -> 1
comx325 compare .8E+1 -7 -> 1
comx326 compare 80E-1 -7 -> 1
comx327 compare 8.0 -7E+0 -> 1
comx328 compare 8.0 -70E-1 -> 1
comx329 compare 8 -.7E+1 -> 1
comx330 compare 8 -70E-1 -> 1
comx340 compare 8.0 -9.0 -> 1
comx341 compare 8.0 -9 -> 1
comx342 compare 8 -9.0 -> 1
comx343 compare 8E+0 -9.0 -> 1
comx344 compare 80E-1 -9.0 -> 1
comx345 compare .8E+1 -9 -> 1
comx346 compare 80E-1 -9 -> 1
comx347 compare 8.0 -9E+0 -> 1
comx348 compare 8.0 -90E-1 -> 1
comx349 compare 8 -.9E+1 -> 1
comx350 compare 8 -90E-1 -> 1
-- and again, with sign changes -- ..
comx400 compare -7.0 -7.0 -> 0
comx401 compare -7.0 -7 -> 0
comx402 compare -7 -7.0 -> 0
comx403 compare -7E+0 -7.0 -> 0
comx404 compare -70E-1 -7.0 -> 0
comx405 compare -.7E+1 -7 -> 0
comx406 compare -70E-1 -7 -> 0
comx407 compare -7.0 -7E+0 -> 0
comx408 compare -7.0 -70E-1 -> 0
comx409 compare -7 -.7E+1 -> 0
comx410 compare -7 -70E-1 -> 0
comx420 compare -8.0 -7.0 -> -1
comx421 compare -8.0 -7 -> -1
comx422 compare -8 -7.0 -> -1
comx423 compare -8E+0 -7.0 -> -1
comx424 compare -80E-1 -7.0 -> -1
comx425 compare -.8E+1 -7 -> -1
comx426 compare -80E-1 -7 -> -1
comx427 compare -8.0 -7E+0 -> -1
comx428 compare -8.0 -70E-1 -> -1
comx429 compare -8 -.7E+1 -> -1
comx430 compare -8 -70E-1 -> -1
comx440 compare -8.0 -9.0 -> 1
comx441 compare -8.0 -9 -> 1
comx442 compare -8 -9.0 -> 1
comx443 compare -8E+0 -9.0 -> 1
comx444 compare -80E-1 -9.0 -> 1
comx445 compare -.8E+1 -9 -> 1
comx446 compare -80E-1 -9 -> 1
comx447 compare -8.0 -9E+0 -> 1
comx448 compare -8.0 -90E-1 -> 1
comx449 compare -8 -.9E+1 -> 1
comx450 compare -8 -90E-1 -> 1
-- testcases that subtract to lots of zeros at boundaries [pgr]
precision: 40
comx470 compare 123.4560000000000000E789 123.456E789 -> 0
comx471 compare 123.456000000000000E-89 123.456E-89 -> 0
comx472 compare 123.45600000000000E789 123.456E789 -> 0
comx473 compare 123.4560000000000E-89 123.456E-89 -> 0
comx474 compare 123.456000000000E789 123.456E789 -> 0
comx475 compare 123.45600000000E-89 123.456E-89 -> 0
comx476 compare 123.4560000000E789 123.456E789 -> 0
comx477 compare 123.456000000E-89 123.456E-89 -> 0
comx478 compare 123.45600000E789 123.456E789 -> 0
comx479 compare 123.4560000E-89 123.456E-89 -> 0
comx480 compare 123.456000E789 123.456E789 -> 0
comx481 compare 123.45600E-89 123.456E-89 -> 0
comx482 compare 123.4560E789 123.456E789 -> 0
comx483 compare 123.456E-89 123.456E-89 -> 0
comx484 compare 123.456E-89 123.4560000000000000E-89 -> 0
comx485 compare 123.456E789 123.456000000000000E789 -> 0
comx486 compare 123.456E-89 123.45600000000000E-89 -> 0
comx487 compare 123.456E789 123.4560000000000E789 -> 0
comx488 compare 123.456E-89 123.456000000000E-89 -> 0
comx489 compare 123.456E789 123.45600000000E789 -> 0
comx490 compare 123.456E-89 123.4560000000E-89 -> 0
comx491 compare 123.456E789 123.456000000E789 -> 0
comx492 compare 123.456E-89 123.45600000E-89 -> 0
comx493 compare 123.456E789 123.4560000E789 -> 0
comx494 compare 123.456E-89 123.456000E-89 -> 0
comx495 compare 123.456E789 123.45600E789 -> 0
comx496 compare 123.456E-89 123.4560E-89 -> 0
comx497 compare 123.456E789 123.456E789 -> 0
-- wide-ranging, around precision; signs equal
precision: 9
comx500 compare 1 1E-15 -> 1
comx501 compare 1 1E-14 -> 1
comx502 compare 1 1E-13 -> 1
comx503 compare 1 1E-12 -> 1
comx504 compare 1 1E-11 -> 1
comx505 compare 1 1E-10 -> 1
comx506 compare 1 1E-9 -> 1
comx507 compare 1 1E-8 -> 1
comx508 compare 1 1E-7 -> 1
comx509 compare 1 1E-6 -> 1
comx510 compare 1 1E-5 -> 1
comx511 compare 1 1E-4 -> 1
comx512 compare 1 1E-3 -> 1
comx513 compare 1 1E-2 -> 1
comx514 compare 1 1E-1 -> 1
comx515 compare 1 1E-0 -> 0
comx516 compare 1 1E+1 -> -1
comx517 compare 1 1E+2 -> -1
comx518 compare 1 1E+3 -> -1
comx519 compare 1 1E+4 -> -1
comx521 compare 1 1E+5 -> -1
comx522 compare 1 1E+6 -> -1
comx523 compare 1 1E+7 -> -1
comx524 compare 1 1E+8 -> -1
comx525 compare 1 1E+9 -> -1
comx526 compare 1 1E+10 -> -1
comx527 compare 1 1E+11 -> -1
comx528 compare 1 1E+12 -> -1
comx529 compare 1 1E+13 -> -1
comx530 compare 1 1E+14 -> -1
comx531 compare 1 1E+15 -> -1
-- LR swap
comx540 compare 1E-15 1 -> -1
comx541 compare 1E-14 1 -> -1
comx542 compare 1E-13 1 -> -1
comx543 compare 1E-12 1 -> -1
comx544 compare 1E-11 1 -> -1
comx545 compare 1E-10 1 -> -1
comx546 compare 1E-9 1 -> -1
comx547 compare 1E-8 1 -> -1
comx548 compare 1E-7 1 -> -1
comx549 compare 1E-6 1 -> -1
comx550 compare 1E-5 1 -> -1
comx551 compare 1E-4 1 -> -1
comx552 compare 1E-3 1 -> -1
comx553 compare 1E-2 1 -> -1
comx554 compare 1E-1 1 -> -1
comx555 compare 1E-0 1 -> 0
comx556 compare 1E+1 1 -> 1
comx557 compare 1E+2 1 -> 1
comx558 compare 1E+3 1 -> 1
comx559 compare 1E+4 1 -> 1
comx561 compare 1E+5 1 -> 1
comx562 compare 1E+6 1 -> 1
comx563 compare 1E+7 1 -> 1
comx564 compare 1E+8 1 -> 1
comx565 compare 1E+9 1 -> 1
comx566 compare 1E+10 1 -> 1
comx567 compare 1E+11 1 -> 1
comx568 compare 1E+12 1 -> 1
comx569 compare 1E+13 1 -> 1
comx570 compare 1E+14 1 -> 1
comx571 compare 1E+15 1 -> 1
-- similar with an useful coefficient, one side only
comx580 compare 0.000000987654321 1E-15 -> 1
comx581 compare 0.000000987654321 1E-14 -> 1
comx582 compare 0.000000987654321 1E-13 -> 1
comx583 compare 0.000000987654321 1E-12 -> 1
comx584 compare 0.000000987654321 1E-11 -> 1
comx585 compare 0.000000987654321 1E-10 -> 1
comx586 compare 0.000000987654321 1E-9 -> 1
comx587 compare 0.000000987654321 1E-8 -> 1
comx588 compare 0.000000987654321 1E-7 -> 1
comx589 compare 0.000000987654321 1E-6 -> -1
comx590 compare 0.000000987654321 1E-5 -> -1
comx591 compare 0.000000987654321 1E-4 -> -1
comx592 compare 0.000000987654321 1E-3 -> -1
comx593 compare 0.000000987654321 1E-2 -> -1
comx594 compare 0.000000987654321 1E-1 -> -1
comx595 compare 0.000000987654321 1E-0 -> -1
comx596 compare 0.000000987654321 1E+1 -> -1
comx597 compare 0.000000987654321 1E+2 -> -1
comx598 compare 0.000000987654321 1E+3 -> -1
comx599 compare 0.000000987654321 1E+4 -> -1
-- check some unit-y traps
precision: 20
comx600 compare 12 12.2345 -> -1
comx601 compare 12.0 12.2345 -> -1
comx602 compare 12.00 12.2345 -> -1
comx603 compare 12.000 12.2345 -> -1
comx604 compare 12.0000 12.2345 -> -1
comx605 compare 12.00000 12.2345 -> -1
comx606 compare 12.000000 12.2345 -> -1
comx607 compare 12.0000000 12.2345 -> -1
comx608 compare 12.00000000 12.2345 -> -1
comx609 compare 12.000000000 12.2345 -> -1
comx610 compare 12.1234 12 -> 1
comx611 compare 12.1234 12.0 -> 1
comx612 compare 12.1234 12.00 -> 1
comx613 compare 12.1234 12.000 -> 1
comx614 compare 12.1234 12.0000 -> 1
comx615 compare 12.1234 12.00000 -> 1
comx616 compare 12.1234 12.000000 -> 1
comx617 compare 12.1234 12.0000000 -> 1
comx618 compare 12.1234 12.00000000 -> 1
comx619 compare 12.1234 12.000000000 -> 1
comx620 compare -12 -12.2345 -> 1
comx621 compare -12.0 -12.2345 -> 1
comx622 compare -12.00 -12.2345 -> 1
comx623 compare -12.000 -12.2345 -> 1
comx624 compare -12.0000 -12.2345 -> 1
comx625 compare -12.00000 -12.2345 -> 1
comx626 compare -12.000000 -12.2345 -> 1
comx627 compare -12.0000000 -12.2345 -> 1
comx628 compare -12.00000000 -12.2345 -> 1
comx629 compare -12.000000000 -12.2345 -> 1
comx630 compare -12.1234 -12 -> -1
comx631 compare -12.1234 -12.0 -> -1
comx632 compare -12.1234 -12.00 -> -1
comx633 compare -12.1234 -12.000 -> -1
comx634 compare -12.1234 -12.0000 -> -1
comx635 compare -12.1234 -12.00000 -> -1
comx636 compare -12.1234 -12.000000 -> -1
comx637 compare -12.1234 -12.0000000 -> -1
comx638 compare -12.1234 -12.00000000 -> -1
comx639 compare -12.1234 -12.000000000 -> -1
precision: 9
-- extended zeros
comx640 compare 0 0 -> 0
comx641 compare 0 -0 -> 0
comx642 compare 0 -0.0 -> 0
comx643 compare 0 0.0 -> 0
comx644 compare -0 0 -> 0
comx645 compare -0 -0 -> 0
comx646 compare -0 -0.0 -> 0
comx647 compare -0 0.0 -> 0
comx648 compare 0.0 0 -> 0
comx649 compare 0.0 -0 -> 0
comx650 compare 0.0 -0.0 -> 0
comx651 compare 0.0 0.0 -> 0
comx652 compare -0.0 0 -> 0
comx653 compare -0.0 -0 -> 0
comx654 compare -0.0 -0.0 -> 0
comx655 compare -0.0 0.0 -> 0
comx656 compare -0E1 0.0 -> 0
comx657 compare -0E2 0.0 -> 0
comx658 compare 0E1 0.0 -> 0
comx659 compare 0E2 0.0 -> 0
comx660 compare -0E1 0 -> 0
comx661 compare -0E2 0 -> 0
comx662 compare 0E1 0 -> 0
comx663 compare 0E2 0 -> 0
comx664 compare -0E1 -0E1 -> 0
comx665 compare -0E2 -0E1 -> 0
comx666 compare 0E1 -0E1 -> 0
comx667 compare 0E2 -0E1 -> 0
comx668 compare -0E1 -0E2 -> 0
comx669 compare -0E2 -0E2 -> 0
comx670 compare 0E1 -0E2 -> 0
comx671 compare 0E2 -0E2 -> 0
comx672 compare -0E1 0E1 -> 0
comx673 compare -0E2 0E1 -> 0
comx674 compare 0E1 0E1 -> 0
comx675 compare 0E2 0E1 -> 0
comx676 compare -0E1 0E2 -> 0
comx677 compare -0E2 0E2 -> 0
comx678 compare 0E1 0E2 -> 0
comx679 compare 0E2 0E2 -> 0
-- trailing zeros; unit-y
precision: 20
comx680 compare 12 12 -> 0
comx681 compare 12 12.0 -> 0
comx682 compare 12 12.00 -> 0
comx683 compare 12 12.000 -> 0
comx684 compare 12 12.0000 -> 0
comx685 compare 12 12.00000 -> 0
comx686 compare 12 12.000000 -> 0
comx687 compare 12 12.0000000 -> 0
comx688 compare 12 12.00000000 -> 0
comx689 compare 12 12.000000000 -> 0
comx690 compare 12 12 -> 0
comx691 compare 12.0 12 -> 0
comx692 compare 12.00 12 -> 0
comx693 compare 12.000 12 -> 0
comx694 compare 12.0000 12 -> 0
comx695 compare 12.00000 12 -> 0
comx696 compare 12.000000 12 -> 0
comx697 compare 12.0000000 12 -> 0
comx698 compare 12.00000000 12 -> 0
comx699 compare 12.000000000 12 -> 0
-- long operand checks
maxexponent: 999
minexponent: -999
precision: 9
comx701 compare 12345678000 1 -> 1
comx702 compare 1 12345678000 -> -1
comx703 compare 1234567800 1 -> 1
comx704 compare 1 1234567800 -> -1
comx705 compare 1234567890 1 -> 1
comx706 compare 1 1234567890 -> -1
comx707 compare 1234567891 1 -> 1
comx708 compare 1 1234567891 -> -1
comx709 compare 12345678901 1 -> 1
comx710 compare 1 12345678901 -> -1
comx711 compare 1234567896 1 -> 1
comx712 compare 1 1234567896 -> -1
comx713 compare -1234567891 1 -> -1
comx714 compare 1 -1234567891 -> 1
comx715 compare -12345678901 1 -> -1
comx716 compare 1 -12345678901 -> 1
comx717 compare -1234567896 1 -> -1
comx718 compare 1 -1234567896 -> 1
precision: 15
-- same with plenty of precision
comx721 compare 12345678000 1 -> 1
comx722 compare 1 12345678000 -> -1
comx723 compare 1234567800 1 -> 1
comx724 compare 1 1234567800 -> -1
comx725 compare 1234567890 1 -> 1
comx726 compare 1 1234567890 -> -1
comx727 compare 1234567891 1 -> 1
comx728 compare 1 1234567891 -> -1
comx729 compare 12345678901 1 -> 1
comx730 compare 1 12345678901 -> -1
comx731 compare 1234567896 1 -> 1
comx732 compare 1 1234567896 -> -1
-- residue cases
precision: 5
comx740 compare 1 0.9999999 -> 1
comx741 compare 1 0.999999 -> 1
comx742 compare 1 0.99999 -> 1
comx743 compare 1 1.0000 -> 0
comx744 compare 1 1.00001 -> -1
comx745 compare 1 1.000001 -> -1
comx746 compare 1 1.0000001 -> -1
comx750 compare 0.9999999 1 -> -1
comx751 compare 0.999999 1 -> -1
comx752 compare 0.99999 1 -> -1
comx753 compare 1.0000 1 -> 0
comx754 compare 1.00001 1 -> 1
comx755 compare 1.000001 1 -> 1
comx756 compare 1.0000001 1 -> 1
-- a selection of longies
comx760 compare -36852134.84194296250843579428931 -5830629.8347085025808756560357940 -> -1
comx761 compare -36852134.84194296250843579428931 -36852134.84194296250843579428931 -> 0
comx762 compare -36852134.94194296250843579428931 -36852134.84194296250843579428931 -> -1
comx763 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
-- precisions above or below the difference should have no effect
precision: 11
comx764 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
precision: 10
comx765 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
precision: 9
comx766 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
precision: 8
comx767 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
precision: 7
comx768 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
precision: 6
comx769 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
precision: 5
comx770 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
precision: 4
comx771 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
precision: 3
comx772 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
precision: 2
comx773 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
precision: 1
comx774 compare -36852134.84194296250843579428931 -36852134.94194296250843579428931 -> 1
-- Specials
precision: 9
comx780 compare Inf -Inf -> 1
comx781 compare Inf -1000 -> 1
comx782 compare Inf -1 -> 1
comx783 compare Inf -0 -> 1
comx784 compare Inf 0 -> 1
comx785 compare Inf 1 -> 1
comx786 compare Inf 1000 -> 1
comx787 compare Inf Inf -> 0
comx788 compare -1000 Inf -> -1
comx789 compare -Inf Inf -> -1
comx790 compare -1 Inf -> -1
comx791 compare -0 Inf -> -1
comx792 compare 0 Inf -> -1
comx793 compare 1 Inf -> -1
comx794 compare 1000 Inf -> -1
comx795 compare Inf Inf -> 0
comx800 compare -Inf -Inf -> 0
comx801 compare -Inf -1000 -> -1
comx802 compare -Inf -1 -> -1
comx803 compare -Inf -0 -> -1
comx804 compare -Inf 0 -> -1
comx805 compare -Inf 1 -> -1
comx806 compare -Inf 1000 -> -1
comx807 compare -Inf Inf -> -1
comx808 compare -Inf -Inf -> 0
comx809 compare -1000 -Inf -> 1
comx810 compare -1 -Inf -> 1
comx811 compare -0 -Inf -> 1
comx812 compare 0 -Inf -> 1
comx813 compare 1 -Inf -> 1
comx814 compare 1000 -Inf -> 1
comx815 compare Inf -Inf -> 1
comx821 compare NaN -Inf -> NaN
comx822 compare NaN -1000 -> NaN
comx823 compare NaN -1 -> NaN
comx824 compare NaN -0 -> NaN
comx825 compare NaN 0 -> NaN
comx826 compare NaN 1 -> NaN
comx827 compare NaN 1000 -> NaN
comx828 compare NaN Inf -> NaN
comx829 compare NaN NaN -> NaN
comx830 compare -Inf NaN -> NaN
comx831 compare -1000 NaN -> NaN
comx832 compare -1 NaN -> NaN
comx833 compare -0 NaN -> NaN
comx834 compare 0 NaN -> NaN
comx835 compare 1 NaN -> NaN
comx836 compare 1000 NaN -> NaN
comx837 compare Inf NaN -> NaN
comx838 compare -NaN -NaN -> -NaN
comx839 compare +NaN -NaN -> NaN
comx840 compare -NaN +NaN -> -NaN
comx841 compare sNaN -Inf -> NaN Invalid_operation
comx842 compare sNaN -1000 -> NaN Invalid_operation
comx843 compare sNaN -1 -> NaN Invalid_operation
comx844 compare sNaN -0 -> NaN Invalid_operation
comx845 compare sNaN 0 -> NaN Invalid_operation
comx846 compare sNaN 1 -> NaN Invalid_operation
comx847 compare sNaN 1000 -> NaN Invalid_operation
comx848 compare sNaN NaN -> NaN Invalid_operation
comx849 compare sNaN sNaN -> NaN Invalid_operation
comx850 compare NaN sNaN -> NaN Invalid_operation
comx851 compare -Inf sNaN -> NaN Invalid_operation
comx852 compare -1000 sNaN -> NaN Invalid_operation
comx853 compare -1 sNaN -> NaN Invalid_operation
comx854 compare -0 sNaN -> NaN Invalid_operation
comx855 compare 0 sNaN -> NaN Invalid_operation
comx856 compare 1 sNaN -> NaN Invalid_operation
comx857 compare 1000 sNaN -> NaN Invalid_operation
comx858 compare Inf sNaN -> NaN Invalid_operation
comx859 compare NaN sNaN -> NaN Invalid_operation
-- propagating NaNs
comx860 compare NaN9 -Inf -> NaN9
comx861 compare NaN8 999 -> NaN8
comx862 compare NaN77 Inf -> NaN77
comx863 compare -NaN67 NaN5 -> -NaN67
comx864 compare -Inf -NaN4 -> -NaN4
comx865 compare -999 -NaN33 -> -NaN33
comx866 compare Inf NaN2 -> NaN2
comx867 compare -NaN41 -NaN42 -> -NaN41
comx868 compare +NaN41 -NaN42 -> NaN41
comx869 compare -NaN41 +NaN42 -> -NaN41
comx870 compare +NaN41 +NaN42 -> NaN41
comx871 compare -sNaN99 -Inf -> -NaN99 Invalid_operation
comx872 compare sNaN98 -11 -> NaN98 Invalid_operation
comx873 compare sNaN97 NaN -> NaN97 Invalid_operation
comx874 compare sNaN16 sNaN94 -> NaN16 Invalid_operation
comx875 compare NaN85 sNaN83 -> NaN83 Invalid_operation
comx876 compare -Inf sNaN92 -> NaN92 Invalid_operation
comx877 compare 088 sNaN81 -> NaN81 Invalid_operation
comx878 compare Inf sNaN90 -> NaN90 Invalid_operation
comx879 compare NaN -sNaN89 -> -NaN89 Invalid_operation
-- overflow and underflow tests .. subnormal results now allowed
maxExponent: 999999999
minexponent: -999999999
comx880 compare +1.23456789012345E-0 9E+999999999 -> -1
comx881 compare 9E+999999999 +1.23456789012345E-0 -> 1
comx882 compare +0.100 9E-999999999 -> 1
comx883 compare 9E-999999999 +0.100 -> -1
comx885 compare -1.23456789012345E-0 9E+999999999 -> -1
comx886 compare 9E+999999999 -1.23456789012345E-0 -> 1
comx887 compare -0.100 9E-999999999 -> -1
comx888 compare 9E-999999999 -0.100 -> 1
comx889 compare 1e-599999999 1e-400000001 -> -1
comx890 compare 1e-599999999 1e-400000000 -> -1
comx891 compare 1e-600000000 1e-400000000 -> -1
comx892 compare 9e-999999998 0.01 -> -1
comx893 compare 9e-999999998 0.1 -> -1
comx894 compare 0.01 9e-999999998 -> 1
comx895 compare 1e599999999 1e400000001 -> 1
comx896 compare 1e599999999 1e400000000 -> 1
comx897 compare 1e600000000 1e400000000 -> 1
comx898 compare 9e999999998 100 -> 1
comx899 compare 9e999999998 10 -> 1
comx900 compare 100 9e999999998 -> -1
-- signs
comx901 compare 1e+777777777 1e+411111111 -> 1
comx902 compare 1e+777777777 -1e+411111111 -> 1
comx903 compare -1e+777777777 1e+411111111 -> -1
comx904 compare -1e+777777777 -1e+411111111 -> -1
comx905 compare 1e-777777777 1e-411111111 -> -1
comx906 compare 1e-777777777 -1e-411111111 -> 1
comx907 compare -1e-777777777 1e-411111111 -> -1
comx908 compare -1e-777777777 -1e-411111111 -> 1
-- Null tests
comx990 compare 10 # -> NaN Invalid_operation
comx991 compare # 10 -> NaN Invalid_operation

441
sys/lib/python/test/decimaltestdata/decimal128.decTest
View file

@ -1,441 +0,0 @@
------------------------------------------------------------------------
-- decimal128.decTest -- decimal sixteen-byte format testcases --
-- Copyright (c) IBM Corporation, 2000, 2003. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- This set of tests is for the sixteen-byte concrete representation.
-- Its characteristics are:
--
-- 1 bit sign
-- 5 bits combination field
-- 12 bits exponent continuation
-- 110 bits coefficient continuation
--
-- Total exponent length 14 bits
-- Total coefficient length 114 bits (34 digits)
--
-- Elimit = 12287 (maximum encoded exponent)
-- Emax = 6144 (largest exponent value)
-- Emin = -6143 (smallest exponent value)
-- bias = 6176 (subtracted from encoded exponent) = -Etiny
extended: 1
precision: 34
rounding: half_up
maxExponent: 6144
minExponent: -6143
-- General testcases
-- (mostly derived from the Strawman 4 document and examples)
decg001 apply #A20780000000000000000000000003D0 -> -7.50
decg002 apply -7.50 -> #A20780000000000000000000000003D0
-- Normality
decf010 apply 1234567890123456789012345678901234 -> #2608134b9c1e28e56f3c127177823534
decf011 apply 1234567890123456789012345678901234.0 -> #2608134b9c1e28e56f3c127177823534 Rounded
decf012 apply 1234567890123456789012345678901234.1 -> #2608134b9c1e28e56f3c127177823534 Rounded Inexact
decf013 apply -1234567890123456789012345678901234 -> #a608134b9c1e28e56f3c127177823534
decf014 apply -1234567890123456789012345678901234.0 -> #a608134b9c1e28e56f3c127177823534 Rounded
decf015 apply -1234567890123456789012345678901234.1 -> #a608134b9c1e28e56f3c127177823534 Rounded Inexact
-- Nmax and similar
decf022 apply 9.999999999999999999999999999999999E+6144 -> #77ffcff3fcff3fcff3fcff3fcff3fcff
decf023 apply #77ffcff3fcff3fcff3fcff3fcff3fcff -> 9.999999999999999999999999999999999E+6144
decf024 apply 1.234567890123456789012345678901234E+6144 -> #47ffd34b9c1e28e56f3c127177823534
decf025 apply #47ffd34b9c1e28e56f3c127177823534 -> 1.234567890123456789012345678901234E+6144
-- fold-downs (more below)
decf030 apply 1.23E+6144 -> #47ffd300000000000000000000000000 Clamped
decf031 apply #47ffd300000000000000000000000000 -> 1.230000000000000000000000000000000E+6144
decf032 apply 1E+6144 -> #47ffc000000000000000000000000000 Clamped
decf033 apply #47ffc000000000000000000000000000 -> 1.000000000000000000000000000000000E+6144
-- overflows
maxExponent: 9999 -- set high so conversion causes the overflow
minExponent: -9999
decf040 apply 10E+6144 -> #78000000000000000000000000000000 Overflow Rounded Inexact
decf041 apply 1.000000000000000E+6145 -> #78000000000000000000000000000000 Overflow Rounded Inexact
maxExponent: 6144
minExponent: -6143
decf051 apply 12345 -> #220800000000000000000000000049c5
decf052 apply #220800000000000000000000000049c5 -> 12345
decf053 apply 1234 -> #22080000000000000000000000000534
decf054 apply #22080000000000000000000000000534 -> 1234
decf055 apply 123 -> #220800000000000000000000000000a3
decf056 apply #220800000000000000000000000000a3 -> 123
decf057 apply 12 -> #22080000000000000000000000000012
decf058 apply #22080000000000000000000000000012 -> 12
decf059 apply 1 -> #22080000000000000000000000000001
decf060 apply #22080000000000000000000000000001 -> 1
decf061 apply 1.23 -> #220780000000000000000000000000a3
decf062 apply #220780000000000000000000000000a3 -> 1.23
decf063 apply 123.45 -> #220780000000000000000000000049c5
decf064 apply #220780000000000000000000000049c5 -> 123.45
-- Nmin and below
decf071 apply 1E-6143 -> #00084000000000000000000000000001
decf072 apply #00084000000000000000000000000001 -> 1E-6143
decf073 apply 1.000000000000000000000000000000000E-6143 -> #04000000000000000000000000000000
decf074 apply #04000000000000000000000000000000 -> 1.000000000000000000000000000000000E-6143
decf075 apply 1.000000000000000000000000000000001E-6143 -> #04000000000000000000000000000001
decf076 apply #04000000000000000000000000000001 -> 1.000000000000000000000000000000001E-6143
decf077 apply 0.100000000000000000000000000000000E-6143 -> #00000800000000000000000000000000 Subnormal
decf078 apply #00000800000000000000000000000000 -> 1.00000000000000000000000000000000E-6144 Subnormal
decf079 apply 0.000000000000000000000000000000010E-6143 -> #00000000000000000000000000000010 Subnormal
decf080 apply #00000000000000000000000000000010 -> 1.0E-6175 Subnormal
decf081 apply 0.00000000000000000000000000000001E-6143 -> #00004000000000000000000000000001 Subnormal
decf082 apply #00004000000000000000000000000001 -> 1E-6175 Subnormal
decf083 apply 0.000000000000000000000000000000001E-6143 -> #00000000000000000000000000000001 Subnormal
decf084 apply #00000000000000000000000000000001 -> 1E-6176 Subnormal
-- underflows
decf090 apply 1e-6176 -> #00000000000000000000000000000001 Subnormal
decf091 apply 1.9e-6176 -> #00000000000000000000000000000002 Subnormal Underflow Inexact Rounded
decf092 apply 1.1e-6176 -> #00000000000000000000000000000001 Subnormal Underflow Inexact Rounded
decf093 apply 1.00000000001e-6176 -> #00000000000000000000000000000001 Subnormal Underflow Inexact Rounded
decf094 apply 1.00000000000001e-6176 -> #00000000000000000000000000000001 Subnormal Underflow Inexact Rounded
decf095 apply 1.000000000000001e-6176 -> #00000000000000000000000000000001 Subnormal Underflow Inexact Rounded
decf096 apply 0.1e-6176 -> #00000000000000000000000000000000 Subnormal Underflow Inexact Rounded
decf097 apply 0.00000000001e-6176 -> #00000000000000000000000000000000 Subnormal Underflow Inexact Rounded
decf098 apply 0.00000000000001e-6176 -> #00000000000000000000000000000000 Subnormal Underflow Inexact Rounded
decf099 apply 0.000000000000001e-6176 -> #00000000000000000000000000000000 Subnormal Underflow Inexact Rounded
decf100 apply 999999999999999999999999999999999e-6176 -> #00000ff3fcff3fcff3fcff3fcff3fcff Subnormal
-- same again, negatives
-- Nmax and similar
decf122 apply -9.999999999999999999999999999999999E+6144 -> #f7ffcff3fcff3fcff3fcff3fcff3fcff
decf123 apply #f7ffcff3fcff3fcff3fcff3fcff3fcff -> -9.999999999999999999999999999999999E+6144
decf124 apply -1.234567890123456789012345678901234E+6144 -> #c7ffd34b9c1e28e56f3c127177823534
decf125 apply #c7ffd34b9c1e28e56f3c127177823534 -> -1.234567890123456789012345678901234E+6144
-- fold-downs (more below)
decf130 apply -1.23E+6144 -> #c7ffd300000000000000000000000000 Clamped
decf131 apply #c7ffd300000000000000000000000000 -> -1.230000000000000000000000000000000E+6144
decf132 apply -1E+6144 -> #c7ffc000000000000000000000000000 Clamped
decf133 apply #c7ffc000000000000000000000000000 -> -1.000000000000000000000000000000000E+6144
-- overflows
maxExponent: 9999 -- set high so conversion causes the overflow
minExponent: -9999
decf140 apply -10E+6144 -> #f8000000000000000000000000000000 Overflow Rounded Inexact
decf141 apply -1.000000000000000E+6145 -> #f8000000000000000000000000000000 Overflow Rounded Inexact
maxExponent: 6144
minExponent: -6143
decf151 apply -12345 -> #a20800000000000000000000000049c5
decf152 apply #a20800000000000000000000000049c5 -> -12345
decf153 apply -1234 -> #a2080000000000000000000000000534
decf154 apply #a2080000000000000000000000000534 -> -1234
decf155 apply -123 -> #a20800000000000000000000000000a3
decf156 apply #a20800000000000000000000000000a3 -> -123
decf157 apply -12 -> #a2080000000000000000000000000012
decf158 apply #a2080000000000000000000000000012 -> -12
decf159 apply -1 -> #a2080000000000000000000000000001
decf160 apply #a2080000000000000000000000000001 -> -1
decf161 apply -1.23 -> #a20780000000000000000000000000a3
decf162 apply #a20780000000000000000000000000a3 -> -1.23
decf163 apply -123.45 -> #a20780000000000000000000000049c5
decf164 apply #a20780000000000000000000000049c5 -> -123.45
-- Nmin and below
decf171 apply -1E-6143 -> #80084000000000000000000000000001
decf172 apply #80084000000000000000000000000001 -> -1E-6143
decf173 apply -1.000000000000000000000000000000000E-6143 -> #84000000000000000000000000000000
decf174 apply #84000000000000000000000000000000 -> -1.000000000000000000000000000000000E-6143
decf175 apply -1.000000000000000000000000000000001E-6143 -> #84000000000000000000000000000001
decf176 apply #84000000000000000000000000000001 -> -1.000000000000000000000000000000001E-6143
decf177 apply -0.100000000000000000000000000000000E-6143 -> #80000800000000000000000000000000 Subnormal
decf178 apply #80000800000000000000000000000000 -> -1.00000000000000000000000000000000E-6144 Subnormal
decf179 apply -0.000000000000000000000000000000010E-6143 -> #80000000000000000000000000000010 Subnormal
decf180 apply #80000000000000000000000000000010 -> -1.0E-6175 Subnormal
decf181 apply -0.00000000000000000000000000000001E-6143 -> #80004000000000000000000000000001 Subnormal
decf182 apply #80004000000000000000000000000001 -> -1E-6175 Subnormal
decf183 apply -0.000000000000000000000000000000001E-6143 -> #80000000000000000000000000000001 Subnormal
decf184 apply #80000000000000000000000000000001 -> -1E-6176 Subnormal
-- underflows
decf190 apply -1e-6176 -> #80000000000000000000000000000001 Subnormal
decf191 apply -1.9e-6176 -> #80000000000000000000000000000002 Subnormal Underflow Inexact Rounded
decf192 apply -1.1e-6176 -> #80000000000000000000000000000001 Subnormal Underflow Inexact Rounded
decf193 apply -1.00000000001e-6176 -> #80000000000000000000000000000001 Subnormal Underflow Inexact Rounded
decf194 apply -1.00000000000001e-6176 -> #80000000000000000000000000000001 Subnormal Underflow Inexact Rounded
decf195 apply -1.000000000000001e-6176 -> #80000000000000000000000000000001 Subnormal Underflow Inexact Rounded
decf196 apply -0.1e-6176 -> #80000000000000000000000000000000 Subnormal Underflow Inexact Rounded
decf197 apply -0.00000000001e-6176 -> #80000000000000000000000000000000 Subnormal Underflow Inexact Rounded
decf198 apply -0.00000000000001e-6176 -> #80000000000000000000000000000000 Subnormal Underflow Inexact Rounded
decf199 apply -0.000000000000001e-6176 -> #80000000000000000000000000000000 Subnormal Underflow Inexact Rounded
decf200 apply -999999999999999999999999999999999e-6176 -> #80000ff3fcff3fcff3fcff3fcff3fcff Subnormal
-- zeros
decf400 apply 0E-8000 -> #00000000000000000000000000000000 Clamped
decf401 apply 0E-6177 -> #00000000000000000000000000000000 Clamped
decf402 apply 0E-6176 -> #00000000000000000000000000000000
decf403 apply #00000000000000000000000000000000 -> 0E-6176
decf404 apply 0.000000000000000000000000000000000E-6143 -> #00000000000000000000000000000000
decf405 apply #00000000000000000000000000000000 -> 0E-6176
decf406 apply 0E-2 -> #22078000000000000000000000000000
decf407 apply #22078000000000000000000000000000 -> 0.00
decf408 apply 0 -> #22080000000000000000000000000000
decf409 apply #22080000000000000000000000000000 -> 0
decf410 apply 0E+3 -> #2208c000000000000000000000000000
decf411 apply #2208c000000000000000000000000000 -> 0E+3
decf412 apply 0E+6111 -> #43ffc000000000000000000000000000
decf413 apply #43ffc000000000000000000000000000 -> 0E+6111
-- clamped zeros...
decf414 apply 0E+6112 -> #43ffc000000000000000000000000000 Clamped
decf415 apply #43ffc000000000000000000000000000 -> 0E+6111
decf416 apply 0E+6144 -> #43ffc000000000000000000000000000 Clamped
decf417 apply #43ffc000000000000000000000000000 -> 0E+6111
decf418 apply 0E+8000 -> #43ffc000000000000000000000000000 Clamped
decf419 apply #43ffc000000000000000000000000000 -> 0E+6111
-- negative zeros
decf420 apply -0E-8000 -> #80000000000000000000000000000000 Clamped
decf421 apply -0E-6177 -> #80000000000000000000000000000000 Clamped
decf422 apply -0E-6176 -> #80000000000000000000000000000000
decf423 apply #80000000000000000000000000000000 -> -0E-6176
decf424 apply -0.000000000000000000000000000000000E-6143 -> #80000000000000000000000000000000
decf425 apply #80000000000000000000000000000000 -> -0E-6176
decf426 apply -0E-2 -> #a2078000000000000000000000000000
decf427 apply #a2078000000000000000000000000000 -> -0.00
decf428 apply -0 -> #a2080000000000000000000000000000
decf429 apply #a2080000000000000000000000000000 -> -0
decf430 apply -0E+3 -> #a208c000000000000000000000000000
decf431 apply #a208c000000000000000000000000000 -> -0E+3
decf432 apply -0E+6111 -> #c3ffc000000000000000000000000000
decf433 apply #c3ffc000000000000000000000000000 -> -0E+6111
-- clamped zeros...
decf434 apply -0E+6112 -> #c3ffc000000000000000000000000000 Clamped
decf435 apply #c3ffc000000000000000000000000000 -> -0E+6111
decf436 apply -0E+6144 -> #c3ffc000000000000000000000000000 Clamped
decf437 apply #c3ffc000000000000000000000000000 -> -0E+6111
decf438 apply -0E+8000 -> #c3ffc000000000000000000000000000 Clamped
decf439 apply #c3ffc000000000000000000000000000 -> -0E+6111
-- Specials
decf500 apply Infinity -> #78000000000000000000000000000000
decf501 apply #78787878787878787878787878787878 -> #78000000000000000000000000000000
decf502 apply #78000000000000000000000000000000 -> Infinity
decf503 apply #79797979797979797979797979797979 -> #78000000000000000000000000000000
decf504 apply #79000000000000000000000000000000 -> Infinity
decf505 apply #7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a -> #78000000000000000000000000000000
decf506 apply #7a000000000000000000000000000000 -> Infinity
decf507 apply #7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b -> #78000000000000000000000000000000
decf508 apply #7b000000000000000000000000000000 -> Infinity
decf509 apply NaN -> #7c000000000000000000000000000000
decf510 apply #7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c -> #7c003c7c7c7c7c7c7c7c7c7c7c7c7c7c
decf511 apply #7c000000000000000000000000000000 -> NaN
decf512 apply #7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d -> #7c003d7d7d7d7d7d7d7d7d7d7d7d7d7d
decf513 apply #7d000000000000000000000000000000 -> NaN
decf514 apply #7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e -> #7e003e7e7c7e7e7e7e7c7e7e7e7e7c7e
decf515 apply #7e000000000000000000000000000000 -> sNaN
decf516 apply #7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f -> #7e003f7f7c7f7f7f7f7c7f7f7f7f7c7f
decf517 apply #7f000000000000000000000000000000 -> sNaN
decf518 apply #7fffffffffffffffffffffffffffffff -> sNaN999999999999999999999999999999999
decf519 apply #7fffffffffffffffffffffffffffffff -> #7e000ff3fcff3fcff3fcff3fcff3fcff
decf520 apply -Infinity -> #f8000000000000000000000000000000
decf521 apply #f8787878787878787878787878787878 -> #f8000000000000000000000000000000
decf522 apply #f8000000000000000000000000000000 -> -Infinity
decf523 apply #f9797979797979797979797979797979 -> #f8000000000000000000000000000000
decf524 apply #f9000000000000000000000000000000 -> -Infinity
decf525 apply #fa7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a -> #f8000000000000000000000000000000
decf526 apply #fa000000000000000000000000000000 -> -Infinity
decf527 apply #fb7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b -> #f8000000000000000000000000000000
decf528 apply #fb000000000000000000000000000000 -> -Infinity
decf529 apply -NaN -> #fc000000000000000000000000000000
decf530 apply #fc7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c -> #fc003c7c7c7c7c7c7c7c7c7c7c7c7c7c
decf531 apply #fc000000000000000000000000000000 -> -NaN
decf532 apply #fd7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d -> #fc003d7d7d7d7d7d7d7d7d7d7d7d7d7d
decf533 apply #fd000000000000000000000000000000 -> -NaN
decf534 apply #fe7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e -> #fe003e7e7c7e7e7e7e7c7e7e7e7e7c7e
decf535 apply #fe000000000000000000000000000000 -> -sNaN
decf536 apply #ff7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f -> #fe003f7f7c7f7f7f7f7c7f7f7f7f7c7f
decf537 apply #ff000000000000000000000000000000 -> -sNaN
decf538 apply #ffffffffffffffffffffffffffffffff -> -sNaN999999999999999999999999999999999
decf539 apply #ffffffffffffffffffffffffffffffff -> #fe000ff3fcff3fcff3fcff3fcff3fcff
decf540 apply NaN -> #7c000000000000000000000000000000
decf541 apply NaN0 -> #7c000000000000000000000000000000
decf542 apply NaN1 -> #7c000000000000000000000000000001
decf543 apply NaN12 -> #7c000000000000000000000000000012
decf544 apply NaN79 -> #7c000000000000000000000000000079
decf545 apply NaN12345 -> #7c0000000000000000000000000049c5
decf546 apply NaN123456 -> #7c000000000000000000000000028e56
decf547 apply NaN799799 -> #7c0000000000000000000000000f7fdf
decf548 apply NaN799799799799799799799799799799799 -> #7c003dff7fdff7fdff7fdff7fdff7fdf
decf549 apply NaN999999999999999999999999999999999 -> #7c000ff3fcff3fcff3fcff3fcff3fcff
decf550 apply NaN1234567890123456789012345678901234 -> #7c000000000000000000000000000000 -- too many digits
-- fold-down full sequence
decf600 apply 1E+6145 -> #78000000000000000000000000000000 Overflow Inexact Rounded
decf601 apply 1E+6144 -> #47ffc000000000000000000000000000 Clamped
decf602 apply #47ffc000000000000000000000000000 -> 1.000000000000000000000000000000000E+6144
decf603 apply 1E+6143 -> #43ffc800000000000000000000000000 Clamped
decf604 apply #43ffc800000000000000000000000000 -> 1.00000000000000000000000000000000E+6143
decf605 apply 1E+6142 -> #43ffc100000000000000000000000000 Clamped
decf606 apply #43ffc100000000000000000000000000 -> 1.0000000000000000000000000000000E+6142
decf607 apply 1E+6141 -> #43ffc010000000000000000000000000 Clamped
decf608 apply #43ffc010000000000000000000000000 -> 1.000000000000000000000000000000E+6141
decf609 apply 1E+6140 -> #43ffc002000000000000000000000000 Clamped
decf610 apply #43ffc002000000000000000000000000 -> 1.00000000000000000000000000000E+6140
decf611 apply 1E+6139 -> #43ffc000400000000000000000000000 Clamped
decf612 apply #43ffc000400000000000000000000000 -> 1.0000000000000000000000000000E+6139
decf613 apply 1E+6138 -> #43ffc000040000000000000000000000 Clamped
decf614 apply #43ffc000040000000000000000000000 -> 1.000000000000000000000000000E+6138
decf615 apply 1E+6137 -> #43ffc000008000000000000000000000 Clamped
decf616 apply #43ffc000008000000000000000000000 -> 1.00000000000000000000000000E+6137
decf617 apply 1E+6136 -> #43ffc000001000000000000000000000 Clamped
decf618 apply #43ffc000001000000000000000000000 -> 1.0000000000000000000000000E+6136
decf619 apply 1E+6135 -> #43ffc000000100000000000000000000 Clamped
decf620 apply #43ffc000000100000000000000000000 -> 1.000000000000000000000000E+6135
decf621 apply 1E+6134 -> #43ffc000000020000000000000000000 Clamped
decf622 apply #43ffc000000020000000000000000000 -> 1.00000000000000000000000E+6134
decf623 apply 1E+6133 -> #43ffc000000004000000000000000000 Clamped
decf624 apply #43ffc000000004000000000000000000 -> 1.0000000000000000000000E+6133
decf625 apply 1E+6132 -> #43ffc000000000400000000000000000 Clamped
decf626 apply #43ffc000000000400000000000000000 -> 1.000000000000000000000E+6132
decf627 apply 1E+6131 -> #43ffc000000000080000000000000000 Clamped
decf628 apply #43ffc000000000080000000000000000 -> 1.00000000000000000000E+6131
decf629 apply 1E+6130 -> #43ffc000000000010000000000000000 Clamped
decf630 apply #43ffc000000000010000000000000000 -> 1.0000000000000000000E+6130
decf631 apply 1E+6129 -> #43ffc000000000001000000000000000 Clamped
decf632 apply #43ffc000000000001000000000000000 -> 1.000000000000000000E+6129
decf633 apply 1E+6128 -> #43ffc000000000000200000000000000 Clamped
decf634 apply #43ffc000000000000200000000000000 -> 1.00000000000000000E+6128
decf635 apply 1E+6127 -> #43ffc000000000000040000000000000 Clamped
decf636 apply #43ffc000000000000040000000000000 -> 1.0000000000000000E+6127
decf637 apply 1E+6126 -> #43ffc000000000000004000000000000 Clamped
decf638 apply #43ffc000000000000004000000000000 -> 1.000000000000000E+6126
decf639 apply 1E+6125 -> #43ffc000000000000000800000000000 Clamped
decf640 apply #43ffc000000000000000800000000000 -> 1.00000000000000E+6125
decf641 apply 1E+6124 -> #43ffc000000000000000100000000000 Clamped
decf642 apply #43ffc000000000000000100000000000 -> 1.0000000000000E+6124
decf643 apply 1E+6123 -> #43ffc000000000000000010000000000 Clamped
decf644 apply #43ffc000000000000000010000000000 -> 1.000000000000E+6123
decf645 apply 1E+6122 -> #43ffc000000000000000002000000000 Clamped
decf646 apply #43ffc000000000000000002000000000 -> 1.00000000000E+6122
decf647 apply 1E+6121 -> #43ffc000000000000000000400000000 Clamped
decf648 apply #43ffc000000000000000000400000000 -> 1.0000000000E+6121
decf649 apply 1E+6120 -> #43ffc000000000000000000040000000 Clamped
decf650 apply #43ffc000000000000000000040000000 -> 1.000000000E+6120
decf651 apply 1E+6119 -> #43ffc000000000000000000008000000 Clamped
decf652 apply #43ffc000000000000000000008000000 -> 1.00000000E+6119
decf653 apply 1E+6118 -> #43ffc000000000000000000001000000 Clamped
decf654 apply #43ffc000000000000000000001000000 -> 1.0000000E+6118
decf655 apply 1E+6117 -> #43ffc000000000000000000000100000 Clamped
decf656 apply #43ffc000000000000000000000100000 -> 1.000000E+6117
decf657 apply 1E+6116 -> #43ffc000000000000000000000020000 Clamped
decf658 apply #43ffc000000000000000000000020000 -> 1.00000E+6116
decf659 apply 1E+6115 -> #43ffc000000000000000000000004000 Clamped
decf660 apply #43ffc000000000000000000000004000 -> 1.0000E+6115
decf661 apply 1E+6114 -> #43ffc000000000000000000000000400 Clamped
decf662 apply #43ffc000000000000000000000000400 -> 1.000E+6114
decf663 apply 1E+6113 -> #43ffc000000000000000000000000080 Clamped
decf664 apply #43ffc000000000000000000000000080 -> 1.00E+6113
decf665 apply 1E+6112 -> #43ffc000000000000000000000000010 Clamped
decf666 apply #43ffc000000000000000000000000010 -> 1.0E+6112
decf667 apply 1E+6111 -> #43ffc000000000000000000000000001
decf668 apply #43ffc000000000000000000000000001 -> 1E+6111
decf669 apply 1E+6110 -> #43ff8000000000000000000000000001
decf670 apply #43ff8000000000000000000000000001 -> 1E+6110
-- Selected DPD codes
decf700 apply #22080000000000000000000000000000 -> 0
decf701 apply #22080000000000000000000000000009 -> 9
decf702 apply #22080000000000000000000000000010 -> 10
decf703 apply #22080000000000000000000000000019 -> 19
decf704 apply #22080000000000000000000000000020 -> 20
decf705 apply #22080000000000000000000000000029 -> 29
decf706 apply #22080000000000000000000000000030 -> 30
decf707 apply #22080000000000000000000000000039 -> 39
decf708 apply #22080000000000000000000000000040 -> 40
decf709 apply #22080000000000000000000000000049 -> 49
decf710 apply #22080000000000000000000000000050 -> 50
decf711 apply #22080000000000000000000000000059 -> 59
decf712 apply #22080000000000000000000000000060 -> 60
decf713 apply #22080000000000000000000000000069 -> 69
decf714 apply #22080000000000000000000000000070 -> 70
decf715 apply #22080000000000000000000000000071 -> 71
decf716 apply #22080000000000000000000000000072 -> 72
decf717 apply #22080000000000000000000000000073 -> 73
decf718 apply #22080000000000000000000000000074 -> 74
decf719 apply #22080000000000000000000000000075 -> 75
decf720 apply #22080000000000000000000000000076 -> 76
decf721 apply #22080000000000000000000000000077 -> 77
decf722 apply #22080000000000000000000000000078 -> 78
decf723 apply #22080000000000000000000000000079 -> 79
decf730 apply #2208000000000000000000000000029e -> 994
decf731 apply #2208000000000000000000000000029f -> 995
decf732 apply #220800000000000000000000000002a0 -> 520
decf733 apply #220800000000000000000000000002a1 -> 521
-- DPD: one of each of the huffman groups
decf740 apply #220800000000000000000000000003f7 -> 777
decf741 apply #220800000000000000000000000003f8 -> 778
decf742 apply #220800000000000000000000000003eb -> 787
decf743 apply #2208000000000000000000000000037d -> 877
decf744 apply #2208000000000000000000000000039f -> 997
decf745 apply #220800000000000000000000000003bf -> 979
decf746 apply #220800000000000000000000000003df -> 799
decf747 apply #2208000000000000000000000000006e -> 888
-- DPD all-highs cases (includes the 24 redundant codes)
decf750 apply #2208000000000000000000000000006e -> 888
decf751 apply #2208000000000000000000000000016e -> 888
decf752 apply #2208000000000000000000000000026e -> 888
decf753 apply #2208000000000000000000000000036e -> 888
decf754 apply #2208000000000000000000000000006f -> 889
decf755 apply #2208000000000000000000000000016f -> 889
decf756 apply #2208000000000000000000000000026f -> 889
decf757 apply #2208000000000000000000000000036f -> 889
decf760 apply #2208000000000000000000000000007e -> 898
decf761 apply #2208000000000000000000000000017e -> 898
decf762 apply #2208000000000000000000000000027e -> 898
decf763 apply #2208000000000000000000000000037e -> 898
decf764 apply #2208000000000000000000000000007f -> 899
decf765 apply #2208000000000000000000000000017f -> 899
decf766 apply #2208000000000000000000000000027f -> 899
decf767 apply #2208000000000000000000000000037f -> 899
decf770 apply #220800000000000000000000000000ee -> 988
decf771 apply #220800000000000000000000000001ee -> 988
decf772 apply #220800000000000000000000000002ee -> 988
decf773 apply #220800000000000000000000000003ee -> 988
decf774 apply #220800000000000000000000000000ef -> 989
decf775 apply #220800000000000000000000000001ef -> 989
decf776 apply #220800000000000000000000000002ef -> 989
decf777 apply #220800000000000000000000000003ef -> 989
decf780 apply #220800000000000000000000000000fe -> 998
decf781 apply #220800000000000000000000000001fe -> 998
decf782 apply #220800000000000000000000000002fe -> 998
decf783 apply #220800000000000000000000000003fe -> 998
decf784 apply #220800000000000000000000000000ff -> 999
decf785 apply #220800000000000000000000000001ff -> 999
decf786 apply #220800000000000000000000000002ff -> 999
decf787 apply #220800000000000000000000000003ff -> 999

385
sys/lib/python/test/decimaltestdata/decimal32.decTest
View file

@ -1,385 +0,0 @@
------------------------------------------------------------------------
-- decimal32.decTest -- decimal four-byte format testcases --
-- Copyright (c) IBM Corporation, 2000, 2003. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- This set of tests is for the four-byte concrete representation.
-- Its characteristics are:
--
-- 1 bit sign
-- 5 bits combination field
-- 6 bits exponent continuation
-- 20 bits coefficient continuation
--
-- Total exponent length 8 bits
-- Total coefficient length 24 bits (7 digits)
--
-- Elimit = 191 (maximum encoded exponent)
-- Emax = 96 (largest exponent value)
-- Emin = -95 (smallest exponent value)
-- bias = 101 (subtracted from encoded exponent) = -Etiny
extended: 1
precision: 7
rounding: half_up
maxExponent: 96
minExponent: -95
-- General testcases
-- (mostly derived from the Strawman 4 document and examples)
decd001 apply #A23003D0 -> -7.50
decd002 apply -7.50 -> #A23003D0
-- Normality
decd010 apply 1234567 -> #2654d2e7
decd011 apply 1234567.0 -> #2654d2e7 Rounded
decd012 apply 1234567.1 -> #2654d2e7 Rounded Inexact
decd013 apply -1234567 -> #a654d2e7
decd014 apply -1234567.0 -> #a654d2e7 Rounded
decd015 apply -1234567.1 -> #a654d2e7 Rounded Inexact
-- Nmax and similar
decd022 apply 9.999999E+96 -> #77f3fcff
decd023 apply #77f3fcff -> 9.999999E+96
decd024 apply 1.234567E+96 -> #47f4d2e7
decd025 apply #47f4d2e7 -> 1.234567E+96
-- fold-downs (more below)
decd030 apply 1.23E+96 -> #47f4c000 Clamped
decd031 apply #47f4c000 -> 1.230000E+96
decd032 apply 1E+96 -> #47f00000 Clamped
decd033 apply #47f00000 -> 1.000000E+96
-- overflows
maxExponent: 999 -- set high so conversion causes the overflow
minExponent: -999
decd040 apply 10E+96 -> #78000000 Overflow Rounded Inexact
decd041 apply 1.000000E+97 -> #78000000 Overflow Rounded Inexact
maxExponent: 96
minExponent: -95
decd051 apply 12345 -> #225049c5
decd052 apply #225049c5 -> 12345
decd053 apply 1234 -> #22500534
decd054 apply #22500534 -> 1234
decd055 apply 123 -> #225000a3
decd056 apply #225000a3 -> 123
decd057 apply 12 -> #22500012
decd058 apply #22500012 -> 12
decd059 apply 1 -> #22500001
decd060 apply #22500001 -> 1
decd061 apply 1.23 -> #223000a3
decd062 apply #223000a3 -> 1.23
decd063 apply 123.45 -> #223049c5
decd064 apply #223049c5 -> 123.45
-- Nmin and below
decd071 apply 1E-95 -> #00600001
decd072 apply #00600001 -> 1E-95
decd073 apply 1.000000E-95 -> #04000000
decd074 apply #04000000 -> 1.000000E-95
decd075 apply 1.000001E-95 -> #04000001
decd076 apply #04000001 -> 1.000001E-95
decd077 apply 0.100000E-95 -> #00020000 Subnormal
decd07x apply 1.00000E-96 -> 1.00000E-96 Subnormal
decd078 apply #00020000 -> 1.00000E-96 Subnormal
decd079 apply 0.000010E-95 -> #00000010 Subnormal
decd080 apply #00000010 -> 1.0E-100 Subnormal
decd081 apply 0.000001E-95 -> #00000001 Subnormal
decd082 apply #00000001 -> 1E-101 Subnormal
decd083 apply 1e-101 -> #00000001 Subnormal
decd084 apply #00000001 -> 1E-101 Subnormal
decd08x apply 1e-101 -> 1E-101 Subnormal
-- underflows
decd090 apply 1e-101 -> #00000001 Subnormal
decd091 apply 1.9e-101 -> #00000002 Subnormal Underflow Inexact Rounded
decd092 apply 1.1e-101 -> #00000001 Subnormal Underflow Inexact Rounded
decd093 apply 1.001e-101 -> #00000001 Subnormal Underflow Inexact Rounded
decd094 apply 1.000001e-101 -> #00000001 Subnormal Underflow Inexact Rounded
decd095 apply 1.0000001e-101 -> #00000001 Subnormal Underflow Inexact Rounded
decd096 apply 0.1e-101 -> #00000000 Subnormal Underflow Inexact Rounded
decd097 apply 0.001e-101 -> #00000000 Subnormal Underflow Inexact Rounded
decd098 apply 0.000001e-101 -> #00000000 Subnormal Underflow Inexact Rounded
decd099 apply 0.0000001e-101 -> #00000000 Subnormal Underflow Inexact Rounded
-- same again, negatives --
-- Nmax and similar
decd122 apply -9.999999E+96 -> #f7f3fcff
decd123 apply #f7f3fcff -> -9.999999E+96
decd124 apply -1.234567E+96 -> #c7f4d2e7
decd125 apply #c7f4d2e7 -> -1.234567E+96
-- fold-downs (more below)
decd130 apply -1.23E+96 -> #c7f4c000 Clamped
decd131 apply #c7f4c000 -> -1.230000E+96
decd132 apply -1E+96 -> #c7f00000 Clamped
decd133 apply #c7f00000 -> -1.000000E+96
-- overflows
maxExponent: 999 -- set high so conversion causes the overflow
minExponent: -999
decd140 apply -10E+96 -> #f8000000 Overflow Rounded Inexact
decd141 apply -1.000000E+97 -> #f8000000 Overflow Rounded Inexact
maxExponent: 96
minExponent: -95
decd151 apply -12345 -> #a25049c5
decd152 apply #a25049c5 -> -12345
decd153 apply -1234 -> #a2500534
decd154 apply #a2500534 -> -1234
decd155 apply -123 -> #a25000a3
decd156 apply #a25000a3 -> -123
decd157 apply -12 -> #a2500012
decd158 apply #a2500012 -> -12
decd159 apply -1 -> #a2500001
decd160 apply #a2500001 -> -1
decd161 apply -1.23 -> #a23000a3
decd162 apply #a23000a3 -> -1.23
decd163 apply -123.45 -> #a23049c5
decd164 apply #a23049c5 -> -123.45
-- Nmin and below
decd171 apply -1E-95 -> #80600001
decd172 apply #80600001 -> -1E-95
decd173 apply -1.000000E-95 -> #84000000
decd174 apply #84000000 -> -1.000000E-95
decd175 apply -1.000001E-95 -> #84000001
decd176 apply #84000001 -> -1.000001E-95
decd177 apply -0.100000E-95 -> #80020000 Subnormal
decd178 apply #80020000 -> -1.00000E-96 Subnormal
decd179 apply -0.000010E-95 -> #80000010 Subnormal
decd180 apply #80000010 -> -1.0E-100 Subnormal
decd181 apply -0.000001E-95 -> #80000001 Subnormal
decd182 apply #80000001 -> -1E-101 Subnormal
decd183 apply -1e-101 -> #80000001 Subnormal
decd184 apply #80000001 -> -1E-101 Subnormal
-- underflows
decd190 apply -1e-101 -> #80000001 Subnormal
decd191 apply -1.9e-101 -> #80000002 Subnormal Underflow Inexact Rounded
decd192 apply -1.1e-101 -> #80000001 Subnormal Underflow Inexact Rounded
decd193 apply -1.001e-101 -> #80000001 Subnormal Underflow Inexact Rounded
decd194 apply -1.000001e-101 -> #80000001 Subnormal Underflow Inexact Rounded
decd195 apply -1.0000001e-101 -> #80000001 Subnormal Underflow Inexact Rounded
decd196 apply -0.1e-101 -> #80000000 Subnormal Underflow Inexact Rounded
decd197 apply -0.001e-101 -> #80000000 Subnormal Underflow Inexact Rounded
decd198 apply -0.000001e-101 -> #80000000 Subnormal Underflow Inexact Rounded
decd199 apply -0.0000001e-101 -> #80000000 Subnormal Underflow Inexact Rounded
-- zeros
decd400 apply 0E-400 -> #00000000 Clamped
decd401 apply 0E-101 -> #00000000
decd402 apply #00000000 -> 0E-101
decd403 apply 0.000000E-95 -> #00000000
decd404 apply #00000000 -> 0E-101
decd405 apply 0E-2 -> #22300000
decd406 apply #22300000 -> 0.00
decd407 apply 0 -> #22500000
decd408 apply #22500000 -> 0
decd409 apply 0E+3 -> #22800000
decd410 apply #22800000 -> 0E+3
decd411 apply 0E+90 -> #43f00000
decd412 apply #43f00000 -> 0E+90
-- clamped zeros...
decd413 apply 0E+91 -> #43f00000 Clamped
decd414 apply #43f00000 -> 0E+90
decd415 apply 0E+96 -> #43f00000 Clamped
decd416 apply #43f00000 -> 0E+90
decd417 apply 0E+400 -> #43f00000 Clamped
decd418 apply #43f00000 -> 0E+90
-- negative zeros
decd420 apply -0E-400 -> #80000000 Clamped
decd421 apply -0E-101 -> #80000000
decd422 apply #80000000 -> -0E-101
decd423 apply -0.000000E-95 -> #80000000
decd424 apply #80000000 -> -0E-101
decd425 apply -0E-2 -> #a2300000
decd426 apply #a2300000 -> -0.00
decd427 apply -0 -> #a2500000
decd428 apply #a2500000 -> -0
decd429 apply -0E+3 -> #a2800000
decd430 apply #a2800000 -> -0E+3
decd431 apply -0E+90 -> #c3f00000
decd432 apply #c3f00000 -> -0E+90
-- clamped zeros...
decd433 apply -0E+91 -> #c3f00000 Clamped
decd434 apply #c3f00000 -> -0E+90
decd435 apply -0E+96 -> #c3f00000 Clamped
decd436 apply #c3f00000 -> -0E+90
decd437 apply -0E+400 -> #c3f00000 Clamped
decd438 apply #c3f00000 -> -0E+90
-- Specials
decd500 apply Infinity -> #78000000
decd501 apply #78787878 -> #78000000
decd502 apply #78000000 -> Infinity
decd503 apply #79797979 -> #78000000
decd504 apply #79000000 -> Infinity
decd505 apply #7a7a7a7a -> #78000000
decd506 apply #7a000000 -> Infinity
decd507 apply #7b7b7b7b -> #78000000
decd508 apply #7b000000 -> Infinity
decd509 apply #7c7c7c7c -> #7c0c7c7c
decd510 apply NaN -> #7c000000
decd511 apply #7c000000 -> NaN
decd512 apply #7d7d7d7d -> #7c0d7d7d
decd513 apply #7d000000 -> NaN
decd514 apply #7e7e7e7e -> #7e0e7c7e
decd515 apply #7e000000 -> sNaN
decd516 apply #7f7f7f7f -> #7e0f7c7f
decd517 apply #7f000000 -> sNaN
decd518 apply #7fffffff -> sNaN999999
decd519 apply #7fffffff -> #7e03fcff
decd520 apply -Infinity -> #f8000000
decd521 apply #f8787878 -> #f8000000
decd522 apply #f8000000 -> -Infinity
decd523 apply #f9797979 -> #f8000000
decd524 apply #f9000000 -> -Infinity
decd525 apply #fa7a7a7a -> #f8000000
decd526 apply #fa000000 -> -Infinity
decd527 apply #fb7b7b7b -> #f8000000
decd528 apply #fb000000 -> -Infinity
decd529 apply -NaN -> #fc000000
decd530 apply #fc7c7c7c -> #fc0c7c7c
decd531 apply #fc000000 -> -NaN
decd532 apply #fd7d7d7d -> #fc0d7d7d
decd533 apply #fd000000 -> -NaN
decd534 apply #fe7e7e7e -> #fe0e7c7e
decd535 apply #fe000000 -> -sNaN
decd536 apply #ff7f7f7f -> #fe0f7c7f
decd537 apply #ff000000 -> -sNaN
decd538 apply #ffffffff -> -sNaN999999
decd539 apply #ffffffff -> #fe03fcff
-- diagnostic NaNs
decd540 apply NaN -> #7c000000
decd541 apply NaN0 -> #7c000000
decd542 apply NaN1 -> #7c000001
decd543 apply NaN12 -> #7c000012
decd544 apply NaN79 -> #7c000079
decd545 apply NaN12345 -> #7c0049c5
decd546 apply NaN123456 -> #7c028e56
decd547 apply NaN799799 -> #7c0f7fdf
decd548 apply NaN999999 -> #7c03fcff
decd549 apply NaN1234567 -> #7c000000 -- too many digits
-- fold-down full sequence
decd601 apply 1E+96 -> #47f00000 Clamped
decd602 apply #47f00000 -> 1.000000E+96
decd603 apply 1E+95 -> #43f20000 Clamped
decd604 apply #43f20000 -> 1.00000E+95
decd605 apply 1E+94 -> #43f04000 Clamped
decd606 apply #43f04000 -> 1.0000E+94
decd607 apply 1E+93 -> #43f00400 Clamped
decd608 apply #43f00400 -> 1.000E+93
decd609 apply 1E+92 -> #43f00080 Clamped
decd610 apply #43f00080 -> 1.00E+92
decd611 apply 1E+91 -> #43f00010 Clamped
decd612 apply #43f00010 -> 1.0E+91
decd613 apply 1E+90 -> #43f00001
decd614 apply #43f00001 -> 1E+90
-- Selected DPD codes
decd700 apply #22500000 -> 0
decd701 apply #22500009 -> 9
decd702 apply #22500010 -> 10
decd703 apply #22500019 -> 19
decd704 apply #22500020 -> 20
decd705 apply #22500029 -> 29
decd706 apply #22500030 -> 30
decd707 apply #22500039 -> 39
decd708 apply #22500040 -> 40
decd709 apply #22500049 -> 49
decd710 apply #22500050 -> 50
decd711 apply #22500059 -> 59
decd712 apply #22500060 -> 60
decd713 apply #22500069 -> 69
decd714 apply #22500070 -> 70
decd715 apply #22500071 -> 71
decd716 apply #22500072 -> 72
decd717 apply #22500073 -> 73
decd718 apply #22500074 -> 74
decd719 apply #22500075 -> 75
decd720 apply #22500076 -> 76
decd721 apply #22500077 -> 77
decd722 apply #22500078 -> 78
decd723 apply #22500079 -> 79
decd730 apply #2250029e -> 994
decd731 apply #2250029f -> 995
decd732 apply #225002a0 -> 520
decd733 apply #225002a1 -> 521
-- DPD: one of each of the huffman groups
decd740 apply #225003f7 -> 777
decd741 apply #225003f8 -> 778
decd742 apply #225003eb -> 787
decd743 apply #2250037d -> 877
decd744 apply #2250039f -> 997
decd745 apply #225003bf -> 979
decd746 apply #225003df -> 799
decd747 apply #2250006e -> 888
-- DPD all-highs cases (includes the 24 redundant codes)
decd750 apply #2250006e -> 888
decd751 apply #2250016e -> 888
decd752 apply #2250026e -> 888
decd753 apply #2250036e -> 888
decd754 apply #2250006f -> 889
decd755 apply #2250016f -> 889
decd756 apply #2250026f -> 889
decd757 apply #2250036f -> 889
decd760 apply #2250007e -> 898
decd761 apply #2250017e -> 898
decd762 apply #2250027e -> 898
decd763 apply #2250037e -> 898
decd764 apply #2250007f -> 899
decd765 apply #2250017f -> 899
decd766 apply #2250027f -> 899
decd767 apply #2250037f -> 899
decd770 apply #225000ee -> 988
decd771 apply #225001ee -> 988
decd772 apply #225002ee -> 988
decd773 apply #225003ee -> 988
decd774 apply #225000ef -> 989
decd775 apply #225001ef -> 989
decd776 apply #225002ef -> 989
decd777 apply #225003ef -> 989
decd780 apply #225000fe -> 998
decd781 apply #225001fe -> 998
decd782 apply #225002fe -> 998
decd783 apply #225003fe -> 998
decd784 apply #225000ff -> 999
decd785 apply #225001ff -> 999
decd786 apply #225002ff -> 999
decd787 apply #225003ff -> 999

444
sys/lib/python/test/decimaltestdata/decimal64.decTest
View file

@ -1,444 +0,0 @@
------------------------------------------------------------------------
-- decimal64.decTest -- decimal eight-byte format testcases --
-- Copyright (c) IBM Corporation, 2000, 2003. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- This set of tests is for the eight-byte concrete representation.
-- Its characteristics are:
--
-- 1 bit sign
-- 5 bits combination field
-- 8 bits exponent continuation
-- 50 bits coefficient continuation
--
-- Total exponent length 10 bits
-- Total coefficient length 54 bits (16 digits)
--
-- Elimit = 767 (maximum encoded exponent)
-- Emax = 384 (largest exponent value)
-- Emin = -383 (smallest exponent value)
-- bias = 398 (subtracted from encoded exponent) = -Etiny
extended: 1
precision: 16
rounding: half_up
maxExponent: 384
minExponent: -383
-- General testcases
-- (mostly derived from the Strawman 4 document and examples)
dece001 apply #A2300000000003D0 -> -7.50
dece002 apply -7.50 -> #A2300000000003D0
-- Normality
dece010 apply 1234567890123456 -> #263934b9c1e28e56
dece011 apply 1234567890123456.0 -> #263934b9c1e28e56 Rounded
dece012 apply 1234567890123456.1 -> #263934b9c1e28e56 Rounded Inexact
dece013 apply -1234567890123456 -> #a63934b9c1e28e56
dece014 apply -1234567890123456.0 -> #a63934b9c1e28e56 Rounded
dece015 apply -1234567890123456.1 -> #a63934b9c1e28e56 Rounded Inexact
-- Nmax and similar
dece022 apply 9.999999999999999E+384 -> #77fcff3fcff3fcff
dece023 apply #77fcff3fcff3fcff -> 9.999999999999999E+384
dece024 apply 1.234567890123456E+384 -> #47fd34b9c1e28e56
dece025 apply #47fd34b9c1e28e56 -> 1.234567890123456E+384
-- fold-downs (more below)
dece030 apply 1.23E+384 -> #47fd300000000000 Clamped
dece031 apply #47fd300000000000 -> 1.230000000000000E+384
dece032 apply 1E+384 -> #47fc000000000000 Clamped
dece033 apply #47fc000000000000 -> 1.000000000000000E+384
-- overflows
maxExponent: 999 -- set high so conversion causes the overflow
minExponent: -999
dece040 apply 10E+384 -> #7800000000000000 Overflow Rounded Inexact
dece041 apply 1.000000000000000E+385 -> #7800000000000000 Overflow Rounded Inexact
maxExponent: 384
minExponent: -383
dece051 apply 12345 -> #22380000000049c5
dece052 apply #22380000000049c5 -> 12345
dece053 apply 1234 -> #2238000000000534
dece054 apply #2238000000000534 -> 1234
dece055 apply 123 -> #22380000000000a3
dece056 apply #22380000000000a3 -> 123
dece057 apply 12 -> #2238000000000012
dece058 apply #2238000000000012 -> 12
dece059 apply 1 -> #2238000000000001
dece060 apply #2238000000000001 -> 1
dece061 apply 1.23 -> #22300000000000a3
dece062 apply #22300000000000a3 -> 1.23
dece063 apply 123.45 -> #22300000000049c5
dece064 apply #22300000000049c5 -> 123.45
-- Nmin and below
dece071 apply 1E-383 -> #003c000000000001
dece072 apply #003c000000000001 -> 1E-383
dece073 apply 1.000000000000000E-383 -> #0400000000000000
dece074 apply #0400000000000000 -> 1.000000000000000E-383
dece075 apply 1.000000000000001E-383 -> #0400000000000001
dece076 apply #0400000000000001 -> 1.000000000000001E-383
dece077 apply 0.100000000000000E-383 -> #0000800000000000 Subnormal
dece078 apply #0000800000000000 -> 1.00000000000000E-384 Subnormal
dece079 apply 0.000000000000010E-383 -> #0000000000000010 Subnormal
dece080 apply #0000000000000010 -> 1.0E-397 Subnormal
dece081 apply 0.00000000000001E-383 -> #0004000000000001 Subnormal
dece082 apply #0004000000000001 -> 1E-397 Subnormal
dece083 apply 0.000000000000001E-383 -> #0000000000000001 Subnormal
dece084 apply #0000000000000001 -> 1E-398 Subnormal
-- underflows
dece090 apply 1e-398 -> #0000000000000001 Subnormal
dece091 apply 1.9e-398 -> #0000000000000002 Subnormal Underflow Inexact Rounded
dece092 apply 1.1e-398 -> #0000000000000001 Subnormal Underflow Inexact Rounded
dece093 apply 1.00000000001e-398 -> #0000000000000001 Subnormal Underflow Inexact Rounded
dece094 apply 1.00000000000001e-398 -> #0000000000000001 Subnormal Underflow Inexact Rounded
dece095 apply 1.000000000000001e-398 -> #0000000000000001 Subnormal Underflow Inexact Rounded
dece096 apply 0.1e-398 -> #0000000000000000 Subnormal Underflow Inexact Rounded
dece097 apply 0.00000000001e-398 -> #0000000000000000 Subnormal Underflow Inexact Rounded
dece098 apply 0.00000000000001e-398 -> #0000000000000000 Subnormal Underflow Inexact Rounded
dece099 apply 0.000000000000001e-398 -> #0000000000000000 Subnormal Underflow Inexact Rounded
-- Same again, negatives
-- Nmax and similar
dece122 apply -9.999999999999999E+384 -> #f7fcff3fcff3fcff
dece123 apply #f7fcff3fcff3fcff -> -9.999999999999999E+384
dece124 apply -1.234567890123456E+384 -> #c7fd34b9c1e28e56
dece125 apply #c7fd34b9c1e28e56 -> -1.234567890123456E+384
-- fold-downs (more below)
dece130 apply -1.23E+384 -> #c7fd300000000000 Clamped
dece131 apply #c7fd300000000000 -> -1.230000000000000E+384
dece132 apply -1E+384 -> #c7fc000000000000 Clamped
dece133 apply #c7fc000000000000 -> -1.000000000000000E+384
-- overflows
maxExponent: 999 -- set high so conversion causes the overflow
minExponent: -999
dece140 apply -10E+384 -> #f800000000000000 Overflow Rounded Inexact
dece141 apply -1.000000000000000E+385 -> #f800000000000000 Overflow Rounded Inexact
maxExponent: 384
minExponent: -383
dece151 apply -12345 -> #a2380000000049c5
dece152 apply #a2380000000049c5 -> -12345
dece153 apply -1234 -> #a238000000000534
dece154 apply #a238000000000534 -> -1234
dece155 apply -123 -> #a2380000000000a3
dece156 apply #a2380000000000a3 -> -123
dece157 apply -12 -> #a238000000000012
dece158 apply #a238000000000012 -> -12
dece159 apply -1 -> #a238000000000001
dece160 apply #a238000000000001 -> -1
dece161 apply -1.23 -> #a2300000000000a3
dece162 apply #a2300000000000a3 -> -1.23
dece163 apply -123.45 -> #a2300000000049c5
dece164 apply #a2300000000049c5 -> -123.45
-- Nmin and below
dece171 apply -1E-383 -> #803c000000000001
dece172 apply #803c000000000001 -> -1E-383
dece173 apply -1.000000000000000E-383 -> #8400000000000000
dece174 apply #8400000000000000 -> -1.000000000000000E-383
dece175 apply -1.000000000000001E-383 -> #8400000000000001
dece176 apply #8400000000000001 -> -1.000000000000001E-383
dece177 apply -0.100000000000000E-383 -> #8000800000000000 Subnormal
dece178 apply #8000800000000000 -> -1.00000000000000E-384 Subnormal
dece179 apply -0.000000000000010E-383 -> #8000000000000010 Subnormal
dece180 apply #8000000000000010 -> -1.0E-397 Subnormal
dece181 apply -0.00000000000001E-383 -> #8004000000000001 Subnormal
dece182 apply #8004000000000001 -> -1E-397 Subnormal
dece183 apply -0.000000000000001E-383 -> #8000000000000001 Subnormal
dece184 apply #8000000000000001 -> -1E-398 Subnormal
-- underflows
dece189 apply -1e-398 -> #8000000000000001 Subnormal
dece190 apply -1.0e-398 -> #8000000000000001 Subnormal Rounded
dece191 apply -1.9e-398 -> #8000000000000002 Subnormal Underflow Inexact Rounded
dece192 apply -1.1e-398 -> #8000000000000001 Subnormal Underflow Inexact Rounded
dece193 apply -1.00000000001e-398 -> #8000000000000001 Subnormal Underflow Inexact Rounded
dece194 apply -1.00000000000001e-398 -> #8000000000000001 Subnormal Underflow Inexact Rounded
dece195 apply -1.000000000000001e-398 -> #8000000000000001 Subnormal Underflow Inexact Rounded
dece196 apply -0.1e-398 -> #8000000000000000 Subnormal Underflow Inexact Rounded
dece197 apply -0.00000000001e-398 -> #8000000000000000 Subnormal Underflow Inexact Rounded
dece198 apply -0.00000000000001e-398 -> #8000000000000000 Subnormal Underflow Inexact Rounded
dece199 apply -0.000000000000001e-398 -> #8000000000000000 Subnormal Underflow Inexact Rounded
-- zeros
dece401 apply 0E-500 -> #0000000000000000 Clamped
dece402 apply 0E-400 -> #0000000000000000 Clamped
dece403 apply 0E-398 -> #0000000000000000
dece404 apply #0000000000000000 -> 0E-398
dece405 apply 0.000000000000000E-383 -> #0000000000000000
dece406 apply #0000000000000000 -> 0E-398
dece407 apply 0E-2 -> #2230000000000000
dece408 apply #2230000000000000 -> 0.00
dece409 apply 0 -> #2238000000000000
dece410 apply #2238000000000000 -> 0
dece411 apply 0E+3 -> #2244000000000000
dece412 apply #2244000000000000 -> 0E+3
dece413 apply 0E+369 -> #43fc000000000000
dece414 apply #43fc000000000000 -> 0E+369
-- clamped zeros...
dece415 apply 0E+370 -> #43fc000000000000 Clamped
dece416 apply #43fc000000000000 -> 0E+369
dece417 apply 0E+384 -> #43fc000000000000 Clamped
dece418 apply #43fc000000000000 -> 0E+369
dece419 apply 0E+400 -> #43fc000000000000 Clamped
dece420 apply #43fc000000000000 -> 0E+369
dece421 apply 0E+500 -> #43fc000000000000 Clamped
dece422 apply #43fc000000000000 -> 0E+369
-- negative zeros
dece431 apply -0E-400 -> #8000000000000000 Clamped
dece432 apply -0E-400 -> #8000000000000000 Clamped
dece433 apply -0E-398 -> #8000000000000000
dece434 apply #8000000000000000 -> -0E-398
dece435 apply -0.000000000000000E-383 -> #8000000000000000
dece436 apply #8000000000000000 -> -0E-398
dece437 apply -0E-2 -> #a230000000000000
dece438 apply #a230000000000000 -> -0.00
dece439 apply -0 -> #a238000000000000
dece440 apply #a238000000000000 -> -0
dece441 apply -0E+3 -> #a244000000000000
dece442 apply #a244000000000000 -> -0E+3
dece443 apply -0E+369 -> #c3fc000000000000
dece444 apply #c3fc000000000000 -> -0E+369
-- clamped zeros...
dece445 apply -0E+370 -> #c3fc000000000000 Clamped
dece446 apply #c3fc000000000000 -> -0E+369
dece447 apply -0E+384 -> #c3fc000000000000 Clamped
dece448 apply #c3fc000000000000 -> -0E+369
dece449 apply -0E+400 -> #c3fc000000000000 Clamped
dece450 apply #c3fc000000000000 -> -0E+369
dece451 apply -0E+500 -> #c3fc000000000000 Clamped
dece452 apply #c3fc000000000000 -> -0E+369
-- Specials
dece500 apply Infinity -> #7800000000000000
dece501 apply #7878787878787878 -> #7800000000000000
dece502 apply #7800000000000000 -> Infinity
dece503 apply #7979797979797979 -> #7800000000000000
dece504 apply #7900000000000000 -> Infinity
dece505 apply #7a7a7a7a7a7a7a7a -> #7800000000000000
dece506 apply #7a00000000000000 -> Infinity
dece507 apply #7b7b7b7b7b7b7b7b -> #7800000000000000
dece508 apply #7b00000000000000 -> Infinity
dece509 apply NaN -> #7c00000000000000
dece510 apply #7c7c7c7c7c7c7c7c -> #7c007c7c7c7c7c7c
dece511 apply #7c00000000000000 -> NaN
dece512 apply #7d7d7d7d7d7d7d7d -> #7c017d7d7d7d7d7d
dece513 apply #7d00000000000000 -> NaN
dece514 apply #7e7e7e7e7e7e7e7e -> #7e007e7e7e7e7c7e
dece515 apply #7e00000000000000 -> sNaN
dece516 apply #7f7f7f7f7f7f7f7f -> #7e007f7f7f7f7c7f
dece517 apply #7f00000000000000 -> sNaN
dece518 apply #7fffffffffffffff -> sNaN999999999999999
dece519 apply #7fffffffffffffff -> #7e00ff3fcff3fcff
dece520 apply -Infinity -> #f800000000000000
dece521 apply #f878787878787878 -> #f800000000000000
dece522 apply #f800000000000000 -> -Infinity
dece523 apply #f979797979797979 -> #f800000000000000
dece524 apply #f900000000000000 -> -Infinity
dece525 apply #fa7a7a7a7a7a7a7a -> #f800000000000000
dece526 apply #fa00000000000000 -> -Infinity
dece527 apply #fb7b7b7b7b7b7b7b -> #f800000000000000
dece528 apply #fb00000000000000 -> -Infinity
dece529 apply -NaN -> #fc00000000000000
dece530 apply #fc7c7c7c7c7c7c7c -> #fc007c7c7c7c7c7c
dece531 apply #fc00000000000000 -> -NaN
dece532 apply #fd7d7d7d7d7d7d7d -> #fc017d7d7d7d7d7d
dece533 apply #fd00000000000000 -> -NaN
dece534 apply #fe7e7e7e7e7e7e7e -> #fe007e7e7e7e7c7e
dece535 apply #fe00000000000000 -> -sNaN
dece536 apply #ff7f7f7f7f7f7f7f -> #fe007f7f7f7f7c7f
dece537 apply #ff00000000000000 -> -sNaN
dece538 apply #ffffffffffffffff -> -sNaN999999999999999
dece539 apply #ffffffffffffffff -> #fe00ff3fcff3fcff
-- diagnostic NaNs
dece540 apply NaN -> #7c00000000000000
dece541 apply NaN0 -> #7c00000000000000
dece542 apply NaN1 -> #7c00000000000001
dece543 apply NaN12 -> #7c00000000000012
dece544 apply NaN79 -> #7c00000000000079
dece545 apply NaN12345 -> #7c000000000049c5
dece546 apply NaN123456 -> #7c00000000028e56
dece547 apply NaN799799 -> #7c000000000f7fdf
dece548 apply NaN799799799799799 -> #7c03dff7fdff7fdf
dece549 apply NaN999999999999999 -> #7c00ff3fcff3fcff
dece550 apply NaN1234567890123456 -> #7c00000000000000 -- too many digits
-- fold-down full sequence
dece601 apply 1E+384 -> #47fc000000000000 Clamped
dece602 apply #47fc000000000000 -> 1.000000000000000E+384
dece603 apply 1E+383 -> #43fc800000000000 Clamped
dece604 apply #43fc800000000000 -> 1.00000000000000E+383
dece605 apply 1E+382 -> #43fc100000000000 Clamped
dece606 apply #43fc100000000000 -> 1.0000000000000E+382
dece607 apply 1E+381 -> #43fc010000000000 Clamped
dece608 apply #43fc010000000000 -> 1.000000000000E+381
dece609 apply 1E+380 -> #43fc002000000000 Clamped
dece610 apply #43fc002000000000 -> 1.00000000000E+380
dece611 apply 1E+379 -> #43fc000400000000 Clamped
dece612 apply #43fc000400000000 -> 1.0000000000E+379
dece613 apply 1E+378 -> #43fc000040000000 Clamped
dece614 apply #43fc000040000000 -> 1.000000000E+378
dece615 apply 1E+377 -> #43fc000008000000 Clamped
dece616 apply #43fc000008000000 -> 1.00000000E+377
dece617 apply 1E+376 -> #43fc000001000000 Clamped
dece618 apply #43fc000001000000 -> 1.0000000E+376
dece619 apply 1E+375 -> #43fc000000100000 Clamped
dece620 apply #43fc000000100000 -> 1.000000E+375
dece621 apply 1E+374 -> #43fc000000020000 Clamped
dece622 apply #43fc000000020000 -> 1.00000E+374
dece623 apply 1E+373 -> #43fc000000004000 Clamped
dece624 apply #43fc000000004000 -> 1.0000E+373
dece625 apply 1E+372 -> #43fc000000000400 Clamped
dece626 apply #43fc000000000400 -> 1.000E+372
dece627 apply 1E+371 -> #43fc000000000080 Clamped
dece628 apply #43fc000000000080 -> 1.00E+371
dece629 apply 1E+370 -> #43fc000000000010 Clamped
dece630 apply #43fc000000000010 -> 1.0E+370
dece631 apply 1E+369 -> #43fc000000000001
dece632 apply #43fc000000000001 -> 1E+369
dece633 apply 1E+368 -> #43f8000000000001
dece634 apply #43f8000000000001 -> 1E+368
-- same with 9s
dece641 apply 9E+384 -> #77fc000000000000 Clamped
dece642 apply #77fc000000000000 -> 9.000000000000000E+384
dece643 apply 9E+383 -> #43fc8c0000000000 Clamped
dece644 apply #43fc8c0000000000 -> 9.00000000000000E+383
dece645 apply 9E+382 -> #43fc1a0000000000 Clamped
dece646 apply #43fc1a0000000000 -> 9.0000000000000E+382
dece647 apply 9E+381 -> #43fc090000000000 Clamped
dece648 apply #43fc090000000000 -> 9.000000000000E+381
dece649 apply 9E+380 -> #43fc002300000000 Clamped
dece650 apply #43fc002300000000 -> 9.00000000000E+380
dece651 apply 9E+379 -> #43fc000680000000 Clamped
dece652 apply #43fc000680000000 -> 9.0000000000E+379
dece653 apply 9E+378 -> #43fc000240000000 Clamped
dece654 apply #43fc000240000000 -> 9.000000000E+378
dece655 apply 9E+377 -> #43fc000008c00000 Clamped
dece656 apply #43fc000008c00000 -> 9.00000000E+377
dece657 apply 9E+376 -> #43fc000001a00000 Clamped
dece658 apply #43fc000001a00000 -> 9.0000000E+376
dece659 apply 9E+375 -> #43fc000000900000 Clamped
dece660 apply #43fc000000900000 -> 9.000000E+375
dece661 apply 9E+374 -> #43fc000000023000 Clamped
dece662 apply #43fc000000023000 -> 9.00000E+374
dece663 apply 9E+373 -> #43fc000000006800 Clamped
dece664 apply #43fc000000006800 -> 9.0000E+373
dece665 apply 9E+372 -> #43fc000000002400 Clamped
dece666 apply #43fc000000002400 -> 9.000E+372
dece667 apply 9E+371 -> #43fc00000000008c Clamped
dece668 apply #43fc00000000008c -> 9.00E+371
dece669 apply 9E+370 -> #43fc00000000001a Clamped
dece670 apply #43fc00000000001a -> 9.0E+370
dece671 apply 9E+369 -> #43fc000000000009
dece672 apply #43fc000000000009 -> 9E+369
dece673 apply 9E+368 -> #43f8000000000009
dece674 apply #43f8000000000009 -> 9E+368
-- Selected DPD codes
dece700 apply #2238000000000000 -> 0
dece701 apply #2238000000000009 -> 9
dece702 apply #2238000000000010 -> 10
dece703 apply #2238000000000019 -> 19
dece704 apply #2238000000000020 -> 20
dece705 apply #2238000000000029 -> 29
dece706 apply #2238000000000030 -> 30
dece707 apply #2238000000000039 -> 39
dece708 apply #2238000000000040 -> 40
dece709 apply #2238000000000049 -> 49
dece710 apply #2238000000000050 -> 50
dece711 apply #2238000000000059 -> 59
dece712 apply #2238000000000060 -> 60
dece713 apply #2238000000000069 -> 69
dece714 apply #2238000000000070 -> 70
dece715 apply #2238000000000071 -> 71
dece716 apply #2238000000000072 -> 72
dece717 apply #2238000000000073 -> 73
dece718 apply #2238000000000074 -> 74
dece719 apply #2238000000000075 -> 75
dece720 apply #2238000000000076 -> 76
dece721 apply #2238000000000077 -> 77
dece722 apply #2238000000000078 -> 78
dece723 apply #2238000000000079 -> 79
dece730 apply #223800000000029e -> 994
dece731 apply #223800000000029f -> 995
dece732 apply #22380000000002a0 -> 520
dece733 apply #22380000000002a1 -> 521
-- DPD: one of each of the huffman groups
dece740 apply #22380000000003f7 -> 777
dece741 apply #22380000000003f8 -> 778
dece742 apply #22380000000003eb -> 787
dece743 apply #223800000000037d -> 877
dece744 apply #223800000000039f -> 997
dece745 apply #22380000000003bf -> 979
dece746 apply #22380000000003df -> 799
dece747 apply #223800000000006e -> 888
-- DPD all-highs cases (includes the 24 redundant codes)
dece750 apply #223800000000006e -> 888
dece751 apply #223800000000016e -> 888
dece752 apply #223800000000026e -> 888
dece753 apply #223800000000036e -> 888
dece754 apply #223800000000006f -> 889
dece755 apply #223800000000016f -> 889
dece756 apply #223800000000026f -> 889
dece757 apply #223800000000036f -> 889
dece760 apply #223800000000007e -> 898
dece761 apply #223800000000017e -> 898
dece762 apply #223800000000027e -> 898
dece763 apply #223800000000037e -> 898
dece764 apply #223800000000007f -> 899
dece765 apply #223800000000017f -> 899
dece766 apply #223800000000027f -> 899
dece767 apply #223800000000037f -> 899
dece770 apply #22380000000000ee -> 988
dece771 apply #22380000000001ee -> 988
dece772 apply #22380000000002ee -> 988
dece773 apply #22380000000003ee -> 988
dece774 apply #22380000000000ef -> 989
dece775 apply #22380000000001ef -> 989
dece776 apply #22380000000002ef -> 989
dece777 apply #22380000000003ef -> 989
dece780 apply #22380000000000fe -> 998
dece781 apply #22380000000001fe -> 998
dece782 apply #22380000000002fe -> 998
dece783 apply #22380000000003fe -> 998
dece784 apply #22380000000000ff -> 999
dece785 apply #22380000000001ff -> 999
dece786 apply #22380000000002ff -> 999
dece787 apply #22380000000003ff -> 999

818
sys/lib/python/test/decimaltestdata/divide.decTest
View file

@ -1,818 +0,0 @@
------------------------------------------------------------------------
-- divide.decTest -- decimal division --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
extended: 1
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
-- sanity checks
divx001 divide 1 1 -> 1
divx002 divide 2 1 -> 2
divx003 divide 1 2 -> 0.5
divx004 divide 2 2 -> 1
divx005 divide 0 1 -> 0
divx006 divide 0 2 -> 0
divx007 divide 1 3 -> 0.333333333 Inexact Rounded
divx008 divide 2 3 -> 0.666666667 Inexact Rounded
divx009 divide 3 3 -> 1
divx010 divide 2.4 1 -> 2.4
divx011 divide 2.4 -1 -> -2.4
divx012 divide -2.4 1 -> -2.4
divx013 divide -2.4 -1 -> 2.4
divx014 divide 2.40 1 -> 2.40
divx015 divide 2.400 1 -> 2.400
divx016 divide 2.4 2 -> 1.2
divx017 divide 2.400 2 -> 1.200
divx018 divide 2. 2 -> 1
divx019 divide 20 20 -> 1
divx020 divide 187 187 -> 1
divx021 divide 5 2 -> 2.5
divx022 divide 5 2.0 -> 2.5
divx023 divide 5 2.000 -> 2.5
divx024 divide 5 0.20 -> 25
divx025 divide 5 0.200 -> 25
divx026 divide 10 1 -> 10
divx027 divide 100 1 -> 100
divx028 divide 1000 1 -> 1000
divx029 divide 1000 100 -> 10
divx030 divide 1 2 -> 0.5
divx031 divide 1 4 -> 0.25
divx032 divide 1 8 -> 0.125
divx033 divide 1 16 -> 0.0625
divx034 divide 1 32 -> 0.03125
divx035 divide 1 64 -> 0.015625
divx040 divide 1 -2 -> -0.5
divx041 divide 1 -4 -> -0.25
divx042 divide 1 -8 -> -0.125
divx043 divide 1 -16 -> -0.0625
divx044 divide 1 -32 -> -0.03125
divx045 divide 1 -64 -> -0.015625
divx050 divide -1 2 -> -0.5
divx051 divide -1 4 -> -0.25
divx052 divide -1 8 -> -0.125
divx053 divide -1 16 -> -0.0625
divx054 divide -1 32 -> -0.03125
divx055 divide -1 64 -> -0.015625
divx060 divide -1 -2 -> 0.5
divx061 divide -1 -4 -> 0.25
divx062 divide -1 -8 -> 0.125
divx063 divide -1 -16 -> 0.0625
divx064 divide -1 -32 -> 0.03125
divx065 divide -1 -64 -> 0.015625
divx070 divide 999999999 1 -> 999999999
divx071 divide 999999999.4 1 -> 999999999 Inexact Rounded
divx072 divide 999999999.5 1 -> 1.00000000E+9 Inexact Rounded
divx073 divide 999999999.9 1 -> 1.00000000E+9 Inexact Rounded
divx074 divide 999999999.999 1 -> 1.00000000E+9 Inexact Rounded
precision: 6
divx080 divide 999999999 1 -> 1.00000E+9 Inexact Rounded
divx081 divide 99999999 1 -> 1.00000E+8 Inexact Rounded
divx082 divide 9999999 1 -> 1.00000E+7 Inexact Rounded
divx083 divide 999999 1 -> 999999
divx084 divide 99999 1 -> 99999
divx085 divide 9999 1 -> 9999
divx086 divide 999 1 -> 999
divx087 divide 99 1 -> 99
divx088 divide 9 1 -> 9
precision: 9
divx090 divide 0. 1 -> 0
divx091 divide .0 1 -> 0.0
divx092 divide 0.00 1 -> 0.00
divx093 divide 0.00E+9 1 -> 0E+7
divx094 divide 0.0000E-50 1 -> 0E-54
divx095 divide 1 1E-8 -> 1E+8
divx096 divide 1 1E-9 -> 1E+9
divx097 divide 1 1E-10 -> 1E+10
divx098 divide 1 1E-11 -> 1E+11
divx099 divide 1 1E-12 -> 1E+12
divx100 divide 1 1 -> 1
divx101 divide 1 2 -> 0.5
divx102 divide 1 3 -> 0.333333333 Inexact Rounded
divx103 divide 1 4 -> 0.25
divx104 divide 1 5 -> 0.2
divx105 divide 1 6 -> 0.166666667 Inexact Rounded
divx106 divide 1 7 -> 0.142857143 Inexact Rounded
divx107 divide 1 8 -> 0.125
divx108 divide 1 9 -> 0.111111111 Inexact Rounded
divx109 divide 1 10 -> 0.1
divx110 divide 1 1 -> 1
divx111 divide 2 1 -> 2
divx112 divide 3 1 -> 3
divx113 divide 4 1 -> 4
divx114 divide 5 1 -> 5
divx115 divide 6 1 -> 6
divx116 divide 7 1 -> 7
divx117 divide 8 1 -> 8
divx118 divide 9 1 -> 9
divx119 divide 10 1 -> 10
divx120 divide 3E+1 0.001 -> 3E+4
divx121 divide 2.200 2 -> 1.100
divx130 divide 12345 4.999 -> 2469.49390 Inexact Rounded
divx131 divide 12345 4.99 -> 2473.94790 Inexact Rounded
divx132 divide 12345 4.9 -> 2519.38776 Inexact Rounded
divx133 divide 12345 5 -> 2469
divx134 divide 12345 5.1 -> 2420.58824 Inexact Rounded
divx135 divide 12345 5.01 -> 2464.07186 Inexact Rounded
divx136 divide 12345 5.001 -> 2468.50630 Inexact Rounded
precision: 9
maxexponent: 999999999
minexponent: -999999999
-- test possibly imprecise results
divx220 divide 391 597 -> 0.654941374 Inexact Rounded
divx221 divide 391 -597 -> -0.654941374 Inexact Rounded
divx222 divide -391 597 -> -0.654941374 Inexact Rounded
divx223 divide -391 -597 -> 0.654941374 Inexact Rounded
-- test some cases that are close to exponent overflow
maxexponent: 999999999
minexponent: -999999999
divx270 divide 1 1e999999999 -> 1E-999999999
divx271 divide 1 0.9e999999999 -> 1.11111111E-999999999 Inexact Rounded
divx272 divide 1 0.99e999999999 -> 1.01010101E-999999999 Inexact Rounded
divx273 divide 1 0.999999999e999999999 -> 1.00000000E-999999999 Inexact Rounded
divx274 divide 9e999999999 1 -> 9E+999999999
divx275 divide 9.9e999999999 1 -> 9.9E+999999999
divx276 divide 9.99e999999999 1 -> 9.99E+999999999
divx277 divide 9.99999999e999999999 1 -> 9.99999999E+999999999
divx280 divide 0.1 9e-999999999 -> 1.11111111E+999999997 Inexact Rounded
divx281 divide 0.1 99e-999999999 -> 1.01010101E+999999996 Inexact Rounded
divx282 divide 0.1 999e-999999999 -> 1.00100100E+999999995 Inexact Rounded
divx283 divide 0.1 9e-999999998 -> 1.11111111E+999999996 Inexact Rounded
divx284 divide 0.1 99e-999999998 -> 1.01010101E+999999995 Inexact Rounded
divx285 divide 0.1 999e-999999998 -> 1.00100100E+999999994 Inexact Rounded
divx286 divide 0.1 999e-999999997 -> 1.00100100E+999999993 Inexact Rounded
divx287 divide 0.1 9999e-999999997 -> 1.00010001E+999999992 Inexact Rounded
divx288 divide 0.1 99999e-999999997 -> 1.00001000E+999999991 Inexact Rounded
-- Divide into 0 tests
divx301 divide 0 7 -> 0
divx302 divide 0 7E-5 -> 0E+5
divx303 divide 0 7E-1 -> 0E+1
divx304 divide 0 7E+1 -> 0.0
divx305 divide 0 7E+5 -> 0.00000
divx306 divide 0 7E+6 -> 0.000000
divx307 divide 0 7E+7 -> 0E-7
divx308 divide 0 70E-5 -> 0E+5
divx309 divide 0 70E-1 -> 0E+1
divx310 divide 0 70E+0 -> 0
divx311 divide 0 70E+1 -> 0.0
divx312 divide 0 70E+5 -> 0.00000
divx313 divide 0 70E+6 -> 0.000000
divx314 divide 0 70E+7 -> 0E-7
divx315 divide 0 700E-5 -> 0E+5
divx316 divide 0 700E-1 -> 0E+1
divx317 divide 0 700E+0 -> 0
divx318 divide 0 700E+1 -> 0.0
divx319 divide 0 700E+5 -> 0.00000
divx320 divide 0 700E+6 -> 0.000000
divx321 divide 0 700E+7 -> 0E-7
divx322 divide 0 700E+77 -> 0E-77
divx331 divide 0E-3 7E-5 -> 0E+2
divx332 divide 0E-3 7E-1 -> 0.00
divx333 divide 0E-3 7E+1 -> 0.0000
divx334 divide 0E-3 7E+5 -> 0E-8
divx335 divide 0E-1 7E-5 -> 0E+4
divx336 divide 0E-1 7E-1 -> 0
divx337 divide 0E-1 7E+1 -> 0.00
divx338 divide 0E-1 7E+5 -> 0.000000
divx339 divide 0E+1 7E-5 -> 0E+6
divx340 divide 0E+1 7E-1 -> 0E+2
divx341 divide 0E+1 7E+1 -> 0
divx342 divide 0E+1 7E+5 -> 0.0000
divx343 divide 0E+3 7E-5 -> 0E+8
divx344 divide 0E+3 7E-1 -> 0E+4
divx345 divide 0E+3 7E+1 -> 0E+2
divx346 divide 0E+3 7E+5 -> 0.00
maxexponent: 92
minexponent: -92
precision: 7
divx351 divide 0E-92 7E-1 -> 0E-91
divx352 divide 0E-92 7E+1 -> 0E-93
divx353 divide 0E-92 7E+5 -> 0E-97
divx354 divide 0E-92 7E+6 -> 0E-98
divx355 divide 0E-92 7E+7 -> 0E-98 Clamped
divx356 divide 0E-92 777E-1 -> 0E-91
divx357 divide 0E-92 777E+1 -> 0E-93
divx358 divide 0E-92 777E+3 -> 0E-95
divx359 divide 0E-92 777E+4 -> 0E-96
divx360 divide 0E-92 777E+5 -> 0E-97
divx361 divide 0E-92 777E+6 -> 0E-98
divx362 divide 0E-92 777E+7 -> 0E-98 Clamped
divx363 divide 0E-92 7E+92 -> 0E-98 Clamped
divx371 divide 0E-92 700E-1 -> 0E-91
divx372 divide 0E-92 700E+1 -> 0E-93
divx373 divide 0E-92 700E+3 -> 0E-95
divx374 divide 0E-92 700E+4 -> 0E-96
divx375 divide 0E-92 700E+5 -> 0E-97
divx376 divide 0E-92 700E+6 -> 0E-98
divx377 divide 0E-92 700E+7 -> 0E-98 Clamped
divx381 divide 0E+92 7E+1 -> 0E+91
divx382 divide 0E+92 7E+0 -> 0E+92
divx383 divide 0E+92 7E-1 -> 0E+92 Clamped
divx384 divide 0E+90 777E+1 -> 0E+89
divx385 divide 0E+90 777E-1 -> 0E+91
divx386 divide 0E+90 777E-2 -> 0E+92
divx387 divide 0E+90 777E-3 -> 0E+92 Clamped
divx388 divide 0E+90 777E-4 -> 0E+92 Clamped
divx391 divide 0E+90 700E+1 -> 0E+89
divx392 divide 0E+90 700E-1 -> 0E+91
divx393 divide 0E+90 700E-2 -> 0E+92
divx394 divide 0E+90 700E-3 -> 0E+92 Clamped
divx395 divide 0E+90 700E-4 -> 0E+92 Clamped
-- input rounding checks
maxexponent: 999
minexponent: -999
precision: 9
divx401 divide 12345678000 1 -> 1.23456780E+10 Rounded
divx402 divide 1 12345678000 -> 8.10000066E-11 Inexact Rounded
divx403 divide 1234567800 1 -> 1.23456780E+9 Rounded
divx404 divide 1 1234567800 -> 8.10000066E-10 Inexact Rounded
divx405 divide 1234567890 1 -> 1.23456789E+9 Rounded
divx406 divide 1 1234567890 -> 8.10000007E-10 Inexact Rounded
divx407 divide 1234567891 1 -> 1.23456789E+9 Inexact Rounded
divx408 divide 1 1234567891 -> 8.10000007E-10 Inexact Rounded
divx409 divide 12345678901 1 -> 1.23456789E+10 Inexact Rounded
divx410 divide 1 12345678901 -> 8.10000007E-11 Inexact Rounded
divx411 divide 1234567896 1 -> 1.23456790E+9 Inexact Rounded
divx412 divide 1 1234567896 -> 8.10000003E-10 Inexact Rounded
divx413 divide 1 1234567897 -> 8.10000003E-10 Inexact Rounded
divx414 divide 1 1234567898 -> 8.10000002E-10 Inexact Rounded
divx415 divide 1 1234567899 -> 8.10000001E-10 Inexact Rounded
divx416 divide 1 1234567900 -> 8.10000001E-10 Inexact Rounded
divx417 divide 1 1234567901 -> 8.10000000E-10 Inexact Rounded
divx418 divide 1 1234567902 -> 8.09999999E-10 Inexact Rounded
-- some longies
divx421 divide 1234567896.000000000000 1 -> 1.23456790E+9 Inexact Rounded
divx422 divide 1 1234567896.000000000000 -> 8.10000003E-10 Inexact Rounded
divx423 divide 1234567896.000000000001 1 -> 1.23456790E+9 Inexact Rounded
divx424 divide 1 1234567896.000000000001 -> 8.10000003E-10 Inexact Rounded
divx425 divide 1234567896.000000000000000000000000000000000000000009 1 -> 1.23456790E+9 Inexact Rounded
divx426 divide 1 1234567896.000000000000000000000000000000000000000009 -> 8.10000003E-10 Inexact Rounded
divx427 divide 1234567897.900010000000000000000000000000000000000009 1 -> 1.23456790E+9 Inexact Rounded
divx428 divide 1 1234567897.900010000000000000000000000000000000000009 -> 8.10000002E-10 Inexact Rounded
precision: 15
-- still checking...
divx441 divide 12345678000 1 -> 12345678000
divx442 divide 1 12345678000 -> 8.10000066420005E-11 Inexact Rounded
divx443 divide 1234567800 1 -> 1234567800
divx444 divide 1 1234567800 -> 8.10000066420005E-10 Inexact Rounded
divx445 divide 1234567890 1 -> 1234567890
divx446 divide 1 1234567890 -> 8.10000007371000E-10 Inexact Rounded
divx447 divide 1234567891 1 -> 1234567891
divx448 divide 1 1234567891 -> 8.10000006714900E-10 Inexact Rounded
divx449 divide 12345678901 1 -> 12345678901
divx450 divide 1 12345678901 -> 8.10000007305390E-11 Inexact Rounded
divx451 divide 1234567896 1 -> 1234567896
divx452 divide 1 1234567896 -> 8.10000003434400E-10 Inexact Rounded
-- high-lows
divx453 divide 1e+1 1 -> 1E+1
divx454 divide 1e+1 1.0 -> 1E+1
divx455 divide 1e+1 1.00 -> 1E+1
divx456 divide 1e+2 2 -> 5E+1
divx457 divide 1e+2 2.0 -> 5E+1
divx458 divide 1e+2 2.00 -> 5E+1
-- some from IEEE discussions
divx460 divide 3e0 2e0 -> 1.5
divx461 divide 30e-1 2e0 -> 1.5
divx462 divide 300e-2 2e0 -> 1.50
divx464 divide 3000e-3 2e0 -> 1.500
divx465 divide 3e0 20e-1 -> 1.5
divx466 divide 30e-1 20e-1 -> 1.5
divx467 divide 300e-2 20e-1 -> 1.5
divx468 divide 3000e-3 20e-1 -> 1.50
divx469 divide 3e0 200e-2 -> 1.5
divx470 divide 30e-1 200e-2 -> 1.5
divx471 divide 300e-2 200e-2 -> 1.5
divx472 divide 3000e-3 200e-2 -> 1.5
divx473 divide 3e0 2000e-3 -> 1.5
divx474 divide 30e-1 2000e-3 -> 1.5
divx475 divide 300e-2 2000e-3 -> 1.5
divx476 divide 3000e-3 2000e-3 -> 1.5
-- some reciprocals
divx480 divide 1 1.0E+33 -> 1E-33
divx481 divide 1 10E+33 -> 1E-34
divx482 divide 1 1.0E-33 -> 1E+33
divx483 divide 1 10E-33 -> 1E+32
-- RMS discussion table
maxexponent: 96
minexponent: -95
precision: 7
divx484 divide 0e5 1e3 -> 0E+2
divx485 divide 0e5 2e3 -> 0E+2
divx486 divide 0e5 10e2 -> 0E+3
divx487 divide 0e5 20e2 -> 0E+3
divx488 divide 0e5 100e1 -> 0E+4
divx489 divide 0e5 200e1 -> 0E+4
divx491 divide 1e5 1e3 -> 1E+2
divx492 divide 1e5 2e3 -> 5E+1
divx493 divide 1e5 10e2 -> 1E+2
divx494 divide 1e5 20e2 -> 5E+1
divx495 divide 1e5 100e1 -> 1E+2
divx496 divide 1e5 200e1 -> 5E+1
-- tryzeros cases
precision: 7
rounding: half_up
maxExponent: 92
minexponent: -92
divx497 divide 0E+86 1000E-13 -> 0E+92 Clamped
divx498 divide 0E-98 1000E+13 -> 0E-98 Clamped
precision: 9
rounding: half_up
maxExponent: 999
minexponent: -999
-- focus on trailing zeros issues
precision: 9
divx500 divide 1 9.9 -> 0.101010101 Inexact Rounded
precision: 8
divx501 divide 1 9.9 -> 0.10101010 Inexact Rounded
precision: 7
divx502 divide 1 9.9 -> 0.1010101 Inexact Rounded
precision: 6
divx503 divide 1 9.9 -> 0.101010 Inexact Rounded
precision: 9
divx511 divide 1 2 -> 0.5
divx512 divide 1.0 2 -> 0.5
divx513 divide 1.00 2 -> 0.50
divx514 divide 1.000 2 -> 0.500
divx515 divide 1.0000 2 -> 0.5000
divx516 divide 1.00000 2 -> 0.50000
divx517 divide 1.000000 2 -> 0.500000
divx518 divide 1.0000000 2 -> 0.5000000
divx519 divide 1.00 2.00 -> 0.5
divx521 divide 2 1 -> 2
divx522 divide 2 1.0 -> 2
divx523 divide 2 1.00 -> 2
divx524 divide 2 1.000 -> 2
divx525 divide 2 1.0000 -> 2
divx526 divide 2 1.00000 -> 2
divx527 divide 2 1.000000 -> 2
divx528 divide 2 1.0000000 -> 2
divx529 divide 2.00 1.00 -> 2
divx530 divide 2.40 2 -> 1.20
divx531 divide 2.40 4 -> 0.60
divx532 divide 2.40 10 -> 0.24
divx533 divide 2.40 2.0 -> 1.2
divx534 divide 2.40 4.0 -> 0.6
divx535 divide 2.40 10.0 -> 0.24
divx536 divide 2.40 2.00 -> 1.2
divx537 divide 2.40 4.00 -> 0.6
divx538 divide 2.40 10.00 -> 0.24
divx539 divide 0.9 0.1 -> 9
divx540 divide 0.9 0.01 -> 9E+1
divx541 divide 0.9 0.001 -> 9E+2
divx542 divide 5 2 -> 2.5
divx543 divide 5 2.0 -> 2.5
divx544 divide 5 2.00 -> 2.5
divx545 divide 5 20 -> 0.25
divx546 divide 5 20.0 -> 0.25
divx547 divide 2.400 2 -> 1.200
divx548 divide 2.400 2.0 -> 1.20
divx549 divide 2.400 2.400 -> 1
divx550 divide 240 1 -> 240
divx551 divide 240 10 -> 24
divx552 divide 240 100 -> 2.4
divx553 divide 240 1000 -> 0.24
divx554 divide 2400 1 -> 2400
divx555 divide 2400 10 -> 240
divx556 divide 2400 100 -> 24
divx557 divide 2400 1000 -> 2.4
-- +ve exponent
precision: 5
divx570 divide 2.4E+6 2 -> 1.2E+6
divx571 divide 2.40E+6 2 -> 1.20E+6
divx572 divide 2.400E+6 2 -> 1.200E+6
divx573 divide 2.4000E+6 2 -> 1.2000E+6
divx574 divide 24E+5 2 -> 1.2E+6
divx575 divide 240E+4 2 -> 1.20E+6
divx576 divide 2400E+3 2 -> 1.200E+6
divx577 divide 24000E+2 2 -> 1.2000E+6
precision: 6
divx580 divide 2.4E+6 2 -> 1.2E+6
divx581 divide 2.40E+6 2 -> 1.20E+6
divx582 divide 2.400E+6 2 -> 1.200E+6
divx583 divide 2.4000E+6 2 -> 1.2000E+6
divx584 divide 24E+5 2 -> 1.2E+6
divx585 divide 240E+4 2 -> 1.20E+6
divx586 divide 2400E+3 2 -> 1.200E+6
divx587 divide 24000E+2 2 -> 1.2000E+6
precision: 7
divx590 divide 2.4E+6 2 -> 1.2E+6
divx591 divide 2.40E+6 2 -> 1.20E+6
divx592 divide 2.400E+6 2 -> 1.200E+6
divx593 divide 2.4000E+6 2 -> 1.2000E+6
divx594 divide 24E+5 2 -> 1.2E+6
divx595 divide 240E+4 2 -> 1.20E+6
divx596 divide 2400E+3 2 -> 1.200E+6
divx597 divide 24000E+2 2 -> 1.2000E+6
precision: 9
divx600 divide 2.4E+9 2 -> 1.2E+9
divx601 divide 2.40E+9 2 -> 1.20E+9
divx602 divide 2.400E+9 2 -> 1.200E+9
divx603 divide 2.4000E+9 2 -> 1.2000E+9
divx604 divide 24E+8 2 -> 1.2E+9
divx605 divide 240E+7 2 -> 1.20E+9
divx606 divide 2400E+6 2 -> 1.200E+9
divx607 divide 24000E+5 2 -> 1.2000E+9
-- long operand triangle
precision: 33
divx610 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.8131097703792 Inexact Rounded
precision: 32
divx611 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.813109770379 Inexact Rounded
precision: 31
divx612 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.81310977038 Inexact Rounded
precision: 30
divx613 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.8131097704 Inexact Rounded
precision: 29
divx614 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.813109770 Inexact Rounded
precision: 28
divx615 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.81310977 Inexact Rounded
precision: 27
divx616 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.8131098 Inexact Rounded
precision: 26
divx617 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.813110 Inexact Rounded
precision: 25
divx618 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.81311 Inexact Rounded
precision: 24
divx619 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.8131 Inexact Rounded
precision: 23
divx620 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.813 Inexact Rounded
precision: 22
divx621 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.81 Inexact Rounded
precision: 21
divx622 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817797.8 Inexact Rounded
precision: 20
divx623 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -41011408883796817798 Inexact Rounded
precision: 19
divx624 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101140888379681780E+19 Inexact Rounded
precision: 18
divx625 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10114088837968178E+19 Inexact Rounded
precision: 17
divx626 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1011408883796818E+19 Inexact Rounded
precision: 16
divx627 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101140888379682E+19 Inexact Rounded
precision: 15
divx628 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10114088837968E+19 Inexact Rounded
precision: 14
divx629 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1011408883797E+19 Inexact Rounded
precision: 13
divx630 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101140888380E+19 Inexact Rounded
precision: 12
divx631 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10114088838E+19 Inexact Rounded
precision: 11
divx632 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1011408884E+19 Inexact Rounded
precision: 10
divx633 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101140888E+19 Inexact Rounded
precision: 9
divx634 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10114089E+19 Inexact Rounded
precision: 8
divx635 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1011409E+19 Inexact Rounded
precision: 7
divx636 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101141E+19 Inexact Rounded
precision: 6
divx637 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10114E+19 Inexact Rounded
precision: 5
divx638 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1011E+19 Inexact Rounded
precision: 4
divx639 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.101E+19 Inexact Rounded
precision: 3
divx640 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.10E+19 Inexact Rounded
precision: 2
divx641 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4.1E+19 Inexact Rounded
precision: 1
divx642 divide -3374988581607586061255542201048 82293895124.90045271504836568681 -> -4E+19 Inexact Rounded
-- more zeros, etc.
precision: 16
rounding: half_up
maxExponent: 384
minExponent: -383
divx731 divide 5.00 1E-3 -> 5.00E+3
divx732 divide 00.00 0.000 -> NaN Division_undefined
divx733 divide 00.00 0E-3 -> NaN Division_undefined
divx734 divide 0 -0 -> NaN Division_undefined
divx735 divide -0 0 -> NaN Division_undefined
divx736 divide -0 -0 -> NaN Division_undefined
divx741 divide 0 -1 -> -0
divx742 divide -0 -1 -> 0
divx743 divide 0 1 -> 0
divx744 divide -0 1 -> -0
divx745 divide -1 0 -> -Infinity Division_by_zero
divx746 divide -1 -0 -> Infinity Division_by_zero
divx747 divide 1 0 -> Infinity Division_by_zero
divx748 divide 1 -0 -> -Infinity Division_by_zero
divx751 divide 0.0 -1 -> -0.0
divx752 divide -0.0 -1 -> 0.0
divx753 divide 0.0 1 -> 0.0
divx754 divide -0.0 1 -> -0.0
divx755 divide -1.0 0 -> -Infinity Division_by_zero
divx756 divide -1.0 -0 -> Infinity Division_by_zero
divx757 divide 1.0 0 -> Infinity Division_by_zero
divx758 divide 1.0 -0 -> -Infinity Division_by_zero
divx761 divide 0 -1.0 -> -0E+1
divx762 divide -0 -1.0 -> 0E+1
divx763 divide 0 1.0 -> 0E+1
divx764 divide -0 1.0 -> -0E+1
divx765 divide -1 0.0 -> -Infinity Division_by_zero
divx766 divide -1 -0.0 -> Infinity Division_by_zero
divx767 divide 1 0.0 -> Infinity Division_by_zero
divx768 divide 1 -0.0 -> -Infinity Division_by_zero
divx771 divide 0.0 -1.0 -> -0
divx772 divide -0.0 -1.0 -> 0
divx773 divide 0.0 1.0 -> 0
divx774 divide -0.0 1.0 -> -0
divx775 divide -1.0 0.0 -> -Infinity Division_by_zero
divx776 divide -1.0 -0.0 -> Infinity Division_by_zero
divx777 divide 1.0 0.0 -> Infinity Division_by_zero
divx778 divide 1.0 -0.0 -> -Infinity Division_by_zero
-- Specials
divx780 divide Inf -Inf -> NaN Invalid_operation
divx781 divide Inf -1000 -> -Infinity
divx782 divide Inf -1 -> -Infinity
divx783 divide Inf -0 -> -Infinity
divx784 divide Inf 0 -> Infinity
divx785 divide Inf 1 -> Infinity
divx786 divide Inf 1000 -> Infinity
divx787 divide Inf Inf -> NaN Invalid_operation
divx788 divide -1000 Inf -> -0E-398 Clamped
divx789 divide -Inf Inf -> NaN Invalid_operation
divx790 divide -1 Inf -> -0E-398 Clamped
divx791 divide -0 Inf -> -0E-398 Clamped
divx792 divide 0 Inf -> 0E-398 Clamped
divx793 divide 1 Inf -> 0E-398 Clamped
divx794 divide 1000 Inf -> 0E-398 Clamped
divx795 divide Inf Inf -> NaN Invalid_operation
divx800 divide -Inf -Inf -> NaN Invalid_operation
divx801 divide -Inf -1000 -> Infinity
divx802 divide -Inf -1 -> Infinity
divx803 divide -Inf -0 -> Infinity
divx804 divide -Inf 0 -> -Infinity
divx805 divide -Inf 1 -> -Infinity
divx806 divide -Inf 1000 -> -Infinity
divx807 divide -Inf Inf -> NaN Invalid_operation
divx808 divide -1000 Inf -> -0E-398 Clamped
divx809 divide -Inf -Inf -> NaN Invalid_operation
divx810 divide -1 -Inf -> 0E-398 Clamped
divx811 divide -0 -Inf -> 0E-398 Clamped
divx812 divide 0 -Inf -> -0E-398 Clamped
divx813 divide 1 -Inf -> -0E-398 Clamped
divx814 divide 1000 -Inf -> -0E-398 Clamped
divx815 divide Inf -Inf -> NaN Invalid_operation
divx821 divide NaN -Inf -> NaN
divx822 divide NaN -1000 -> NaN
divx823 divide NaN -1 -> NaN
divx824 divide NaN -0 -> NaN
divx825 divide NaN 0 -> NaN
divx826 divide NaN 1 -> NaN
divx827 divide NaN 1000 -> NaN
divx828 divide NaN Inf -> NaN
divx829 divide NaN NaN -> NaN
divx830 divide -Inf NaN -> NaN
divx831 divide -1000 NaN -> NaN
divx832 divide -1 NaN -> NaN
divx833 divide -0 NaN -> NaN
divx834 divide 0 NaN -> NaN
divx835 divide 1 NaN -> NaN
divx836 divide 1000 NaN -> NaN
divx837 divide Inf NaN -> NaN
divx841 divide sNaN -Inf -> NaN Invalid_operation
divx842 divide sNaN -1000 -> NaN Invalid_operation
divx843 divide sNaN -1 -> NaN Invalid_operation
divx844 divide sNaN -0 -> NaN Invalid_operation
divx845 divide sNaN 0 -> NaN Invalid_operation
divx846 divide sNaN 1 -> NaN Invalid_operation
divx847 divide sNaN 1000 -> NaN Invalid_operation
divx848 divide sNaN NaN -> NaN Invalid_operation
divx849 divide sNaN sNaN -> NaN Invalid_operation
divx850 divide NaN sNaN -> NaN Invalid_operation
divx851 divide -Inf sNaN -> NaN Invalid_operation
divx852 divide -1000 sNaN -> NaN Invalid_operation
divx853 divide -1 sNaN -> NaN Invalid_operation
divx854 divide -0 sNaN -> NaN Invalid_operation
divx855 divide 0 sNaN -> NaN Invalid_operation
divx856 divide 1 sNaN -> NaN Invalid_operation
divx857 divide 1000 sNaN -> NaN Invalid_operation
divx858 divide Inf sNaN -> NaN Invalid_operation
divx859 divide NaN sNaN -> NaN Invalid_operation
-- propagating NaNs
divx861 divide NaN9 -Inf -> NaN9
divx862 divide NaN8 1000 -> NaN8
divx863 divide NaN7 Inf -> NaN7
divx864 divide NaN6 NaN5 -> NaN6
divx865 divide -Inf NaN4 -> NaN4
divx866 divide -1000 NaN3 -> NaN3
divx867 divide Inf NaN2 -> NaN2
divx871 divide sNaN99 -Inf -> NaN99 Invalid_operation
divx872 divide sNaN98 -1 -> NaN98 Invalid_operation
divx873 divide sNaN97 NaN -> NaN97 Invalid_operation
divx874 divide sNaN96 sNaN94 -> NaN96 Invalid_operation
divx875 divide NaN95 sNaN93 -> NaN93 Invalid_operation
divx876 divide -Inf sNaN92 -> NaN92 Invalid_operation
divx877 divide 0 sNaN91 -> NaN91 Invalid_operation
divx878 divide Inf sNaN90 -> NaN90 Invalid_operation
divx879 divide NaN sNaN89 -> NaN89 Invalid_operation
divx881 divide -NaN9 -Inf -> -NaN9
divx882 divide -NaN8 1000 -> -NaN8
divx883 divide -NaN7 Inf -> -NaN7
divx884 divide -NaN6 -NaN5 -> -NaN6
divx885 divide -Inf -NaN4 -> -NaN4
divx886 divide -1000 -NaN3 -> -NaN3
divx887 divide Inf -NaN2 -> -NaN2
divx891 divide -sNaN99 -Inf -> -NaN99 Invalid_operation
divx892 divide -sNaN98 -1 -> -NaN98 Invalid_operation
divx893 divide -sNaN97 NaN -> -NaN97 Invalid_operation
divx894 divide -sNaN96 -sNaN94 -> -NaN96 Invalid_operation
divx895 divide -NaN95 -sNaN93 -> -NaN93 Invalid_operation
divx896 divide -Inf -sNaN92 -> -NaN92 Invalid_operation
divx897 divide 0 -sNaN91 -> -NaN91 Invalid_operation
divx898 divide Inf -sNaN90 -> -NaN90 Invalid_operation
divx899 divide -NaN -sNaN89 -> -NaN89 Invalid_operation
maxexponent: 999999999
minexponent: -999999999
-- Various flavours of divide by 0
divx901 divide 0 0 -> NaN Division_undefined
divx902 divide 0.0E5 0 -> NaN Division_undefined
divx903 divide 0.000 0 -> NaN Division_undefined
divx904 divide 0.0001 0 -> Infinity Division_by_zero
divx905 divide 0.01 0 -> Infinity Division_by_zero
divx906 divide 0.1 0 -> Infinity Division_by_zero
divx907 divide 1 0 -> Infinity Division_by_zero
divx908 divide 1 0.0 -> Infinity Division_by_zero
divx909 divide 10 0.0 -> Infinity Division_by_zero
divx910 divide 1E+100 0.0 -> Infinity Division_by_zero
divx911 divide 1E+1000 0 -> Infinity Division_by_zero
divx921 divide -0.0001 0 -> -Infinity Division_by_zero
divx922 divide -0.01 0 -> -Infinity Division_by_zero
divx923 divide -0.1 0 -> -Infinity Division_by_zero
divx924 divide -1 0 -> -Infinity Division_by_zero
divx925 divide -1 0.0 -> -Infinity Division_by_zero
divx926 divide -10 0.0 -> -Infinity Division_by_zero
divx927 divide -1E+100 0.0 -> -Infinity Division_by_zero
divx928 divide -1E+1000 0 -> -Infinity Division_by_zero
divx931 divide 0.0001 -0 -> -Infinity Division_by_zero
divx932 divide 0.01 -0 -> -Infinity Division_by_zero
divx933 divide 0.1 -0 -> -Infinity Division_by_zero
divx934 divide 1 -0 -> -Infinity Division_by_zero
divx935 divide 1 -0.0 -> -Infinity Division_by_zero
divx936 divide 10 -0.0 -> -Infinity Division_by_zero
divx937 divide 1E+100 -0.0 -> -Infinity Division_by_zero
divx938 divide 1E+1000 -0 -> -Infinity Division_by_zero
divx941 divide -0.0001 -0 -> Infinity Division_by_zero
divx942 divide -0.01 -0 -> Infinity Division_by_zero
divx943 divide -0.1 -0 -> Infinity Division_by_zero
divx944 divide -1 -0 -> Infinity Division_by_zero
divx945 divide -1 -0.0 -> Infinity Division_by_zero
divx946 divide -10 -0.0 -> Infinity Division_by_zero
divx947 divide -1E+100 -0.0 -> Infinity Division_by_zero
divx948 divide -1E+1000 -0 -> Infinity Division_by_zero
-- overflow and underflow tests
precision: 9
maxexponent: 999999999
minexponent: -999999999
divx951 divide 9E+999999999 +0.23456789012345E-0 -> Infinity Inexact Overflow Rounded
divx952 divide +0.100 9E+999999999 -> 1.111111E-1000000001 Inexact Rounded Underflow Subnormal
divx953 divide 9E-999999999 +9.100 -> 9.8901099E-1000000000 Inexact Rounded Underflow Subnormal
divx954 divide -1.23456789 9E+999999999 -> -1.3717421E-1000000000 Subnormal
divx955 divide -1.23456789012345E-0 9E+999999999 -> -1.3717421E-1000000000 Underflow Subnormal Rounded Inexact
divx956 divide -1.23456789012345E-0 7E+999999999 -> -1.7636684E-1000000000 Inexact Rounded Underflow Subnormal
divx957 divide 9E+999999999 -0.83456789012345E-0 -> -Infinity Inexact Overflow Rounded
divx958 divide -0.100 9E+999999999 -> -1.111111E-1000000001 Subnormal Inexact Rounded Underflow
divx959 divide 9E-999999999 -9.100 -> -9.8901099E-1000000000 Inexact Rounded Underflow Subnormal
-- overflow and underflow (additional edge tests in multiply.decTest)
-- 'subnormal' results now possible (all hard underflow or overflow in
-- base arithemtic)
divx960 divide 1e-600000000 1e+400000001 -> 1E-1000000001 Subnormal
divx961 divide 1e-600000000 1e+400000002 -> 1E-1000000002 Subnormal
divx962 divide 1e-600000000 1e+400000003 -> 1E-1000000003 Subnormal
divx963 divide 1e-600000000 1e+400000004 -> 1E-1000000004 Subnormal
divx964 divide 1e-600000000 1e+400000005 -> 1E-1000000005 Subnormal
divx965 divide 1e-600000000 1e+400000006 -> 1E-1000000006 Subnormal
divx966 divide 1e-600000000 1e+400000007 -> 1E-1000000007 Subnormal
divx967 divide 1e-600000000 1e+400000008 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
divx968 divide 1e-600000000 1e+400000009 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
divx969 divide 1e-600000000 1e+400000010 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
-- [no equivalent of 'subnormal' for overflow]
divx970 divide 1e+600000000 1e-400000001 -> Infinity Overflow Inexact Rounded
divx971 divide 1e+600000000 1e-400000002 -> Infinity Overflow Inexact Rounded
divx972 divide 1e+600000000 1e-400000003 -> Infinity Overflow Inexact Rounded
divx973 divide 1e+600000000 1e-400000004 -> Infinity Overflow Inexact Rounded
divx974 divide 1e+600000000 1e-400000005 -> Infinity Overflow Inexact Rounded
divx975 divide 1e+600000000 1e-400000006 -> Infinity Overflow Inexact Rounded
divx976 divide 1e+600000000 1e-400000007 -> Infinity Overflow Inexact Rounded
divx977 divide 1e+600000000 1e-400000008 -> Infinity Overflow Inexact Rounded
divx978 divide 1e+600000000 1e-400000009 -> Infinity Overflow Inexact Rounded
divx979 divide 1e+600000000 1e-400000010 -> Infinity Overflow Inexact Rounded
-- Sign after overflow and underflow
divx980 divide 1e-600000000 1e+400000009 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
divx981 divide 1e-600000000 -1e+400000009 -> -0E-1000000007 Underflow Subnormal Inexact Rounded
divx982 divide -1e-600000000 1e+400000009 -> -0E-1000000007 Underflow Subnormal Inexact Rounded
divx983 divide -1e-600000000 -1e+400000009 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
divx984 divide 1e+600000000 1e-400000009 -> Infinity Overflow Inexact Rounded
divx985 divide 1e+600000000 -1e-400000009 -> -Infinity Overflow Inexact Rounded
divx986 divide -1e+600000000 1e-400000009 -> -Infinity Overflow Inexact Rounded
divx987 divide -1e+600000000 -1e-400000009 -> Infinity Overflow Inexact Rounded
-- Long operand overflow may be a different path
precision: 3
divx990 divide 1000 9.999E-999999999 -> Infinity Inexact Overflow Rounded
divx991 divide 1000 -9.999E-999999999 -> -Infinity Inexact Overflow Rounded
divx992 divide 9.999E+999999999 0.01 -> Infinity Inexact Overflow Rounded
divx993 divide -9.999E+999999999 0.01 -> -Infinity Inexact Overflow Rounded
-- check for double-rounded subnormals
precision: 5
maxexponent: 79
minexponent: -79
divx1001 divide 1.52444E-80 1 -> 1.524E-80 Inexact Rounded Subnormal Underflow
divx1002 divide 1.52445E-80 1 -> 1.524E-80 Inexact Rounded Subnormal Underflow
divx1003 divide 1.52446E-80 1 -> 1.524E-80 Inexact Rounded Subnormal Underflow
-- a rounding problem in one implementation
precision: 34
rounding: half_up
maxExponent: 6144
minExponent: -6143
-- Unbounded answer to 40 digits:
-- 1.465811965811965811965811965811965811966E+7000
divx1010 divide 343E6000 234E-1000 -> Infinity Overflow Inexact Rounded
-- Null tests
divx9998 divide 10 # -> NaN Invalid_operation
divx9999 divide # 10 -> NaN Invalid_operation

470
sys/lib/python/test/decimaltestdata/divideint.decTest
View file

@ -1,470 +0,0 @@
------------------------------------------------------------------------
-- divideint.decTest -- decimal integer division --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
extended: 1
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
dvix001 divideint 1 1 -> 1
dvix002 divideint 2 1 -> 2
dvix003 divideint 1 2 -> 0
dvix004 divideint 2 2 -> 1
dvix005 divideint 0 1 -> 0
dvix006 divideint 0 2 -> 0
dvix007 divideint 1 3 -> 0
dvix008 divideint 2 3 -> 0
dvix009 divideint 3 3 -> 1
dvix010 divideint 2.4 1 -> 2
dvix011 divideint 2.4 -1 -> -2
dvix012 divideint -2.4 1 -> -2
dvix013 divideint -2.4 -1 -> 2
dvix014 divideint 2.40 1 -> 2
dvix015 divideint 2.400 1 -> 2
dvix016 divideint 2.4 2 -> 1
dvix017 divideint 2.400 2 -> 1
dvix018 divideint 2. 2 -> 1
dvix019 divideint 20 20 -> 1
dvix020 divideint 187 187 -> 1
dvix021 divideint 5 2 -> 2
dvix022 divideint 5 2.0 -> 2
dvix023 divideint 5 2.000 -> 2
dvix024 divideint 5 0.200 -> 25
dvix025 divideint 5 0.200 -> 25
dvix030 divideint 1 2 -> 0
dvix031 divideint 1 4 -> 0
dvix032 divideint 1 8 -> 0
dvix033 divideint 1 16 -> 0
dvix034 divideint 1 32 -> 0
dvix035 divideint 1 64 -> 0
dvix040 divideint 1 -2 -> -0
dvix041 divideint 1 -4 -> -0
dvix042 divideint 1 -8 -> -0
dvix043 divideint 1 -16 -> -0
dvix044 divideint 1 -32 -> -0
dvix045 divideint 1 -64 -> -0
dvix050 divideint -1 2 -> -0
dvix051 divideint -1 4 -> -0
dvix052 divideint -1 8 -> -0
dvix053 divideint -1 16 -> -0
dvix054 divideint -1 32 -> -0
dvix055 divideint -1 64 -> -0
dvix060 divideint -1 -2 -> 0
dvix061 divideint -1 -4 -> 0
dvix062 divideint -1 -8 -> 0
dvix063 divideint -1 -16 -> 0
dvix064 divideint -1 -32 -> 0
dvix065 divideint -1 -64 -> 0
-- similar with powers of ten
dvix160 divideint 1 1 -> 1
dvix161 divideint 1 10 -> 0
dvix162 divideint 1 100 -> 0
dvix163 divideint 1 1000 -> 0
dvix164 divideint 1 10000 -> 0
dvix165 divideint 1 100000 -> 0
dvix166 divideint 1 1000000 -> 0
dvix167 divideint 1 10000000 -> 0
dvix168 divideint 1 100000000 -> 0
dvix170 divideint 1 -1 -> -1
dvix171 divideint 1 -10 -> -0
dvix172 divideint 1 -100 -> -0
dvix173 divideint 1 -1000 -> -0
dvix174 divideint 1 -10000 -> -0
dvix175 divideint 1 -100000 -> -0
dvix176 divideint 1 -1000000 -> -0
dvix177 divideint 1 -10000000 -> -0
dvix178 divideint 1 -100000000 -> -0
dvix180 divideint -1 1 -> -1
dvix181 divideint -1 10 -> -0
dvix182 divideint -1 100 -> -0
dvix183 divideint -1 1000 -> -0
dvix184 divideint -1 10000 -> -0
dvix185 divideint -1 100000 -> -0
dvix186 divideint -1 1000000 -> -0
dvix187 divideint -1 10000000 -> -0
dvix188 divideint -1 100000000 -> -0
dvix190 divideint -1 -1 -> 1
dvix191 divideint -1 -10 -> 0
dvix192 divideint -1 -100 -> 0
dvix193 divideint -1 -1000 -> 0
dvix194 divideint -1 -10000 -> 0
dvix195 divideint -1 -100000 -> 0
dvix196 divideint -1 -1000000 -> 0
dvix197 divideint -1 -10000000 -> 0
dvix198 divideint -1 -100000000 -> 0
-- some long operand cases here
dvix070 divideint 999999999 1 -> 999999999
dvix071 divideint 999999999.4 1 -> 999999999
dvix072 divideint 999999999.5 1 -> 999999999
dvix073 divideint 999999999.9 1 -> 999999999
dvix074 divideint 999999999.999 1 -> 999999999
precision: 6
dvix080 divideint 999999999 1 -> NaN Division_impossible
dvix081 divideint 99999999 1 -> NaN Division_impossible
dvix082 divideint 9999999 1 -> NaN Division_impossible
dvix083 divideint 999999 1 -> 999999
dvix084 divideint 99999 1 -> 99999
dvix085 divideint 9999 1 -> 9999
dvix086 divideint 999 1 -> 999
dvix087 divideint 99 1 -> 99
dvix088 divideint 9 1 -> 9
precision: 9
dvix090 divideint 0. 1 -> 0
dvix091 divideint .0 1 -> 0
dvix092 divideint 0.00 1 -> 0
dvix093 divideint 0.00E+9 1 -> 0
dvix094 divideint 0.0000E-50 1 -> 0
dvix100 divideint 1 1 -> 1
dvix101 divideint 1 2 -> 0
dvix102 divideint 1 3 -> 0
dvix103 divideint 1 4 -> 0
dvix104 divideint 1 5 -> 0
dvix105 divideint 1 6 -> 0
dvix106 divideint 1 7 -> 0
dvix107 divideint 1 8 -> 0
dvix108 divideint 1 9 -> 0
dvix109 divideint 1 10 -> 0
dvix110 divideint 1 1 -> 1
dvix111 divideint 2 1 -> 2
dvix112 divideint 3 1 -> 3
dvix113 divideint 4 1 -> 4
dvix114 divideint 5 1 -> 5
dvix115 divideint 6 1 -> 6
dvix116 divideint 7 1 -> 7
dvix117 divideint 8 1 -> 8
dvix118 divideint 9 1 -> 9
dvix119 divideint 10 1 -> 10
-- from DiagBigDecimal
dvix131 divideint 101.3 1 -> 101
dvix132 divideint 101.0 1 -> 101
dvix133 divideint 101.3 3 -> 33
dvix134 divideint 101.0 3 -> 33
dvix135 divideint 2.4 1 -> 2
dvix136 divideint 2.400 1 -> 2
dvix137 divideint 18 18 -> 1
dvix138 divideint 1120 1000 -> 1
dvix139 divideint 2.4 2 -> 1
dvix140 divideint 2.400 2 -> 1
dvix141 divideint 0.5 2.000 -> 0
dvix142 divideint 8.005 7 -> 1
dvix143 divideint 5 2 -> 2
dvix144 divideint 0 2 -> 0
dvix145 divideint 0.00 2 -> 0
-- Others
dvix150 divideint 12345 4.999 -> 2469
dvix151 divideint 12345 4.99 -> 2473
dvix152 divideint 12345 4.9 -> 2519
dvix153 divideint 12345 5 -> 2469
dvix154 divideint 12345 5.1 -> 2420
dvix155 divideint 12345 5.01 -> 2464
dvix156 divideint 12345 5.001 -> 2468
dvix157 divideint 101 7.6 -> 13
-- Various flavours of divideint by 0
maxexponent: 999999999
minexponent: -999999999
dvix201 divideint 0 0 -> NaN Division_undefined
dvix202 divideint 0.0E5 0 -> NaN Division_undefined
dvix203 divideint 0.000 0 -> NaN Division_undefined
dvix204 divideint 0.0001 0 -> Infinity Division_by_zero
dvix205 divideint 0.01 0 -> Infinity Division_by_zero
dvix206 divideint 0.1 0 -> Infinity Division_by_zero
dvix207 divideint 1 0 -> Infinity Division_by_zero
dvix208 divideint 1 0.0 -> Infinity Division_by_zero
dvix209 divideint 10 0.0 -> Infinity Division_by_zero
dvix210 divideint 1E+100 0.0 -> Infinity Division_by_zero
dvix211 divideint 1E+1000 0 -> Infinity Division_by_zero
dvix214 divideint -0.0001 0 -> -Infinity Division_by_zero
dvix215 divideint -0.01 0 -> -Infinity Division_by_zero
dvix216 divideint -0.1 0 -> -Infinity Division_by_zero
dvix217 divideint -1 0 -> -Infinity Division_by_zero
dvix218 divideint -1 0.0 -> -Infinity Division_by_zero
dvix219 divideint -10 0.0 -> -Infinity Division_by_zero
dvix220 divideint -1E+100 0.0 -> -Infinity Division_by_zero
dvix221 divideint -1E+1000 0 -> -Infinity Division_by_zero
-- test some cases that are close to exponent overflow
maxexponent: 999999999
minexponent: -999999999
dvix270 divideint 1 1e999999999 -> 0
dvix271 divideint 1 0.9e999999999 -> 0
dvix272 divideint 1 0.99e999999999 -> 0
dvix273 divideint 1 0.999999999e999999999 -> 0
dvix274 divideint 9e999999999 1 -> NaN Division_impossible
dvix275 divideint 9.9e999999999 1 -> NaN Division_impossible
dvix276 divideint 9.99e999999999 1 -> NaN Division_impossible
dvix277 divideint 9.99999999e999999999 1 -> NaN Division_impossible
dvix280 divideint 0.1 9e-999999999 -> NaN Division_impossible
dvix281 divideint 0.1 99e-999999999 -> NaN Division_impossible
dvix282 divideint 0.1 999e-999999999 -> NaN Division_impossible
dvix283 divideint 0.1 9e-999999998 -> NaN Division_impossible
dvix284 divideint 0.1 99e-999999998 -> NaN Division_impossible
dvix285 divideint 0.1 999e-999999998 -> NaN Division_impossible
dvix286 divideint 0.1 999e-999999997 -> NaN Division_impossible
dvix287 divideint 0.1 9999e-999999997 -> NaN Division_impossible
dvix288 divideint 0.1 99999e-999999997 -> NaN Division_impossible
-- overflow and underflow tests [from divide]
maxexponent: 999999999
minexponent: -999999999
dvix330 divideint +1.23456789012345E-0 9E+999999999 -> 0
dvix331 divideint 9E+999999999 +0.23456789012345E-0 -> NaN Division_impossible
dvix332 divideint +0.100 9E+999999999 -> 0
dvix333 divideint 9E-999999999 +9.100 -> 0
dvix335 divideint -1.23456789012345E-0 9E+999999999 -> -0
dvix336 divideint 9E+999999999 -0.83456789012345E-0 -> NaN Division_impossible
dvix337 divideint -0.100 9E+999999999 -> -0
dvix338 divideint 9E-999999999 -9.100 -> -0
-- long operand checks
maxexponent: 999
minexponent: -999
precision: 9
dvix401 divideint 12345678000 100 -> 123456780
dvix402 divideint 1 12345678000 -> 0
dvix403 divideint 1234567800 10 -> 123456780
dvix404 divideint 1 1234567800 -> 0
dvix405 divideint 1234567890 10 -> 123456789
dvix406 divideint 1 1234567890 -> 0
dvix407 divideint 1234567891 10 -> 123456789
dvix408 divideint 1 1234567891 -> 0
dvix409 divideint 12345678901 100 -> 123456789
dvix410 divideint 1 12345678901 -> 0
dvix411 divideint 1234567896 10 -> 123456789
dvix412 divideint 1 1234567896 -> 0
dvix413 divideint 12345678948 100 -> 123456789
dvix414 divideint 12345678949 100 -> 123456789
dvix415 divideint 12345678950 100 -> 123456789
dvix416 divideint 12345678951 100 -> 123456789
dvix417 divideint 12345678999 100 -> 123456789
precision: 15
dvix441 divideint 12345678000 1 -> 12345678000
dvix442 divideint 1 12345678000 -> 0
dvix443 divideint 1234567800 1 -> 1234567800
dvix444 divideint 1 1234567800 -> 0
dvix445 divideint 1234567890 1 -> 1234567890
dvix446 divideint 1 1234567890 -> 0
dvix447 divideint 1234567891 1 -> 1234567891
dvix448 divideint 1 1234567891 -> 0
dvix449 divideint 12345678901 1 -> 12345678901
dvix450 divideint 1 12345678901 -> 0
dvix451 divideint 1234567896 1 -> 1234567896
dvix452 divideint 1 1234567896 -> 0
precision: 9
rounding: half_up
maxExponent: 999
minexponent: -999
-- more zeros, etc.
dvix531 divideint 5.00 1E-3 -> 5000
dvix532 divideint 00.00 0.000 -> NaN Division_undefined
dvix533 divideint 00.00 0E-3 -> NaN Division_undefined
dvix534 divideint 0 -0 -> NaN Division_undefined
dvix535 divideint -0 0 -> NaN Division_undefined
dvix536 divideint -0 -0 -> NaN Division_undefined
dvix541 divideint 0 -1 -> -0
dvix542 divideint -0 -1 -> 0
dvix543 divideint 0 1 -> 0
dvix544 divideint -0 1 -> -0
dvix545 divideint -1 0 -> -Infinity Division_by_zero
dvix546 divideint -1 -0 -> Infinity Division_by_zero
dvix547 divideint 1 0 -> Infinity Division_by_zero
dvix548 divideint 1 -0 -> -Infinity Division_by_zero
dvix551 divideint 0.0 -1 -> -0
dvix552 divideint -0.0 -1 -> 0
dvix553 divideint 0.0 1 -> 0
dvix554 divideint -0.0 1 -> -0
dvix555 divideint -1.0 0 -> -Infinity Division_by_zero
dvix556 divideint -1.0 -0 -> Infinity Division_by_zero
dvix557 divideint 1.0 0 -> Infinity Division_by_zero
dvix558 divideint 1.0 -0 -> -Infinity Division_by_zero
dvix561 divideint 0 -1.0 -> -0
dvix562 divideint -0 -1.0 -> 0
dvix563 divideint 0 1.0 -> 0
dvix564 divideint -0 1.0 -> -0
dvix565 divideint -1 0.0 -> -Infinity Division_by_zero
dvix566 divideint -1 -0.0 -> Infinity Division_by_zero
dvix567 divideint 1 0.0 -> Infinity Division_by_zero
dvix568 divideint 1 -0.0 -> -Infinity Division_by_zero
dvix571 divideint 0.0 -1.0 -> -0
dvix572 divideint -0.0 -1.0 -> 0
dvix573 divideint 0.0 1.0 -> 0
dvix574 divideint -0.0 1.0 -> -0
dvix575 divideint -1.0 0.0 -> -Infinity Division_by_zero
dvix576 divideint -1.0 -0.0 -> Infinity Division_by_zero
dvix577 divideint 1.0 0.0 -> Infinity Division_by_zero
dvix578 divideint 1.0 -0.0 -> -Infinity Division_by_zero
-- Specials
dvix580 divideint Inf -Inf -> NaN Invalid_operation
dvix581 divideint Inf -1000 -> -Infinity
dvix582 divideint Inf -1 -> -Infinity
dvix583 divideint Inf -0 -> -Infinity
dvix584 divideint Inf 0 -> Infinity
dvix585 divideint Inf 1 -> Infinity
dvix586 divideint Inf 1000 -> Infinity
dvix587 divideint Inf Inf -> NaN Invalid_operation
dvix588 divideint -1000 Inf -> -0
dvix589 divideint -Inf Inf -> NaN Invalid_operation
dvix590 divideint -1 Inf -> -0
dvix591 divideint -0 Inf -> -0
dvix592 divideint 0 Inf -> 0
dvix593 divideint 1 Inf -> 0
dvix594 divideint 1000 Inf -> 0
dvix595 divideint Inf Inf -> NaN Invalid_operation
dvix600 divideint -Inf -Inf -> NaN Invalid_operation
dvix601 divideint -Inf -1000 -> Infinity
dvix602 divideint -Inf -1 -> Infinity
dvix603 divideint -Inf -0 -> Infinity
dvix604 divideint -Inf 0 -> -Infinity
dvix605 divideint -Inf 1 -> -Infinity
dvix606 divideint -Inf 1000 -> -Infinity
dvix607 divideint -Inf Inf -> NaN Invalid_operation
dvix608 divideint -1000 Inf -> -0
dvix609 divideint -Inf -Inf -> NaN Invalid_operation
dvix610 divideint -1 -Inf -> 0
dvix611 divideint -0 -Inf -> 0
dvix612 divideint 0 -Inf -> -0
dvix613 divideint 1 -Inf -> -0
dvix614 divideint 1000 -Inf -> -0
dvix615 divideint Inf -Inf -> NaN Invalid_operation
dvix621 divideint NaN -Inf -> NaN
dvix622 divideint NaN -1000 -> NaN
dvix623 divideint NaN -1 -> NaN
dvix624 divideint NaN -0 -> NaN
dvix625 divideint NaN 0 -> NaN
dvix626 divideint NaN 1 -> NaN
dvix627 divideint NaN 1000 -> NaN
dvix628 divideint NaN Inf -> NaN
dvix629 divideint NaN NaN -> NaN
dvix630 divideint -Inf NaN -> NaN
dvix631 divideint -1000 NaN -> NaN
dvix632 divideint -1 NaN -> NaN
dvix633 divideint -0 NaN -> NaN
dvix634 divideint 0 NaN -> NaN
dvix635 divideint 1 NaN -> NaN
dvix636 divideint 1000 NaN -> NaN
dvix637 divideint Inf NaN -> NaN
dvix641 divideint sNaN -Inf -> NaN Invalid_operation
dvix642 divideint sNaN -1000 -> NaN Invalid_operation
dvix643 divideint sNaN -1 -> NaN Invalid_operation
dvix644 divideint sNaN -0 -> NaN Invalid_operation
dvix645 divideint sNaN 0 -> NaN Invalid_operation
dvix646 divideint sNaN 1 -> NaN Invalid_operation
dvix647 divideint sNaN 1000 -> NaN Invalid_operation
dvix648 divideint sNaN NaN -> NaN Invalid_operation
dvix649 divideint sNaN sNaN -> NaN Invalid_operation
dvix650 divideint NaN sNaN -> NaN Invalid_operation
dvix651 divideint -Inf sNaN -> NaN Invalid_operation
dvix652 divideint -1000 sNaN -> NaN Invalid_operation
dvix653 divideint -1 sNaN -> NaN Invalid_operation
dvix654 divideint -0 sNaN -> NaN Invalid_operation
dvix655 divideint 0 sNaN -> NaN Invalid_operation
dvix656 divideint 1 sNaN -> NaN Invalid_operation
dvix657 divideint 1000 sNaN -> NaN Invalid_operation
dvix658 divideint Inf sNaN -> NaN Invalid_operation
dvix659 divideint NaN sNaN -> NaN Invalid_operation
-- propagating NaNs
dvix661 divideint NaN9 -Inf -> NaN9
dvix662 divideint NaN8 1000 -> NaN8
dvix663 divideint NaN7 Inf -> NaN7
dvix664 divideint -NaN6 NaN5 -> -NaN6
dvix665 divideint -Inf NaN4 -> NaN4
dvix666 divideint -1000 NaN3 -> NaN3
dvix667 divideint Inf -NaN2 -> -NaN2
dvix671 divideint -sNaN99 -Inf -> -NaN99 Invalid_operation
dvix672 divideint sNaN98 -1 -> NaN98 Invalid_operation
dvix673 divideint sNaN97 NaN -> NaN97 Invalid_operation
dvix674 divideint sNaN96 sNaN94 -> NaN96 Invalid_operation
dvix675 divideint NaN95 sNaN93 -> NaN93 Invalid_operation
dvix676 divideint -Inf sNaN92 -> NaN92 Invalid_operation
dvix677 divideint 0 sNaN91 -> NaN91 Invalid_operation
dvix678 divideint Inf -sNaN90 -> -NaN90 Invalid_operation
dvix679 divideint NaN sNaN89 -> NaN89 Invalid_operation
-- some long operand cases again
precision: 8
dvix710 divideint 100000001 1 -> NaN Division_impossible
dvix711 divideint 100000000.4 1 -> NaN Division_impossible
dvix712 divideint 100000000.5 1 -> NaN Division_impossible
dvix713 divideint 100000000.9 1 -> NaN Division_impossible
dvix714 divideint 100000000.999 1 -> NaN Division_impossible
precision: 6
dvix720 divideint 100000000 1 -> NaN Division_impossible
dvix721 divideint 10000000 1 -> NaN Division_impossible
dvix722 divideint 1000000 1 -> NaN Division_impossible
dvix723 divideint 100000 1 -> 100000
dvix724 divideint 10000 1 -> 10000
dvix725 divideint 1000 1 -> 1000
dvix726 divideint 100 1 -> 100
dvix727 divideint 10 1 -> 10
dvix728 divideint 1 1 -> 1
dvix729 divideint 1 10 -> 0
precision: 9
maxexponent: 999999999
minexponent: -999999999
dvix732 divideint 1 0.99e999999999 -> 0
dvix733 divideint 1 0.999999999e999999999 -> 0
dvix734 divideint 9e999999999 1 -> NaN Division_impossible
dvix735 divideint 9.9e999999999 1 -> NaN Division_impossible
dvix736 divideint 9.99e999999999 1 -> NaN Division_impossible
dvix737 divideint 9.99999999e999999999 1 -> NaN Division_impossible
dvix740 divideint 0.1 9e-999999999 -> NaN Division_impossible
dvix741 divideint 0.1 99e-999999999 -> NaN Division_impossible
dvix742 divideint 0.1 999e-999999999 -> NaN Division_impossible
dvix743 divideint 0.1 9e-999999998 -> NaN Division_impossible
dvix744 divideint 0.1 99e-999999998 -> NaN Division_impossible
dvix745 divideint 0.1 999e-999999998 -> NaN Division_impossible
dvix746 divideint 0.1 999e-999999997 -> NaN Division_impossible
dvix747 divideint 0.1 9999e-999999997 -> NaN Division_impossible
dvix748 divideint 0.1 99999e-999999997 -> NaN Division_impossible
-- Null tests
dvix900 divideint 10 # -> NaN Invalid_operation
dvix901 divideint # 10 -> NaN Invalid_operation

215
sys/lib/python/test/decimaltestdata/inexact.decTest
View file

@ -1,215 +0,0 @@
------------------------------------------------------------------------
-- inexact.decTest -- decimal inexact and rounded edge cases --
-- Copyright (c) IBM Corporation, 1981, 2003. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
extended: 1
precision: 9
rounding: half_up
maxExponent: 999
minexponent: -999
inx001 add 1 1 -> 2
inx002 add 123456789 0 -> 123456789
inx003 add 123456789 0.0 -> 123456789 Rounded
inx004 add 123456789 0.00 -> 123456789 Rounded
inx005 add 123456789 1 -> 123456790
inx006 add 123456789 0.1 -> 123456789 Inexact Rounded
inx007 add 123456789 0.01 -> 123456789 Inexact Rounded
inx008 add 123456789 0.001 -> 123456789 Inexact Rounded
inx009 add 123456789 0.000001 -> 123456789 Inexact Rounded
inx010 add 123456789 0.000000001 -> 123456789 Inexact Rounded
inx011 add 123456789 0.000000000001 -> 123456789 Inexact Rounded
inx012 add 123456789 0.9 -> 123456790 Inexact Rounded
inx013 add 123456789 0.09 -> 123456789 Inexact Rounded
inx014 add 123456789 0.009 -> 123456789 Inexact Rounded
inx015 add 123456789 0.000009 -> 123456789 Inexact Rounded
inx016 add 123456789 0.000000009 -> 123456789 Inexact Rounded
inx017 add 123456789 0.000000000009 -> 123456789 Inexact Rounded
inx021 add 1 -1 -> 0
inx022 add 123456789 -0 -> 123456789
inx023 add 123456789 -0.0 -> 123456789 Rounded
inx024 add 123456789 -0.00 -> 123456789 Rounded
inx025 add 123456789 -1 -> 123456788
inx026 add 123456789 -0.1 -> 123456789 Inexact Rounded
inx027 add 123456789 -0.01 -> 123456789 Inexact Rounded
inx028 add 123456789 -0.001 -> 123456789 Inexact Rounded
inx029 add 123456789 -0.000001 -> 123456789 Inexact Rounded
inx030 add 123456789 -0.000000001 -> 123456789 Inexact Rounded
inx031 add 123456789 -0.000000000001 -> 123456789 Inexact Rounded
inx032 add 123456789 -0.9 -> 123456788 Inexact Rounded
inx033 add 123456789 -0.09 -> 123456789 Inexact Rounded
inx034 add 123456789 -0.009 -> 123456789 Inexact Rounded
inx035 add 123456789 -0.000009 -> 123456789 Inexact Rounded
inx036 add 123456789 -0.000000009 -> 123456789 Inexact Rounded
inx037 add 123456789 -0.000000000009 -> 123456789 Inexact Rounded
inx042 add 0 123456789 -> 123456789
inx043 add 0.0 123456789 -> 123456789 Rounded
inx044 add 0.00 123456789 -> 123456789 Rounded
inx045 add 1 123456789 -> 123456790
inx046 add 0.1 123456789 -> 123456789 Inexact Rounded
inx047 add 0.01 123456789 -> 123456789 Inexact Rounded
inx048 add 0.001 123456789 -> 123456789 Inexact Rounded
inx049 add 0.000001 123456789 -> 123456789 Inexact Rounded
inx050 add 0.000000001 123456789 -> 123456789 Inexact Rounded
inx051 add 0.000000000001 123456789 -> 123456789 Inexact Rounded
inx052 add 0.9 123456789 -> 123456790 Inexact Rounded
inx053 add 0.09 123456789 -> 123456789 Inexact Rounded
inx054 add 0.009 123456789 -> 123456789 Inexact Rounded
inx055 add 0.000009 123456789 -> 123456789 Inexact Rounded
inx056 add 0.000000009 123456789 -> 123456789 Inexact Rounded
inx057 add 0.000000000009 123456789 -> 123456789 Inexact Rounded
inx062 add -0 123456789 -> 123456789
inx063 add -0.0 123456789 -> 123456789 Rounded
inx064 add -0.00 123456789 -> 123456789 Rounded
inx065 add -1 123456789 -> 123456788
inx066 add -0.1 123456789 -> 123456789 Inexact Rounded
inx067 add -0.01 123456789 -> 123456789 Inexact Rounded
inx068 add -0.001 123456789 -> 123456789 Inexact Rounded
inx069 add -0.000001 123456789 -> 123456789 Inexact Rounded
inx070 add -0.000000001 123456789 -> 123456789 Inexact Rounded
inx071 add -0.000000000001 123456789 -> 123456789 Inexact Rounded
inx072 add -0.9 123456789 -> 123456788 Inexact Rounded
inx073 add -0.09 123456789 -> 123456789 Inexact Rounded
inx074 add -0.009 123456789 -> 123456789 Inexact Rounded
inx075 add -0.000009 123456789 -> 123456789 Inexact Rounded
inx076 add -0.000000009 123456789 -> 123456789 Inexact Rounded
inx077 add -0.000000000009 123456789 -> 123456789 Inexact Rounded
-- some boundaries
inx081 add 999999999 0 -> 999999999
inx082 add 0.999999999 0.000000000 -> 0.999999999
inx083 add 999999999 1 -> 1.00000000E+9 Rounded
inx084 add 0.999999999 0.000000001 -> 1.00000000 Rounded
inx085 add 999999999 2 -> 1.00000000E+9 Inexact Rounded
inx086 add 0.999999999 0.000000002 -> 1.00000000 Inexact Rounded
inx087 add 999999999 3 -> 1.00000000E+9 Inexact Rounded
inx089 add 0.999999999 0.000000003 -> 1.00000000 Inexact Rounded
-- minus, plus, and subtract all assumed to work like add.
-- multiply
precision: 8
inx101 multiply 1000 1000 -> 1000000
inx102 multiply 9000 9000 -> 81000000
inx103 multiply 9999 9999 -> 99980001
inx104 multiply 1000 10000 -> 10000000
inx105 multiply 10000 10000 -> 1.0000000E+8 Rounded
inx106 multiply 10001 10000 -> 1.0001000E+8 Rounded
inx107 multiply 10001 10001 -> 1.0002000E+8 Inexact Rounded
inx108 multiply 10101 10001 -> 1.0102010E+8 Inexact Rounded
inx109 multiply 10001 10101 -> 1.0102010E+8 Inexact Rounded
-- divide
precision: 4
inx201 divide 1000 1000 -> 1
inx202 divide 1000 1 -> 1000
inx203 divide 1000 2 -> 500
inx204 divide 1000 3 -> 333.3 Inexact Rounded
inx205 divide 1000 4 -> 250
inx206 divide 1000 5 -> 200
inx207 divide 1000 6 -> 166.7 Inexact Rounded
inx208 divide 1000 7 -> 142.9 Inexact Rounded
inx209 divide 1000 8 -> 125
inx210 divide 1000 9 -> 111.1 Inexact Rounded
inx211 divide 1000 10 -> 100
inx220 divide 1 1 -> 1
inx221 divide 1 2 -> 0.5
inx222 divide 1 4 -> 0.25
inx223 divide 1 8 -> 0.125
inx224 divide 1 16 -> 0.0625
inx225 divide 1 32 -> 0.03125
inx226 divide 1 64 -> 0.01563 Inexact Rounded
inx227 divide 1 128 -> 0.007813 Inexact Rounded
precision: 5
inx230 divide 1 1 -> 1
inx231 divide 1 2 -> 0.5
inx232 divide 1 4 -> 0.25
inx233 divide 1 8 -> 0.125
inx234 divide 1 16 -> 0.0625
inx235 divide 1 32 -> 0.03125
inx236 divide 1 64 -> 0.015625
inx237 divide 1 128 -> 0.0078125
precision: 3
inx240 divide 1 1 -> 1
inx241 divide 1 2 -> 0.5
inx242 divide 1 4 -> 0.25
inx243 divide 1 8 -> 0.125
inx244 divide 1 16 -> 0.0625
inx245 divide 1 32 -> 0.0313 Inexact Rounded
inx246 divide 1 64 -> 0.0156 Inexact Rounded
inx247 divide 1 128 -> 0.00781 Inexact Rounded
precision: 2
inx250 divide 1 1 -> 1
inx251 divide 1 2 -> 0.5
inx252 divide 1 4 -> 0.25
inx253 divide 1 8 -> 0.13 Inexact Rounded
inx254 divide 1 16 -> 0.063 Inexact Rounded
inx255 divide 1 32 -> 0.031 Inexact Rounded
inx256 divide 1 64 -> 0.016 Inexact Rounded
inx257 divide 1 128 -> 0.0078 Inexact Rounded
precision: 1
inx260 divide 1 1 -> 1
inx261 divide 1 2 -> 0.5
inx262 divide 1 4 -> 0.3 Inexact Rounded
inx263 divide 1 8 -> 0.1 Inexact Rounded
inx264 divide 1 16 -> 0.06 Inexact Rounded
inx265 divide 1 32 -> 0.03 Inexact Rounded
inx266 divide 1 64 -> 0.02 Inexact Rounded
inx267 divide 1 128 -> 0.008 Inexact Rounded
-- power
precision: 4
inx301 power 0.5 2 -> 0.25
inx302 power 0.5 4 -> 0.0625
inx303 power 0.5 8 -> 0.003906 Inexact Rounded
inx304 power 0.5 16 -> 0.00001526 Inexact Rounded
inx305 power 0.5 32 -> 2.328E-10 Inexact Rounded
-- compare, divideInteger, and remainder are always exact
-- rescale
precision: 4
inx401 rescale 0 0 -> 0
inx402 rescale 1 0 -> 1
inx403 rescale 0.1 +2 -> 0E+2 Inexact Rounded
inx404 rescale 0.1 +1 -> 0E+1 Inexact Rounded
inx405 rescale 0.1 0 -> 0 Inexact Rounded
inx406 rescale 0.1 -1 -> 0.1
inx407 rescale 0.1 -2 -> 0.10
-- long operands cause rounding too
precision: 9
inx801 plus 123456789 -> 123456789
inx802 plus 1234567890 -> 1.23456789E+9 Rounded
inx803 plus 1234567891 -> 1.23456789E+9 Inexact Rounded
inx804 plus 1234567892 -> 1.23456789E+9 Inexact Rounded
inx805 plus 1234567899 -> 1.23456790E+9 Inexact Rounded
inx806 plus 1234567900 -> 1.23456790E+9 Rounded

376
sys/lib/python/test/decimaltestdata/max.decTest
View file

@ -1,376 +0,0 @@
------------------------------------------------------------------------
-- max.decTest -- decimal maximum --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- we assume that base comparison is tested in compare.decTest, so
-- these mainly cover special cases and rounding
extended: 1
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
-- sanity checks
maxx001 max -2 -2 -> -2
maxx002 max -2 -1 -> -1
maxx003 max -2 0 -> 0
maxx004 max -2 1 -> 1
maxx005 max -2 2 -> 2
maxx006 max -1 -2 -> -1
maxx007 max -1 -1 -> -1
maxx008 max -1 0 -> 0
maxx009 max -1 1 -> 1
maxx010 max -1 2 -> 2
maxx011 max 0 -2 -> 0
maxx012 max 0 -1 -> 0
maxx013 max 0 0 -> 0
maxx014 max 0 1 -> 1
maxx015 max 0 2 -> 2
maxx016 max 1 -2 -> 1
maxx017 max 1 -1 -> 1
maxx018 max 1 0 -> 1
maxx019 max 1 1 -> 1
maxx020 max 1 2 -> 2
maxx021 max 2 -2 -> 2
maxx022 max 2 -1 -> 2
maxx023 max 2 0 -> 2
maxx025 max 2 1 -> 2
maxx026 max 2 2 -> 2
-- extended zeros
maxx030 max 0 0 -> 0
maxx031 max 0 -0 -> 0
maxx032 max 0 -0.0 -> 0
maxx033 max 0 0.0 -> 0
maxx034 max -0 0 -> 0 -- note: -0 = 0, but 0 chosen
maxx035 max -0 -0 -> -0
maxx036 max -0 -0.0 -> -0.0
maxx037 max -0 0.0 -> 0.0
maxx038 max 0.0 0 -> 0
maxx039 max 0.0 -0 -> 0.0
maxx040 max 0.0 -0.0 -> 0.0
maxx041 max 0.0 0.0 -> 0.0
maxx042 max -0.0 0 -> 0
maxx043 max -0.0 -0 -> -0.0
maxx044 max -0.0 -0.0 -> -0.0
maxx045 max -0.0 0.0 -> 0.0
maxx050 max -0E1 0E1 -> 0E+1
maxx051 max -0E2 0E2 -> 0E+2
maxx052 max -0E2 0E1 -> 0E+1
maxx053 max -0E1 0E2 -> 0E+2
maxx054 max 0E1 -0E1 -> 0E+1
maxx055 max 0E2 -0E2 -> 0E+2
maxx056 max 0E2 -0E1 -> 0E+2
maxx057 max 0E1 -0E2 -> 0E+1
maxx058 max 0E1 0E1 -> 0E+1
maxx059 max 0E2 0E2 -> 0E+2
maxx060 max 0E2 0E1 -> 0E+2
maxx061 max 0E1 0E2 -> 0E+2
maxx062 max -0E1 -0E1 -> -0E+1
maxx063 max -0E2 -0E2 -> -0E+2
maxx064 max -0E2 -0E1 -> -0E+1
maxx065 max -0E1 -0E2 -> -0E+1
-- Specials
precision: 9
maxx090 max Inf -Inf -> Infinity
maxx091 max Inf -1000 -> Infinity
maxx092 max Inf -1 -> Infinity
maxx093 max Inf -0 -> Infinity
maxx094 max Inf 0 -> Infinity
maxx095 max Inf 1 -> Infinity
maxx096 max Inf 1000 -> Infinity
maxx097 max Inf Inf -> Infinity
maxx098 max -1000 Inf -> Infinity
maxx099 max -Inf Inf -> Infinity
maxx100 max -1 Inf -> Infinity
maxx101 max -0 Inf -> Infinity
maxx102 max 0 Inf -> Infinity
maxx103 max 1 Inf -> Infinity
maxx104 max 1000 Inf -> Infinity
maxx105 max Inf Inf -> Infinity
maxx120 max -Inf -Inf -> -Infinity
maxx121 max -Inf -1000 -> -1000
maxx122 max -Inf -1 -> -1
maxx123 max -Inf -0 -> -0
maxx124 max -Inf 0 -> 0
maxx125 max -Inf 1 -> 1
maxx126 max -Inf 1000 -> 1000
maxx127 max -Inf Inf -> Infinity
maxx128 max -Inf -Inf -> -Infinity
maxx129 max -1000 -Inf -> -1000
maxx130 max -1 -Inf -> -1
maxx131 max -0 -Inf -> -0
maxx132 max 0 -Inf -> 0
maxx133 max 1 -Inf -> 1
maxx134 max 1000 -Inf -> 1000
maxx135 max Inf -Inf -> Infinity
-- 2004.08.02 754r chooses number over NaN in mixed cases
maxx141 max NaN -Inf -> -Infinity
maxx142 max NaN -1000 -> -1000
maxx143 max NaN -1 -> -1
maxx144 max NaN -0 -> -0
maxx145 max NaN 0 -> 0
maxx146 max NaN 1 -> 1
maxx147 max NaN 1000 -> 1000
maxx148 max NaN Inf -> Infinity
maxx149 max NaN NaN -> NaN
maxx150 max -Inf NaN -> -Infinity
maxx151 max -1000 NaN -> -1000
maxx152 max -1 NaN -> -1
maxx153 max -0 NaN -> -0
maxx154 max 0 NaN -> 0
maxx155 max 1 NaN -> 1
maxx156 max 1000 NaN -> 1000
maxx157 max Inf NaN -> Infinity
maxx161 max sNaN -Inf -> NaN Invalid_operation
maxx162 max sNaN -1000 -> NaN Invalid_operation
maxx163 max sNaN -1 -> NaN Invalid_operation
maxx164 max sNaN -0 -> NaN Invalid_operation
maxx165 max sNaN 0 -> NaN Invalid_operation
maxx166 max sNaN 1 -> NaN Invalid_operation
maxx167 max sNaN 1000 -> NaN Invalid_operation
maxx168 max sNaN NaN -> NaN Invalid_operation
maxx169 max sNaN sNaN -> NaN Invalid_operation
maxx170 max NaN sNaN -> NaN Invalid_operation
maxx171 max -Inf sNaN -> NaN Invalid_operation
maxx172 max -1000 sNaN -> NaN Invalid_operation
maxx173 max -1 sNaN -> NaN Invalid_operation
maxx174 max -0 sNaN -> NaN Invalid_operation
maxx175 max 0 sNaN -> NaN Invalid_operation
maxx176 max 1 sNaN -> NaN Invalid_operation
maxx177 max 1000 sNaN -> NaN Invalid_operation
maxx178 max Inf sNaN -> NaN Invalid_operation
maxx179 max NaN sNaN -> NaN Invalid_operation
-- propagating NaNs
maxx181 max NaN9 -Inf -> -Infinity
maxx182 max NaN8 9 -> 9
maxx183 max -NaN7 Inf -> Infinity
maxx184 max -NaN1 NaN11 -> -NaN1
maxx185 max NaN2 NaN12 -> NaN2
maxx186 max -NaN13 -NaN7 -> -NaN13
maxx187 max NaN14 -NaN5 -> NaN14
maxx188 max -Inf NaN4 -> -Infinity
maxx189 max -9 -NaN3 -> -9
maxx190 max Inf NaN2 -> Infinity
maxx191 max sNaN99 -Inf -> NaN99 Invalid_operation
maxx192 max sNaN98 -1 -> NaN98 Invalid_operation
maxx193 max -sNaN97 NaN -> -NaN97 Invalid_operation
maxx194 max sNaN96 sNaN94 -> NaN96 Invalid_operation
maxx195 max NaN95 sNaN93 -> NaN93 Invalid_operation
maxx196 max -Inf sNaN92 -> NaN92 Invalid_operation
maxx197 max 0 sNaN91 -> NaN91 Invalid_operation
maxx198 max Inf -sNaN90 -> -NaN90 Invalid_operation
maxx199 max NaN sNaN89 -> NaN89 Invalid_operation
-- rounding checks
maxexponent: 999
minexponent: -999
precision: 9
maxx201 max 12345678000 1 -> 1.23456780E+10 Rounded
maxx202 max 1 12345678000 -> 1.23456780E+10 Rounded
maxx203 max 1234567800 1 -> 1.23456780E+9 Rounded
maxx204 max 1 1234567800 -> 1.23456780E+9 Rounded
maxx205 max 1234567890 1 -> 1.23456789E+9 Rounded
maxx206 max 1 1234567890 -> 1.23456789E+9 Rounded
maxx207 max 1234567891 1 -> 1.23456789E+9 Inexact Rounded
maxx208 max 1 1234567891 -> 1.23456789E+9 Inexact Rounded
maxx209 max 12345678901 1 -> 1.23456789E+10 Inexact Rounded
maxx210 max 1 12345678901 -> 1.23456789E+10 Inexact Rounded
maxx211 max 1234567896 1 -> 1.23456790E+9 Inexact Rounded
maxx212 max 1 1234567896 -> 1.23456790E+9 Inexact Rounded
maxx213 max -1234567891 1 -> 1
maxx214 max 1 -1234567891 -> 1
maxx215 max -12345678901 1 -> 1
maxx216 max 1 -12345678901 -> 1
maxx217 max -1234567896 1 -> 1
maxx218 max 1 -1234567896 -> 1
precision: 15
maxx221 max 12345678000 1 -> 12345678000
maxx222 max 1 12345678000 -> 12345678000
maxx223 max 1234567800 1 -> 1234567800
maxx224 max 1 1234567800 -> 1234567800
maxx225 max 1234567890 1 -> 1234567890
maxx226 max 1 1234567890 -> 1234567890
maxx227 max 1234567891 1 -> 1234567891
maxx228 max 1 1234567891 -> 1234567891
maxx229 max 12345678901 1 -> 12345678901
maxx230 max 1 12345678901 -> 12345678901
maxx231 max 1234567896 1 -> 1234567896
maxx232 max 1 1234567896 -> 1234567896
maxx233 max -1234567891 1 -> 1
maxx234 max 1 -1234567891 -> 1
maxx235 max -12345678901 1 -> 1
maxx236 max 1 -12345678901 -> 1
maxx237 max -1234567896 1 -> 1
maxx238 max 1 -1234567896 -> 1
-- from examples
maxx280 max '3' '2' -> '3'
maxx281 max '-10' '3' -> '3'
maxx282 max '1.0' '1' -> '1'
maxx283 max '1' '1.0' -> '1'
maxx284 max '7' 'NaN' -> '7'
-- overflow and underflow tests ...
maxExponent: 999999999
minexponent: -999999999
maxx330 max +1.23456789012345E-0 9E+999999999 -> 9E+999999999
maxx331 max 9E+999999999 +1.23456789012345E-0 -> 9E+999999999
maxx332 max +0.100 9E-999999999 -> 0.100
maxx333 max 9E-999999999 +0.100 -> 0.100
maxx335 max -1.23456789012345E-0 9E+999999999 -> 9E+999999999
maxx336 max 9E+999999999 -1.23456789012345E-0 -> 9E+999999999
maxx337 max -0.100 9E-999999999 -> 9E-999999999
maxx338 max 9E-999999999 -0.100 -> 9E-999999999
maxx339 max 1e-599999999 1e-400000001 -> 1E-400000001
maxx340 max 1e-599999999 1e-400000000 -> 1E-400000000
maxx341 max 1e-600000000 1e-400000000 -> 1E-400000000
maxx342 max 9e-999999998 0.01 -> 0.01
maxx343 max 9e-999999998 0.1 -> 0.1
maxx344 max 0.01 9e-999999998 -> 0.01
maxx345 max 1e599999999 1e400000001 -> 1E+599999999
maxx346 max 1e599999999 1e400000000 -> 1E+599999999
maxx347 max 1e600000000 1e400000000 -> 1E+600000000
maxx348 max 9e999999998 100 -> 9E+999999998
maxx349 max 9e999999998 10 -> 9E+999999998
maxx350 max 100 9e999999998 -> 9E+999999998
-- signs
maxx351 max 1e+777777777 1e+411111111 -> 1E+777777777
maxx352 max 1e+777777777 -1e+411111111 -> 1E+777777777
maxx353 max -1e+777777777 1e+411111111 -> 1E+411111111
maxx354 max -1e+777777777 -1e+411111111 -> -1E+411111111
maxx355 max 1e-777777777 1e-411111111 -> 1E-411111111
maxx356 max 1e-777777777 -1e-411111111 -> 1E-777777777
maxx357 max -1e-777777777 1e-411111111 -> 1E-411111111
maxx358 max -1e-777777777 -1e-411111111 -> -1E-777777777
-- expanded list from min/max 754r purple prose
-- [explicit tests for exponent ordering]
maxx401 max Inf 1.1 -> Infinity
maxx402 max 1.1 1 -> 1.1
maxx403 max 1 1.0 -> 1
maxx404 max 1.0 0.1 -> 1.0
maxx405 max 0.1 0.10 -> 0.1
maxx406 max 0.10 0.100 -> 0.10
maxx407 max 0.10 0 -> 0.10
maxx408 max 0 0.0 -> 0
maxx409 max 0.0 -0 -> 0.0
maxx410 max 0.0 -0.0 -> 0.0
maxx411 max 0.00 -0.0 -> 0.00
maxx412 max 0.0 -0.00 -> 0.0
maxx413 max 0 -0.0 -> 0
maxx414 max 0 -0 -> 0
maxx415 max -0.0 -0 -> -0.0
maxx416 max -0 -0.100 -> -0
maxx417 max -0.100 -0.10 -> -0.100
maxx418 max -0.10 -0.1 -> -0.10
maxx419 max -0.1 -1.0 -> -0.1
maxx420 max -1.0 -1 -> -1.0
maxx421 max -1 -1.1 -> -1
maxx423 max -1.1 -Inf -> -1.1
-- same with operands reversed
maxx431 max 1.1 Inf -> Infinity
maxx432 max 1 1.1 -> 1.1
maxx433 max 1.0 1 -> 1
maxx434 max 0.1 1.0 -> 1.0
maxx435 max 0.10 0.1 -> 0.1
maxx436 max 0.100 0.10 -> 0.10
maxx437 max 0 0.10 -> 0.10
maxx438 max 0.0 0 -> 0
maxx439 max -0 0.0 -> 0.0
maxx440 max -0.0 0.0 -> 0.0
maxx441 max -0.0 0.00 -> 0.00
maxx442 max -0.00 0.0 -> 0.0
maxx443 max -0.0 0 -> 0
maxx444 max -0 0 -> 0
maxx445 max -0 -0.0 -> -0.0
maxx446 max -0.100 -0 -> -0
maxx447 max -0.10 -0.100 -> -0.100
maxx448 max -0.1 -0.10 -> -0.10
maxx449 max -1.0 -0.1 -> -0.1
maxx450 max -1 -1.0 -> -1.0
maxx451 max -1.1 -1 -> -1
maxx453 max -Inf -1.1 -> -1.1
-- largies
maxx460 max 1000 1E+3 -> 1E+3
maxx461 max 1E+3 1000 -> 1E+3
maxx462 max 1000 -1E+3 -> 1000
maxx463 max 1E+3 -1000 -> 1E+3
maxx464 max -1000 1E+3 -> 1E+3
maxx465 max -1E+3 1000 -> 1000
maxx466 max -1000 -1E+3 -> -1000
maxx467 max -1E+3 -1000 -> -1000
-- overflow tests
maxexponent: 999999999
minexponent: -999999999
precision: 3
maxx500 max 9.999E+999999999 0 -> Infinity Inexact Overflow Rounded
maxx501 max -9.999E+999999999 0 -> 0
-- subnormals and underflow
precision: 3
maxexponent: 999
minexponent: -999
maxx510 max 1.00E-999 0 -> 1.00E-999
maxx511 max 0.1E-999 0 -> 1E-1000 Subnormal
maxx512 max 0.10E-999 0 -> 1.0E-1000 Subnormal
maxx513 max 0.100E-999 0 -> 1.0E-1000 Subnormal Rounded
maxx514 max 0.01E-999 0 -> 1E-1001 Subnormal
-- next is rounded to Emin
maxx515 max 0.999E-999 0 -> 1.00E-999 Inexact Rounded Subnormal Underflow
maxx516 max 0.099E-999 0 -> 1.0E-1000 Inexact Rounded Subnormal Underflow
maxx517 max 0.009E-999 0 -> 1E-1001 Inexact Rounded Subnormal Underflow
maxx518 max 0.001E-999 0 -> 0E-1001 Inexact Rounded Subnormal Underflow
maxx519 max 0.0009E-999 0 -> 0E-1001 Inexact Rounded Subnormal Underflow
maxx520 max 0.0001E-999 0 -> 0E-1001 Inexact Rounded Subnormal Underflow
maxx530 max -1.00E-999 0 -> 0
maxx531 max -0.1E-999 0 -> 0
maxx532 max -0.10E-999 0 -> 0
maxx533 max -0.100E-999 0 -> 0
maxx534 max -0.01E-999 0 -> 0
maxx535 max -0.999E-999 0 -> 0
maxx536 max -0.099E-999 0 -> 0
maxx537 max -0.009E-999 0 -> 0
maxx538 max -0.001E-999 0 -> 0
maxx539 max -0.0009E-999 0 -> 0
maxx540 max -0.0001E-999 0 -> 0
-- Null tests
maxx900 max 10 # -> NaN Invalid_operation
maxx901 max # 10 -> NaN Invalid_operation

363
sys/lib/python/test/decimaltestdata/min.decTest
View file

@ -1,363 +0,0 @@
------------------------------------------------------------------------
-- min.decTest -- decimal minimum --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- we assume that base comparison is tested in compare.decTest, so
-- these mainly cover special cases and rounding
extended: 1
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
-- sanity checks
mnmx001 min -2 -2 -> -2
mnmx002 min -2 -1 -> -2
mnmx003 min -2 0 -> -2
mnmx004 min -2 1 -> -2
mnmx005 min -2 2 -> -2
mnmx006 min -1 -2 -> -2
mnmx007 min -1 -1 -> -1
mnmx008 min -1 0 -> -1
mnmx009 min -1 1 -> -1
mnmx010 min -1 2 -> -1
mnmx011 min 0 -2 -> -2
mnmx012 min 0 -1 -> -1
mnmx013 min 0 0 -> 0
mnmx014 min 0 1 -> 0
mnmx015 min 0 2 -> 0
mnmx016 min 1 -2 -> -2
mnmx017 min 1 -1 -> -1
mnmx018 min 1 0 -> 0
mnmx019 min 1 1 -> 1
mnmx020 min 1 2 -> 1
mnmx021 min 2 -2 -> -2
mnmx022 min 2 -1 -> -1
mnmx023 min 2 0 -> 0
mnmx025 min 2 1 -> 1
mnmx026 min 2 2 -> 2
-- extended zeros
mnmx030 min 0 0 -> 0
mnmx031 min 0 -0 -> -0
mnmx032 min 0 -0.0 -> -0.0
mnmx033 min 0 0.0 -> 0.0
mnmx034 min -0 0 -> -0
mnmx035 min -0 -0 -> -0
mnmx036 min -0 -0.0 -> -0
mnmx037 min -0 0.0 -> -0
mnmx038 min 0.0 0 -> 0.0
mnmx039 min 0.0 -0 -> -0
mnmx040 min 0.0 -0.0 -> -0.0
mnmx041 min 0.0 0.0 -> 0.0
mnmx042 min -0.0 0 -> -0.0
mnmx043 min -0.0 -0 -> -0
mnmx044 min -0.0 -0.0 -> -0.0
mnmx045 min -0.0 0.0 -> -0.0
mnmx046 min 0E1 -0E1 -> -0E+1
mnmx047 min -0E1 0E2 -> -0E+1
mnmx048 min 0E2 0E1 -> 0E+1
mnmx049 min 0E1 0E2 -> 0E+1
mnmx050 min -0E3 -0E2 -> -0E+3
mnmx051 min -0E2 -0E3 -> -0E+3
-- Specials
precision: 9
mnmx090 min Inf -Inf -> -Infinity
mnmx091 min Inf -1000 -> -1000
mnmx092 min Inf -1 -> -1
mnmx093 min Inf -0 -> -0
mnmx094 min Inf 0 -> 0
mnmx095 min Inf 1 -> 1
mnmx096 min Inf 1000 -> 1000
mnmx097 min Inf Inf -> Infinity
mnmx098 min -1000 Inf -> -1000
mnmx099 min -Inf Inf -> -Infinity
mnmx100 min -1 Inf -> -1
mnmx101 min -0 Inf -> -0
mnmx102 min 0 Inf -> 0
mnmx103 min 1 Inf -> 1
mnmx104 min 1000 Inf -> 1000
mnmx105 min Inf Inf -> Infinity
mnmx120 min -Inf -Inf -> -Infinity
mnmx121 min -Inf -1000 -> -Infinity
mnmx122 min -Inf -1 -> -Infinity
mnmx123 min -Inf -0 -> -Infinity
mnmx124 min -Inf 0 -> -Infinity
mnmx125 min -Inf 1 -> -Infinity
mnmx126 min -Inf 1000 -> -Infinity
mnmx127 min -Inf Inf -> -Infinity
mnmx128 min -Inf -Inf -> -Infinity
mnmx129 min -1000 -Inf -> -Infinity
mnmx130 min -1 -Inf -> -Infinity
mnmx131 min -0 -Inf -> -Infinity
mnmx132 min 0 -Inf -> -Infinity
mnmx133 min 1 -Inf -> -Infinity
mnmx134 min 1000 -Inf -> -Infinity
mnmx135 min Inf -Inf -> -Infinity
-- 2004.08.02 754r chooses number over NaN in mixed cases
mnmx141 min NaN -Inf -> -Infinity
mnmx142 min NaN -1000 -> -1000
mnmx143 min NaN -1 -> -1
mnmx144 min NaN -0 -> -0
mnmx145 min NaN 0 -> 0
mnmx146 min NaN 1 -> 1
mnmx147 min NaN 1000 -> 1000
mnmx148 min NaN Inf -> Infinity
mnmx149 min NaN NaN -> NaN
mnmx150 min -Inf NaN -> -Infinity
mnmx151 min -1000 NaN -> -1000
mnmx152 min -1 -NaN -> -1
mnmx153 min -0 NaN -> -0
mnmx154 min 0 -NaN -> 0
mnmx155 min 1 NaN -> 1
mnmx156 min 1000 NaN -> 1000
mnmx157 min Inf NaN -> Infinity
mnmx161 min sNaN -Inf -> NaN Invalid_operation
mnmx162 min sNaN -1000 -> NaN Invalid_operation
mnmx163 min sNaN -1 -> NaN Invalid_operation
mnmx164 min sNaN -0 -> NaN Invalid_operation
mnmx165 min -sNaN 0 -> -NaN Invalid_operation
mnmx166 min -sNaN 1 -> -NaN Invalid_operation
mnmx167 min sNaN 1000 -> NaN Invalid_operation
mnmx168 min sNaN NaN -> NaN Invalid_operation
mnmx169 min sNaN sNaN -> NaN Invalid_operation
mnmx170 min NaN sNaN -> NaN Invalid_operation
mnmx171 min -Inf sNaN -> NaN Invalid_operation
mnmx172 min -1000 sNaN -> NaN Invalid_operation
mnmx173 min -1 sNaN -> NaN Invalid_operation
mnmx174 min -0 sNaN -> NaN Invalid_operation
mnmx175 min 0 sNaN -> NaN Invalid_operation
mnmx176 min 1 sNaN -> NaN Invalid_operation
mnmx177 min 1000 sNaN -> NaN Invalid_operation
mnmx178 min Inf sNaN -> NaN Invalid_operation
mnmx179 min NaN sNaN -> NaN Invalid_operation
-- propagating NaNs
mnmx181 min NaN9 -Inf -> -Infinity
mnmx182 min -NaN8 9990 -> 9990
mnmx183 min NaN71 Inf -> Infinity
mnmx184 min NaN1 NaN54 -> NaN1
mnmx185 min NaN22 -NaN53 -> NaN22
mnmx186 min -NaN3 NaN6 -> -NaN3
mnmx187 min -NaN44 NaN7 -> -NaN44
mnmx188 min -Inf NaN41 -> -Infinity
mnmx189 min -9999 -NaN33 -> -9999
mnmx190 min Inf NaN2 -> Infinity
mnmx191 min sNaN99 -Inf -> NaN99 Invalid_operation
mnmx192 min sNaN98 -11 -> NaN98 Invalid_operation
mnmx193 min -sNaN97 NaN8 -> -NaN97 Invalid_operation
mnmx194 min sNaN69 sNaN94 -> NaN69 Invalid_operation
mnmx195 min NaN95 sNaN93 -> NaN93 Invalid_operation
mnmx196 min -Inf sNaN92 -> NaN92 Invalid_operation
mnmx197 min 088 sNaN91 -> NaN91 Invalid_operation
mnmx198 min Inf -sNaN90 -> -NaN90 Invalid_operation
mnmx199 min NaN sNaN86 -> NaN86 Invalid_operation
-- rounding checks -- chosen is rounded, or not
maxExponent: 999
minexponent: -999
precision: 9
mnmx201 min -12345678000 1 -> -1.23456780E+10 Rounded
mnmx202 min 1 -12345678000 -> -1.23456780E+10 Rounded
mnmx203 min -1234567800 1 -> -1.23456780E+9 Rounded
mnmx204 min 1 -1234567800 -> -1.23456780E+9 Rounded
mnmx205 min -1234567890 1 -> -1.23456789E+9 Rounded
mnmx206 min 1 -1234567890 -> -1.23456789E+9 Rounded
mnmx207 min -1234567891 1 -> -1.23456789E+9 Inexact Rounded
mnmx208 min 1 -1234567891 -> -1.23456789E+9 Inexact Rounded
mnmx209 min -12345678901 1 -> -1.23456789E+10 Inexact Rounded
mnmx210 min 1 -12345678901 -> -1.23456789E+10 Inexact Rounded
mnmx211 min -1234567896 1 -> -1.23456790E+9 Inexact Rounded
mnmx212 min 1 -1234567896 -> -1.23456790E+9 Inexact Rounded
mnmx213 min 1234567891 1 -> 1
mnmx214 min 1 1234567891 -> 1
mnmx215 min 12345678901 1 -> 1
mnmx216 min 1 12345678901 -> 1
mnmx217 min 1234567896 1 -> 1
mnmx218 min 1 1234567896 -> 1
precision: 15
mnmx221 min -12345678000 1 -> -12345678000
mnmx222 min 1 -12345678000 -> -12345678000
mnmx223 min -1234567800 1 -> -1234567800
mnmx224 min 1 -1234567800 -> -1234567800
mnmx225 min -1234567890 1 -> -1234567890
mnmx226 min 1 -1234567890 -> -1234567890
mnmx227 min -1234567891 1 -> -1234567891
mnmx228 min 1 -1234567891 -> -1234567891
mnmx229 min -12345678901 1 -> -12345678901
mnmx230 min 1 -12345678901 -> -12345678901
mnmx231 min -1234567896 1 -> -1234567896
mnmx232 min 1 -1234567896 -> -1234567896
mnmx233 min 1234567891 1 -> 1
mnmx234 min 1 1234567891 -> 1
mnmx235 min 12345678901 1 -> 1
mnmx236 min 1 12345678901 -> 1
mnmx237 min 1234567896 1 -> 1
mnmx238 min 1 1234567896 -> 1
-- from examples
mnmx280 min '3' '2' -> '2'
mnmx281 min '-10' '3' -> '-10'
mnmx282 min '1.0' '1' -> '1.0'
mnmx283 min '1' '1.0' -> '1.0'
mnmx284 min '7' 'NaN' -> '7'
-- overflow and underflow tests .. subnormal results [inputs] now allowed
maxExponent: 999999999
minexponent: -999999999
mnmx330 min -1.23456789012345E-0 -9E+999999999 -> -9E+999999999
mnmx331 min -9E+999999999 -1.23456789012345E-0 -> -9E+999999999
mnmx332 min -0.100 -9E-999999999 -> -0.100
mnmx333 min -9E-999999999 -0.100 -> -0.100
mnmx335 min +1.23456789012345E-0 -9E+999999999 -> -9E+999999999
mnmx336 min -9E+999999999 1.23456789012345E-0 -> -9E+999999999
mnmx337 min +0.100 -9E-999999999 -> -9E-999999999
mnmx338 min -9E-999999999 0.100 -> -9E-999999999
mnmx339 min -1e-599999999 -1e-400000001 -> -1E-400000001
mnmx340 min -1e-599999999 -1e-400000000 -> -1E-400000000
mnmx341 min -1e-600000000 -1e-400000000 -> -1E-400000000
mnmx342 min -9e-999999998 -0.01 -> -0.01
mnmx343 min -9e-999999998 -0.1 -> -0.1
mnmx344 min -0.01 -9e-999999998 -> -0.01
mnmx345 min -1e599999999 -1e400000001 -> -1E+599999999
mnmx346 min -1e599999999 -1e400000000 -> -1E+599999999
mnmx347 min -1e600000000 -1e400000000 -> -1E+600000000
mnmx348 min -9e999999998 -100 -> -9E+999999998
mnmx349 min -9e999999998 -10 -> -9E+999999998
mnmx350 min -100 -9e999999998 -> -9E+999999998
-- signs
mnmx351 min -1e+777777777 -1e+411111111 -> -1E+777777777
mnmx352 min -1e+777777777 +1e+411111111 -> -1E+777777777
mnmx353 min +1e+777777777 -1e+411111111 -> -1E+411111111
mnmx354 min +1e+777777777 +1e+411111111 -> 1E+411111111
mnmx355 min -1e-777777777 -1e-411111111 -> -1E-411111111
mnmx356 min -1e-777777777 +1e-411111111 -> -1E-777777777
mnmx357 min +1e-777777777 -1e-411111111 -> -1E-411111111
mnmx358 min +1e-777777777 +1e-411111111 -> 1E-777777777
-- expanded list from min/max 754r purple prose
-- [explicit tests for exponent ordering]
mnmx401 min Inf 1.1 -> 1.1
mnmx402 min 1.1 1 -> 1
mnmx403 min 1 1.0 -> 1.0
mnmx404 min 1.0 0.1 -> 0.1
mnmx405 min 0.1 0.10 -> 0.10
mnmx406 min 0.10 0.100 -> 0.100
mnmx407 min 0.10 0 -> 0
mnmx408 min 0 0.0 -> 0.0
mnmx409 min 0.0 -0 -> -0
mnmx410 min 0.0 -0.0 -> -0.0
mnmx411 min 0.00 -0.0 -> -0.0
mnmx412 min 0.0 -0.00 -> -0.00
mnmx413 min 0 -0.0 -> -0.0
mnmx414 min 0 -0 -> -0
mnmx415 min -0.0 -0 -> -0
mnmx416 min -0 -0.100 -> -0.100
mnmx417 min -0.100 -0.10 -> -0.10
mnmx418 min -0.10 -0.1 -> -0.1
mnmx419 min -0.1 -1.0 -> -1.0
mnmx420 min -1.0 -1 -> -1
mnmx421 min -1 -1.1 -> -1.1
mnmx423 min -1.1 -Inf -> -Infinity
-- same with operands reversed
mnmx431 min 1.1 Inf -> 1.1
mnmx432 min 1 1.1 -> 1
mnmx433 min 1.0 1 -> 1.0
mnmx434 min 0.1 1.0 -> 0.1
mnmx435 min 0.10 0.1 -> 0.10
mnmx436 min 0.100 0.10 -> 0.100
mnmx437 min 0 0.10 -> 0
mnmx438 min 0.0 0 -> 0.0
mnmx439 min -0 0.0 -> -0
mnmx440 min -0.0 0.0 -> -0.0
mnmx441 min -0.0 0.00 -> -0.0
mnmx442 min -0.00 0.0 -> -0.00
mnmx443 min -0.0 0 -> -0.0
mnmx444 min -0 0 -> -0
mnmx445 min -0 -0.0 -> -0
mnmx446 min -0.100 -0 -> -0.100
mnmx447 min -0.10 -0.100 -> -0.10
mnmx448 min -0.1 -0.10 -> -0.1
mnmx449 min -1.0 -0.1 -> -1.0
mnmx450 min -1 -1.0 -> -1
mnmx451 min -1.1 -1 -> -1.1
mnmx453 min -Inf -1.1 -> -Infinity
-- largies
mnmx460 min 1000 1E+3 -> 1000
mnmx461 min 1E+3 1000 -> 1000
mnmx462 min 1000 -1E+3 -> -1E+3
mnmx463 min 1E+3 -1000 -> -1000
mnmx464 min -1000 1E+3 -> -1000
mnmx465 min -1E+3 1000 -> -1E+3
mnmx466 min -1000 -1E+3 -> -1E+3
mnmx467 min -1E+3 -1000 -> -1E+3
-- overflow tests
maxexponent: 999999999
minexponent: -999999999
precision: 3
mnmx500 min 9.999E+999999999 0 -> 0
mnmx501 min -9.999E+999999999 0 -> -Infinity Inexact Overflow Rounded
-- subnormals and underflow
precision: 3
maxexponent: 999
minexponent: -999
mnmx510 min 1.00E-999 0 -> 0
mnmx511 min 0.1E-999 0 -> 0
mnmx512 min 0.10E-999 0 -> 0
mnmx513 min 0.100E-999 0 -> 0
mnmx514 min 0.01E-999 0 -> 0
mnmx515 min 0.999E-999 0 -> 0
mnmx516 min 0.099E-999 0 -> 0
mnmx517 min 0.009E-999 0 -> 0
mnmx518 min 0.001E-999 0 -> 0
mnmx519 min 0.0009E-999 0 -> 0
mnmx520 min 0.0001E-999 0 -> 0
mnmx530 min -1.00E-999 0 -> -1.00E-999
mnmx531 min -0.1E-999 0 -> -1E-1000 Subnormal
mnmx532 min -0.10E-999 0 -> -1.0E-1000 Subnormal
mnmx533 min -0.100E-999 0 -> -1.0E-1000 Subnormal Rounded
mnmx534 min -0.01E-999 0 -> -1E-1001 Subnormal
-- next is rounded to Emin
mnmx535 min -0.999E-999 0 -> -1.00E-999 Inexact Rounded Subnormal Underflow
mnmx536 min -0.099E-999 0 -> -1.0E-1000 Inexact Rounded Subnormal Underflow
mnmx537 min -0.009E-999 0 -> -1E-1001 Inexact Rounded Subnormal Underflow
mnmx538 min -0.001E-999 0 -> -0E-1001 Inexact Rounded Subnormal Underflow
mnmx539 min -0.0009E-999 0 -> -0E-1001 Inexact Rounded Subnormal Underflow
mnmx540 min -0.0001E-999 0 -> -0E-1001 Inexact Rounded Subnormal Underflow
-- Null tests
mnm900 min 10 # -> NaN Invalid_operation
mnm901 min # 10 -> NaN Invalid_operation

182
sys/lib/python/test/decimaltestdata/minus.decTest
View file

@ -1,182 +0,0 @@
------------------------------------------------------------------------
-- minus.decTest -- decimal negation --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- This set of tests primarily tests the existence of the operator.
-- Subtraction, rounding, and more overflows are tested elsewhere.
extended: 1
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
minx001 minus '1' -> '-1'
minx002 minus '-1' -> '1'
minx003 minus '1.00' -> '-1.00'
minx004 minus '-1.00' -> '1.00'
minx005 minus '0' -> '0'
minx006 minus '0.00' -> '0.00'
minx007 minus '00.0' -> '0.0'
minx008 minus '00.00' -> '0.00'
minx009 minus '00' -> '0'
minx010 minus '-2' -> '2'
minx011 minus '2' -> '-2'
minx012 minus '-2.00' -> '2.00'
minx013 minus '2.00' -> '-2.00'
minx014 minus '-0' -> '0'
minx015 minus '-0.00' -> '0.00'
minx016 minus '-00.0' -> '0.0'
minx017 minus '-00.00' -> '0.00'
minx018 minus '-00' -> '0'
-- "lhs" zeros in plus and minus have exponent = operand
minx020 minus '-0E3' -> '0E+3'
minx021 minus '-0E2' -> '0E+2'
minx022 minus '-0E1' -> '0E+1'
minx023 minus '-0E0' -> '0'
minx024 minus '+0E0' -> '0'
minx025 minus '+0E1' -> '0E+1'
minx026 minus '+0E2' -> '0E+2'
minx027 minus '+0E3' -> '0E+3'
minx030 minus '-5E3' -> '5E+3'
minx031 minus '-5E8' -> '5E+8'
minx032 minus '-5E13' -> '5E+13'
minx033 minus '-5E18' -> '5E+18'
minx034 minus '+5E3' -> '-5E+3'
minx035 minus '+5E8' -> '-5E+8'
minx036 minus '+5E13' -> '-5E+13'
minx037 minus '+5E18' -> '-5E+18'
minx050 minus '-2000000' -> '2000000'
minx051 minus '2000000' -> '-2000000'
precision: 7
minx052 minus '-2000000' -> '2000000'
minx053 minus '2000000' -> '-2000000'
precision: 6
minx054 minus '-2000000' -> '2.00000E+6' Rounded
minx055 minus '2000000' -> '-2.00000E+6' Rounded
precision: 3
minx056 minus '-2000000' -> '2.00E+6' Rounded
minx057 minus '2000000' -> '-2.00E+6' Rounded
-- more fixed, potential LHS swaps/overlays if done by 0 subtract x
precision: 9
minx060 minus '56267E-10' -> '-0.0000056267'
minx061 minus '56267E-5' -> '-0.56267'
minx062 minus '56267E-2' -> '-562.67'
minx063 minus '56267E-1' -> '-5626.7'
minx065 minus '56267E-0' -> '-56267'
minx066 minus '56267E+0' -> '-56267'
minx067 minus '56267E+1' -> '-5.6267E+5'
minx068 minus '56267E+2' -> '-5.6267E+6'
minx069 minus '56267E+3' -> '-5.6267E+7'
minx070 minus '56267E+4' -> '-5.6267E+8'
minx071 minus '56267E+5' -> '-5.6267E+9'
minx072 minus '56267E+6' -> '-5.6267E+10'
minx080 minus '-56267E-10' -> '0.0000056267'
minx081 minus '-56267E-5' -> '0.56267'
minx082 minus '-56267E-2' -> '562.67'
minx083 minus '-56267E-1' -> '5626.7'
minx085 minus '-56267E-0' -> '56267'
minx086 minus '-56267E+0' -> '56267'
minx087 minus '-56267E+1' -> '5.6267E+5'
minx088 minus '-56267E+2' -> '5.6267E+6'
minx089 minus '-56267E+3' -> '5.6267E+7'
minx090 minus '-56267E+4' -> '5.6267E+8'
minx091 minus '-56267E+5' -> '5.6267E+9'
minx092 minus '-56267E+6' -> '5.6267E+10'
-- overflow tests
maxexponent: 999999999
minexponent: -999999999
precision: 3
minx100 minus 9.999E+999999999 -> -Infinity Inexact Overflow Rounded
minx101 minus -9.999E+999999999 -> Infinity Inexact Overflow Rounded
-- subnormals and underflow
precision: 3
maxexponent: 999
minexponent: -999
minx110 minus 1.00E-999 -> -1.00E-999
minx111 minus 0.1E-999 -> -1E-1000 Subnormal
minx112 minus 0.10E-999 -> -1.0E-1000 Subnormal
minx113 minus 0.100E-999 -> -1.0E-1000 Subnormal Rounded
minx114 minus 0.01E-999 -> -1E-1001 Subnormal
-- next is rounded to Emin
minx115 minus 0.999E-999 -> -1.00E-999 Inexact Rounded Subnormal Underflow
minx116 minus 0.099E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow
minx117 minus 0.009E-999 -> -1E-1001 Inexact Rounded Subnormal Underflow
minx118 minus 0.001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow
minx119 minus 0.0009E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow
minx120 minus 0.0001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow
minx130 minus -1.00E-999 -> 1.00E-999
minx131 minus -0.1E-999 -> 1E-1000 Subnormal
minx132 minus -0.10E-999 -> 1.0E-1000 Subnormal
minx133 minus -0.100E-999 -> 1.0E-1000 Subnormal Rounded
minx134 minus -0.01E-999 -> 1E-1001 Subnormal
-- next is rounded to Emin
minx135 minus -0.999E-999 -> 1.00E-999 Inexact Rounded Subnormal Underflow
minx136 minus -0.099E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow
minx137 minus -0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow
minx138 minus -0.001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
minx139 minus -0.0009E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
minx140 minus -0.0001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
-- long operand checks
maxexponent: 999
minexponent: -999
precision: 9
minx301 minus 12345678000 -> -1.23456780E+10 Rounded
minx302 minus 1234567800 -> -1.23456780E+9 Rounded
minx303 minus 1234567890 -> -1.23456789E+9 Rounded
minx304 minus 1234567891 -> -1.23456789E+9 Inexact Rounded
minx305 minus 12345678901 -> -1.23456789E+10 Inexact Rounded
minx306 minus 1234567896 -> -1.23456790E+9 Inexact Rounded
precision: 15
-- still checking
minx321 minus 12345678000 -> -12345678000
minx322 minus 1234567800 -> -1234567800
minx323 minus 1234567890 -> -1234567890
minx324 minus 1234567891 -> -1234567891
minx325 minus 12345678901 -> -12345678901
minx326 minus 1234567896 -> -1234567896
-- specials
minx420 minus 'Inf' -> '-Infinity'
minx421 minus '-Inf' -> 'Infinity'
minx422 minus NaN -> NaN
minx423 minus sNaN -> NaN Invalid_operation
minx424 minus NaN255 -> NaN255
minx425 minus sNaN256 -> NaN256 Invalid_operation
minx426 minus -NaN -> -NaN
minx427 minus -sNaN -> -NaN Invalid_operation
minx428 minus -NaN255 -> -NaN255
minx429 minus -sNaN256 -> -NaN256 Invalid_operation
-- Null tests
minx900 minus # -> NaN Invalid_operation

651
sys/lib/python/test/decimaltestdata/multiply.decTest
View file

@ -1,651 +0,0 @@
------------------------------------------------------------------------
-- multiply.decTest -- decimal multiplication --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
extended: 1
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
-- sanity checks (as base, above)
mulx000 multiply 2 2 -> 4
mulx001 multiply 2 3 -> 6
mulx002 multiply 5 1 -> 5
mulx003 multiply 5 2 -> 10
mulx004 multiply 1.20 2 -> 2.40
mulx005 multiply 1.20 0 -> 0.00
mulx006 multiply 1.20 -2 -> -2.40
mulx007 multiply -1.20 2 -> -2.40
mulx008 multiply -1.20 0 -> -0.00
mulx009 multiply -1.20 -2 -> 2.40
mulx010 multiply 5.09 7.1 -> 36.139
mulx011 multiply 2.5 4 -> 10.0
mulx012 multiply 2.50 4 -> 10.00
mulx013 multiply 1.23456789 1.00000000 -> 1.23456789 Rounded
mulx014 multiply 9.999999999 9.999999999 -> 100.000000 Inexact Rounded
mulx015 multiply 2.50 4 -> 10.00
precision: 6
mulx016 multiply 2.50 4 -> 10.00
mulx017 multiply 9.999999999 9.999999999 -> 100.000 Inexact Rounded
-- 1999.12.21: next one is a edge case if intermediate longs are used
precision: 15
mulx019 multiply 999999999999 9765625 -> 9.76562499999023E+18 Inexact Rounded
precision: 30
mulx160 multiply 999999999999 9765625 -> 9765624999990234375
precision: 9
-----
-- zeros, etc.
mulx020 multiply 0 0 -> 0
mulx021 multiply 0 -0 -> -0
mulx022 multiply -0 0 -> -0
mulx023 multiply -0 -0 -> 0
mulx030 multiply 5.00 1E-3 -> 0.00500
mulx031 multiply 00.00 0.000 -> 0.00000
mulx032 multiply 00.00 0E-3 -> 0.00000 -- rhs is 0
mulx033 multiply 0E-3 00.00 -> 0.00000 -- lhs is 0
mulx034 multiply -5.00 1E-3 -> -0.00500
mulx035 multiply -00.00 0.000 -> -0.00000
mulx036 multiply -00.00 0E-3 -> -0.00000 -- rhs is 0
mulx037 multiply -0E-3 00.00 -> -0.00000 -- lhs is 0
mulx038 multiply 5.00 -1E-3 -> -0.00500
mulx039 multiply 00.00 -0.000 -> -0.00000
mulx040 multiply 00.00 -0E-3 -> -0.00000 -- rhs is 0
mulx041 multiply 0E-3 -00.00 -> -0.00000 -- lhs is 0
mulx042 multiply -5.00 -1E-3 -> 0.00500
mulx043 multiply -00.00 -0.000 -> 0.00000
mulx044 multiply -00.00 -0E-3 -> 0.00000 -- rhs is 0
mulx045 multiply -0E-3 -00.00 -> 0.00000 -- lhs is 0
-- examples from decarith
mulx050 multiply 1.20 3 -> 3.60
mulx051 multiply 7 3 -> 21
mulx052 multiply 0.9 0.8 -> 0.72
mulx053 multiply 0.9 -0 -> -0.0
mulx054 multiply 654321 654321 -> 4.28135971E+11 Inexact Rounded
mulx060 multiply 123.45 1e7 -> 1.2345E+9
mulx061 multiply 123.45 1e8 -> 1.2345E+10
mulx062 multiply 123.45 1e+9 -> 1.2345E+11
mulx063 multiply 123.45 1e10 -> 1.2345E+12
mulx064 multiply 123.45 1e11 -> 1.2345E+13
mulx065 multiply 123.45 1e12 -> 1.2345E+14
mulx066 multiply 123.45 1e13 -> 1.2345E+15
-- test some intermediate lengths
precision: 9
mulx080 multiply 0.1 123456789 -> 12345678.9
mulx081 multiply 0.1 1234567891 -> 123456789 Inexact Rounded
mulx082 multiply 0.1 12345678912 -> 1.23456789E+9 Inexact Rounded
mulx083 multiply 0.1 12345678912345 -> 1.23456789E+12 Inexact Rounded
mulx084 multiply 0.1 123456789 -> 12345678.9
precision: 8
mulx085 multiply 0.1 12345678912 -> 1.2345679E+9 Inexact Rounded
mulx086 multiply 0.1 12345678912345 -> 1.2345679E+12 Inexact Rounded
precision: 7
mulx087 multiply 0.1 12345678912 -> 1.234568E+9 Inexact Rounded
mulx088 multiply 0.1 12345678912345 -> 1.234568E+12 Inexact Rounded
precision: 9
mulx090 multiply 123456789 0.1 -> 12345678.9
mulx091 multiply 1234567891 0.1 -> 123456789 Inexact Rounded
mulx092 multiply 12345678912 0.1 -> 1.23456789E+9 Inexact Rounded
mulx093 multiply 12345678912345 0.1 -> 1.23456789E+12 Inexact Rounded
mulx094 multiply 123456789 0.1 -> 12345678.9
precision: 8
mulx095 multiply 12345678912 0.1 -> 1.2345679E+9 Inexact Rounded
mulx096 multiply 12345678912345 0.1 -> 1.2345679E+12 Inexact Rounded
precision: 7
mulx097 multiply 12345678912 0.1 -> 1.234568E+9 Inexact Rounded
mulx098 multiply 12345678912345 0.1 -> 1.234568E+12 Inexact Rounded
-- test some more edge cases and carries
maxexponent: 9999
minexponent: -9999
precision: 33
mulx101 multiply 9 9 -> 81
mulx102 multiply 9 90 -> 810
mulx103 multiply 9 900 -> 8100
mulx104 multiply 9 9000 -> 81000
mulx105 multiply 9 90000 -> 810000
mulx106 multiply 9 900000 -> 8100000
mulx107 multiply 9 9000000 -> 81000000
mulx108 multiply 9 90000000 -> 810000000
mulx109 multiply 9 900000000 -> 8100000000
mulx110 multiply 9 9000000000 -> 81000000000
mulx111 multiply 9 90000000000 -> 810000000000
mulx112 multiply 9 900000000000 -> 8100000000000
mulx113 multiply 9 9000000000000 -> 81000000000000
mulx114 multiply 9 90000000000000 -> 810000000000000
mulx115 multiply 9 900000000000000 -> 8100000000000000
mulx116 multiply 9 9000000000000000 -> 81000000000000000
mulx117 multiply 9 90000000000000000 -> 810000000000000000
mulx118 multiply 9 900000000000000000 -> 8100000000000000000
mulx119 multiply 9 9000000000000000000 -> 81000000000000000000
mulx120 multiply 9 90000000000000000000 -> 810000000000000000000
mulx121 multiply 9 900000000000000000000 -> 8100000000000000000000
mulx122 multiply 9 9000000000000000000000 -> 81000000000000000000000
mulx123 multiply 9 90000000000000000000000 -> 810000000000000000000000
-- test some more edge cases without carries
mulx131 multiply 3 3 -> 9
mulx132 multiply 3 30 -> 90
mulx133 multiply 3 300 -> 900
mulx134 multiply 3 3000 -> 9000
mulx135 multiply 3 30000 -> 90000
mulx136 multiply 3 300000 -> 900000
mulx137 multiply 3 3000000 -> 9000000
mulx138 multiply 3 30000000 -> 90000000
mulx139 multiply 3 300000000 -> 900000000
mulx140 multiply 3 3000000000 -> 9000000000
mulx141 multiply 3 30000000000 -> 90000000000
mulx142 multiply 3 300000000000 -> 900000000000
mulx143 multiply 3 3000000000000 -> 9000000000000
mulx144 multiply 3 30000000000000 -> 90000000000000
mulx145 multiply 3 300000000000000 -> 900000000000000
mulx146 multiply 3 3000000000000000 -> 9000000000000000
mulx147 multiply 3 30000000000000000 -> 90000000000000000
mulx148 multiply 3 300000000000000000 -> 900000000000000000
mulx149 multiply 3 3000000000000000000 -> 9000000000000000000
mulx150 multiply 3 30000000000000000000 -> 90000000000000000000
mulx151 multiply 3 300000000000000000000 -> 900000000000000000000
mulx152 multiply 3 3000000000000000000000 -> 9000000000000000000000
mulx153 multiply 3 30000000000000000000000 -> 90000000000000000000000
maxexponent: 999999999
minexponent: -999999999
precision: 9
-- test some cases that are close to exponent overflow/underflow
mulx170 multiply 1 9e999999999 -> 9E+999999999
mulx171 multiply 1 9.9e999999999 -> 9.9E+999999999
mulx172 multiply 1 9.99e999999999 -> 9.99E+999999999
mulx173 multiply 9e999999999 1 -> 9E+999999999
mulx174 multiply 9.9e999999999 1 -> 9.9E+999999999
mulx176 multiply 9.99e999999999 1 -> 9.99E+999999999
mulx177 multiply 1 9.99999999e999999999 -> 9.99999999E+999999999
mulx178 multiply 9.99999999e999999999 1 -> 9.99999999E+999999999
mulx180 multiply 0.1 9e-999999998 -> 9E-999999999
mulx181 multiply 0.1 99e-999999998 -> 9.9E-999999998
mulx182 multiply 0.1 999e-999999998 -> 9.99E-999999997
mulx183 multiply 0.1 9e-999999998 -> 9E-999999999
mulx184 multiply 0.1 99e-999999998 -> 9.9E-999999998
mulx185 multiply 0.1 999e-999999998 -> 9.99E-999999997
mulx186 multiply 0.1 999e-999999997 -> 9.99E-999999996
mulx187 multiply 0.1 9999e-999999997 -> 9.999E-999999995
mulx188 multiply 0.1 99999e-999999997 -> 9.9999E-999999994
mulx190 multiply 1 9e-999999998 -> 9E-999999998
mulx191 multiply 1 99e-999999998 -> 9.9E-999999997
mulx192 multiply 1 999e-999999998 -> 9.99E-999999996
mulx193 multiply 9e-999999998 1 -> 9E-999999998
mulx194 multiply 99e-999999998 1 -> 9.9E-999999997
mulx195 multiply 999e-999999998 1 -> 9.99E-999999996
mulx196 multiply 1e-599999999 1e-400000000 -> 1E-999999999
mulx197 multiply 1e-600000000 1e-399999999 -> 1E-999999999
mulx198 multiply 1.2e-599999999 1.2e-400000000 -> 1.44E-999999999
mulx199 multiply 1.2e-600000000 1.2e-399999999 -> 1.44E-999999999
mulx201 multiply 1e599999999 1e400000000 -> 1E+999999999
mulx202 multiply 1e600000000 1e399999999 -> 1E+999999999
mulx203 multiply 1.2e599999999 1.2e400000000 -> 1.44E+999999999
mulx204 multiply 1.2e600000000 1.2e399999999 -> 1.44E+999999999
-- long operand triangle
precision: 33
mulx246 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193369671916511992830 Inexact Rounded
precision: 32
mulx247 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119336967191651199283 Inexact Rounded
precision: 31
mulx248 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011933696719165119928 Inexact Rounded
precision: 30
mulx249 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193369671916511993 Inexact Rounded
precision: 29
mulx250 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119336967191651199 Inexact Rounded
precision: 28
mulx251 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011933696719165120 Inexact Rounded
precision: 27
mulx252 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193369671916512 Inexact Rounded
precision: 26
mulx253 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119336967191651 Inexact Rounded
precision: 25
mulx254 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011933696719165 Inexact Rounded
precision: 24
mulx255 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193369671917 Inexact Rounded
precision: 23
mulx256 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119336967192 Inexact Rounded
precision: 22
mulx257 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011933696719 Inexact Rounded
precision: 21
mulx258 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193369672 Inexact Rounded
precision: 20
mulx259 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119336967 Inexact Rounded
precision: 19
mulx260 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011933697 Inexact Rounded
precision: 18
mulx261 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193370 Inexact Rounded
precision: 17
mulx262 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119337 Inexact Rounded
precision: 16
mulx263 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908011934 Inexact Rounded
precision: 15
mulx264 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801193 Inexact Rounded
precision: 14
mulx265 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080119 Inexact Rounded
precision: 13
mulx266 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908012 Inexact Rounded
precision: 12
mulx267 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.290801 Inexact Rounded
precision: 11
mulx268 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29080 Inexact Rounded
precision: 10
mulx269 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.2908 Inexact Rounded
precision: 9
mulx270 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.291 Inexact Rounded
precision: 8
mulx271 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.29 Inexact Rounded
precision: 7
mulx272 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433.3 Inexact Rounded
precision: 6
mulx273 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 145433 Inexact Rounded
precision: 5
mulx274 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 1.4543E+5 Inexact Rounded
precision: 4
mulx275 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 1.454E+5 Inexact Rounded
precision: 3
mulx276 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 1.45E+5 Inexact Rounded
precision: 2
mulx277 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 1.5E+5 Inexact Rounded
precision: 1
mulx278 multiply 30269.587755640502150977251770554 4.8046009735990873395936309640543 -> 1E+5 Inexact Rounded
-- tryzeros cases
precision: 7
rounding: half_up
maxExponent: 92
minexponent: -92
mulx504 multiply 0E-60 1000E-60 -> 0E-98 Clamped
mulx505 multiply 100E+60 0E+60 -> 0E+92 Clamped
-- mixed with zeros
maxexponent: 999999999
minexponent: -999999999
precision: 9
mulx541 multiply 0 -1 -> -0
mulx542 multiply -0 -1 -> 0
mulx543 multiply 0 1 -> 0
mulx544 multiply -0 1 -> -0
mulx545 multiply -1 0 -> -0
mulx546 multiply -1 -0 -> 0
mulx547 multiply 1 0 -> 0
mulx548 multiply 1 -0 -> -0
mulx551 multiply 0.0 -1 -> -0.0
mulx552 multiply -0.0 -1 -> 0.0
mulx553 multiply 0.0 1 -> 0.0
mulx554 multiply -0.0 1 -> -0.0
mulx555 multiply -1.0 0 -> -0.0
mulx556 multiply -1.0 -0 -> 0.0
mulx557 multiply 1.0 0 -> 0.0
mulx558 multiply 1.0 -0 -> -0.0
mulx561 multiply 0 -1.0 -> -0.0
mulx562 multiply -0 -1.0 -> 0.0
mulx563 multiply 0 1.0 -> 0.0
mulx564 multiply -0 1.0 -> -0.0
mulx565 multiply -1 0.0 -> -0.0
mulx566 multiply -1 -0.0 -> 0.0
mulx567 multiply 1 0.0 -> 0.0
mulx568 multiply 1 -0.0 -> -0.0
mulx571 multiply 0.0 -1.0 -> -0.00
mulx572 multiply -0.0 -1.0 -> 0.00
mulx573 multiply 0.0 1.0 -> 0.00
mulx574 multiply -0.0 1.0 -> -0.00
mulx575 multiply -1.0 0.0 -> -0.00
mulx576 multiply -1.0 -0.0 -> 0.00
mulx577 multiply 1.0 0.0 -> 0.00
mulx578 multiply 1.0 -0.0 -> -0.00
-- Specials
mulx580 multiply Inf -Inf -> -Infinity
mulx581 multiply Inf -1000 -> -Infinity
mulx582 multiply Inf -1 -> -Infinity
mulx583 multiply Inf -0 -> NaN Invalid_operation
mulx584 multiply Inf 0 -> NaN Invalid_operation
mulx585 multiply Inf 1 -> Infinity
mulx586 multiply Inf 1000 -> Infinity
mulx587 multiply Inf Inf -> Infinity
mulx588 multiply -1000 Inf -> -Infinity
mulx589 multiply -Inf Inf -> -Infinity
mulx590 multiply -1 Inf -> -Infinity
mulx591 multiply -0 Inf -> NaN Invalid_operation
mulx592 multiply 0 Inf -> NaN Invalid_operation
mulx593 multiply 1 Inf -> Infinity
mulx594 multiply 1000 Inf -> Infinity
mulx595 multiply Inf Inf -> Infinity
mulx600 multiply -Inf -Inf -> Infinity
mulx601 multiply -Inf -1000 -> Infinity
mulx602 multiply -Inf -1 -> Infinity
mulx603 multiply -Inf -0 -> NaN Invalid_operation
mulx604 multiply -Inf 0 -> NaN Invalid_operation
mulx605 multiply -Inf 1 -> -Infinity
mulx606 multiply -Inf 1000 -> -Infinity
mulx607 multiply -Inf Inf -> -Infinity
mulx608 multiply -1000 Inf -> -Infinity
mulx609 multiply -Inf -Inf -> Infinity
mulx610 multiply -1 -Inf -> Infinity
mulx611 multiply -0 -Inf -> NaN Invalid_operation
mulx612 multiply 0 -Inf -> NaN Invalid_operation
mulx613 multiply 1 -Inf -> -Infinity
mulx614 multiply 1000 -Inf -> -Infinity
mulx615 multiply Inf -Inf -> -Infinity
mulx621 multiply NaN -Inf -> NaN
mulx622 multiply NaN -1000 -> NaN
mulx623 multiply NaN -1 -> NaN
mulx624 multiply NaN -0 -> NaN
mulx625 multiply NaN 0 -> NaN
mulx626 multiply NaN 1 -> NaN
mulx627 multiply NaN 1000 -> NaN
mulx628 multiply NaN Inf -> NaN
mulx629 multiply NaN NaN -> NaN
mulx630 multiply -Inf NaN -> NaN
mulx631 multiply -1000 NaN -> NaN
mulx632 multiply -1 NaN -> NaN
mulx633 multiply -0 NaN -> NaN
mulx634 multiply 0 NaN -> NaN
mulx635 multiply 1 NaN -> NaN
mulx636 multiply 1000 NaN -> NaN
mulx637 multiply Inf NaN -> NaN
mulx641 multiply sNaN -Inf -> NaN Invalid_operation
mulx642 multiply sNaN -1000 -> NaN Invalid_operation
mulx643 multiply sNaN -1 -> NaN Invalid_operation
mulx644 multiply sNaN -0 -> NaN Invalid_operation
mulx645 multiply sNaN 0 -> NaN Invalid_operation
mulx646 multiply sNaN 1 -> NaN Invalid_operation
mulx647 multiply sNaN 1000 -> NaN Invalid_operation
mulx648 multiply sNaN NaN -> NaN Invalid_operation
mulx649 multiply sNaN sNaN -> NaN Invalid_operation
mulx650 multiply NaN sNaN -> NaN Invalid_operation
mulx651 multiply -Inf sNaN -> NaN Invalid_operation
mulx652 multiply -1000 sNaN -> NaN Invalid_operation
mulx653 multiply -1 sNaN -> NaN Invalid_operation
mulx654 multiply -0 sNaN -> NaN Invalid_operation
mulx655 multiply 0 sNaN -> NaN Invalid_operation
mulx656 multiply 1 sNaN -> NaN Invalid_operation
mulx657 multiply 1000 sNaN -> NaN Invalid_operation
mulx658 multiply Inf sNaN -> NaN Invalid_operation
mulx659 multiply NaN sNaN -> NaN Invalid_operation
-- propagating NaNs
mulx661 multiply NaN9 -Inf -> NaN9
mulx662 multiply NaN8 999 -> NaN8
mulx663 multiply NaN71 Inf -> NaN71
mulx664 multiply NaN6 NaN5 -> NaN6
mulx665 multiply -Inf NaN4 -> NaN4
mulx666 multiply -999 NaN33 -> NaN33
mulx667 multiply Inf NaN2 -> NaN2
mulx671 multiply sNaN99 -Inf -> NaN99 Invalid_operation
mulx672 multiply sNaN98 -11 -> NaN98 Invalid_operation
mulx673 multiply sNaN97 NaN -> NaN97 Invalid_operation
mulx674 multiply sNaN16 sNaN94 -> NaN16 Invalid_operation
mulx675 multiply NaN95 sNaN93 -> NaN93 Invalid_operation
mulx676 multiply -Inf sNaN92 -> NaN92 Invalid_operation
mulx677 multiply 088 sNaN91 -> NaN91 Invalid_operation
mulx678 multiply Inf sNaN90 -> NaN90 Invalid_operation
mulx679 multiply NaN sNaN89 -> NaN89 Invalid_operation
mulx681 multiply -NaN9 -Inf -> -NaN9
mulx682 multiply -NaN8 999 -> -NaN8
mulx683 multiply -NaN71 Inf -> -NaN71
mulx684 multiply -NaN6 -NaN5 -> -NaN6
mulx685 multiply -Inf -NaN4 -> -NaN4
mulx686 multiply -999 -NaN33 -> -NaN33
mulx687 multiply Inf -NaN2 -> -NaN2
mulx691 multiply -sNaN99 -Inf -> -NaN99 Invalid_operation
mulx692 multiply -sNaN98 -11 -> -NaN98 Invalid_operation
mulx693 multiply -sNaN97 NaN -> -NaN97 Invalid_operation
mulx694 multiply -sNaN16 -sNaN94 -> -NaN16 Invalid_operation
mulx695 multiply -NaN95 -sNaN93 -> -NaN93 Invalid_operation
mulx696 multiply -Inf -sNaN92 -> -NaN92 Invalid_operation
mulx697 multiply 088 -sNaN91 -> -NaN91 Invalid_operation
mulx698 multiply Inf -sNaN90 -> -NaN90 Invalid_operation
mulx699 multiply -NaN -sNaN89 -> -NaN89 Invalid_operation
mulx701 multiply -NaN -Inf -> -NaN
mulx702 multiply -NaN 999 -> -NaN
mulx703 multiply -NaN Inf -> -NaN
mulx704 multiply -NaN -NaN -> -NaN
mulx705 multiply -Inf -NaN0 -> -NaN
mulx706 multiply -999 -NaN -> -NaN
mulx707 multiply Inf -NaN -> -NaN
mulx711 multiply -sNaN -Inf -> -NaN Invalid_operation
mulx712 multiply -sNaN -11 -> -NaN Invalid_operation
mulx713 multiply -sNaN00 NaN -> -NaN Invalid_operation
mulx714 multiply -sNaN -sNaN -> -NaN Invalid_operation
mulx715 multiply -NaN -sNaN -> -NaN Invalid_operation
mulx716 multiply -Inf -sNaN -> -NaN Invalid_operation
mulx717 multiply 088 -sNaN -> -NaN Invalid_operation
mulx718 multiply Inf -sNaN -> -NaN Invalid_operation
mulx719 multiply -NaN -sNaN -> -NaN Invalid_operation
-- overflow and underflow tests .. note subnormal results
maxexponent: 999999999
minexponent: -999999999
mulx730 multiply +1.23456789012345E-0 9E+999999999 -> Infinity Inexact Overflow Rounded
mulx731 multiply 9E+999999999 +1.23456789012345E-0 -> Infinity Inexact Overflow Rounded
mulx732 multiply +0.100 9E-999999999 -> 9.00E-1000000000 Subnormal
mulx733 multiply 9E-999999999 +0.100 -> 9.00E-1000000000 Subnormal
mulx735 multiply -1.23456789012345E-0 9E+999999999 -> -Infinity Inexact Overflow Rounded
mulx736 multiply 9E+999999999 -1.23456789012345E-0 -> -Infinity Inexact Overflow Rounded
mulx737 multiply -0.100 9E-999999999 -> -9.00E-1000000000 Subnormal
mulx738 multiply 9E-999999999 -0.100 -> -9.00E-1000000000 Subnormal
mulx739 multiply 1e-599999999 1e-400000001 -> 1E-1000000000 Subnormal
mulx740 multiply 1e-599999999 1e-400000000 -> 1E-999999999
mulx741 multiply 1e-600000000 1e-400000000 -> 1E-1000000000 Subnormal
mulx742 multiply 9e-999999998 0.01 -> 9E-1000000000 Subnormal
mulx743 multiply 9e-999999998 0.1 -> 9E-999999999
mulx744 multiply 0.01 9e-999999998 -> 9E-1000000000 Subnormal
mulx745 multiply 1e599999999 1e400000001 -> Infinity Overflow Inexact Rounded
mulx746 multiply 1e599999999 1e400000000 -> 1E+999999999
mulx747 multiply 1e600000000 1e400000000 -> Infinity Overflow Inexact Rounded
mulx748 multiply 9e999999998 100 -> Infinity Overflow Inexact Rounded
mulx749 multiply 9e999999998 10 -> 9.0E+999999999
mulx750 multiply 100 9e999999998 -> Infinity Overflow Inexact Rounded
-- signs
mulx751 multiply 1e+777777777 1e+411111111 -> Infinity Overflow Inexact Rounded
mulx752 multiply 1e+777777777 -1e+411111111 -> -Infinity Overflow Inexact Rounded
mulx753 multiply -1e+777777777 1e+411111111 -> -Infinity Overflow Inexact Rounded
mulx754 multiply -1e+777777777 -1e+411111111 -> Infinity Overflow Inexact Rounded
mulx755 multiply 1e-777777777 1e-411111111 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
mulx756 multiply 1e-777777777 -1e-411111111 -> -0E-1000000007 Underflow Subnormal Inexact Rounded
mulx757 multiply -1e-777777777 1e-411111111 -> -0E-1000000007 Underflow Subnormal Inexact Rounded
mulx758 multiply -1e-777777777 -1e-411111111 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
-- 'subnormal' boundary (all hard underflow or overflow in base arithemtic)
precision: 9
mulx760 multiply 1e-600000000 1e-400000001 -> 1E-1000000001 Subnormal
mulx761 multiply 1e-600000000 1e-400000002 -> 1E-1000000002 Subnormal
mulx762 multiply 1e-600000000 1e-400000003 -> 1E-1000000003 Subnormal
mulx763 multiply 1e-600000000 1e-400000004 -> 1E-1000000004 Subnormal
mulx764 multiply 1e-600000000 1e-400000005 -> 1E-1000000005 Subnormal
mulx765 multiply 1e-600000000 1e-400000006 -> 1E-1000000006 Subnormal
mulx766 multiply 1e-600000000 1e-400000007 -> 1E-1000000007 Subnormal
mulx767 multiply 1e-600000000 1e-400000008 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
mulx768 multiply 1e-600000000 1e-400000009 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
mulx769 multiply 1e-600000000 1e-400000010 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
-- [no equivalent of 'subnormal' for overflow]
mulx770 multiply 1e+600000000 1e+400000001 -> Infinity Overflow Inexact Rounded
mulx771 multiply 1e+600000000 1e+400000002 -> Infinity Overflow Inexact Rounded
mulx772 multiply 1e+600000000 1e+400000003 -> Infinity Overflow Inexact Rounded
mulx773 multiply 1e+600000000 1e+400000004 -> Infinity Overflow Inexact Rounded
mulx774 multiply 1e+600000000 1e+400000005 -> Infinity Overflow Inexact Rounded
mulx775 multiply 1e+600000000 1e+400000006 -> Infinity Overflow Inexact Rounded
mulx776 multiply 1e+600000000 1e+400000007 -> Infinity Overflow Inexact Rounded
mulx777 multiply 1e+600000000 1e+400000008 -> Infinity Overflow Inexact Rounded
mulx778 multiply 1e+600000000 1e+400000009 -> Infinity Overflow Inexact Rounded
mulx779 multiply 1e+600000000 1e+400000010 -> Infinity Overflow Inexact Rounded
-- 'subnormal' test edge condition at higher precisions
precision: 99
mulx780 multiply 1e-600000000 1e-400000007 -> 1E-1000000007 Subnormal
mulx781 multiply 1e-600000000 1e-400000008 -> 1E-1000000008 Subnormal
mulx782 multiply 1e-600000000 1e-400000097 -> 1E-1000000097 Subnormal
mulx783 multiply 1e-600000000 1e-400000098 -> 0E-1000000097 Underflow Subnormal Inexact Rounded
precision: 999
mulx784 multiply 1e-600000000 1e-400000997 -> 1E-1000000997 Subnormal
mulx785 multiply 1e-600000000 1e-400000998 -> 0E-1000000997 Underflow Subnormal Inexact Rounded
-- following testcases [through mulx800] not yet run against code
precision: 9999
mulx786 multiply 1e-600000000 1e-400009997 -> 1E-1000009997 Subnormal
mulx787 multiply 1e-600000000 1e-400009998 -> 0E-1000009997 Underflow Subnormal Inexact Rounded
precision: 99999
mulx788 multiply 1e-600000000 1e-400099997 -> 1E-1000099997 Subnormal
mulx789 multiply 1e-600000000 1e-400099998 -> 0E-1000099997 Underflow Subnormal Inexact Rounded
precision: 999999
mulx790 multiply 1e-600000000 1e-400999997 -> 1E-1000999997 Subnormal
mulx791 multiply 1e-600000000 1e-400999998 -> 0E-1000999997 Underflow Subnormal Inexact Rounded
precision: 9999999
mulx792 multiply 1e-600000000 1e-409999997 -> 1E-1009999997 Subnormal
mulx793 multiply 1e-600000000 1e-409999998 -> 0E-1009999997 Underflow Subnormal Inexact Rounded
precision: 99999999
mulx794 multiply 1e-600000000 1e-499999997 -> 1E-1099999997 Subnormal
mulx795 multiply 1e-600000000 1e-499999998 -> 0E-1099999997 Underflow Subnormal Inexact Rounded
precision: 999999999
mulx796 multiply 1e-999999999 1e-999999997 -> 1E-1999999996 Subnormal
mulx797 multiply 1e-999999999 1e-999999998 -> 1E-1999999997 Subnormal
mulx798 multiply 1e-999999999 1e-999999999 -> 0E-1999999997 Underflow Subnormal Inexact Rounded
mulx799 multiply 1e-600000000 1e-400000007 -> 1E-1000000007 Subnormal
mulx800 multiply 1e-600000000 1e-400000008 -> 1E-1000000008 Subnormal
-- test subnormals rounding
precision: 5
maxExponent: 999
minexponent: -999
rounding: half_even
mulx801 multiply 1.0000E-999 1 -> 1.0000E-999
mulx802 multiply 1.000E-999 1e-1 -> 1.000E-1000 Subnormal
mulx803 multiply 1.00E-999 1e-2 -> 1.00E-1001 Subnormal
mulx804 multiply 1.0E-999 1e-3 -> 1.0E-1002 Subnormal
mulx805 multiply 1.0E-999 1e-4 -> 1E-1003 Subnormal Rounded
mulx806 multiply 1.3E-999 1e-4 -> 1E-1003 Underflow Subnormal Inexact Rounded
mulx807 multiply 1.5E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded
mulx808 multiply 1.7E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded
mulx809 multiply 2.3E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded
mulx810 multiply 2.5E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded
mulx811 multiply 2.7E-999 1e-4 -> 3E-1003 Underflow Subnormal Inexact Rounded
mulx812 multiply 1.49E-999 1e-4 -> 1E-1003 Underflow Subnormal Inexact Rounded
mulx813 multiply 1.50E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded
mulx814 multiply 1.51E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded
mulx815 multiply 2.49E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded
mulx816 multiply 2.50E-999 1e-4 -> 2E-1003 Underflow Subnormal Inexact Rounded
mulx817 multiply 2.51E-999 1e-4 -> 3E-1003 Underflow Subnormal Inexact Rounded
mulx818 multiply 1E-999 1e-4 -> 1E-1003 Subnormal
mulx819 multiply 3E-999 1e-5 -> 0E-1003 Underflow Subnormal Inexact Rounded
mulx820 multiply 5E-999 1e-5 -> 0E-1003 Underflow Subnormal Inexact Rounded
mulx821 multiply 7E-999 1e-5 -> 1E-1003 Underflow Subnormal Inexact Rounded
mulx822 multiply 9E-999 1e-5 -> 1E-1003 Underflow Subnormal Inexact Rounded
mulx823 multiply 9.9E-999 1e-5 -> 1E-1003 Underflow Subnormal Inexact Rounded
mulx824 multiply 1E-999 -1e-4 -> -1E-1003 Subnormal
mulx825 multiply 3E-999 -1e-5 -> -0E-1003 Underflow Subnormal Inexact Rounded
mulx826 multiply -5E-999 1e-5 -> -0E-1003 Underflow Subnormal Inexact Rounded
mulx827 multiply 7E-999 -1e-5 -> -1E-1003 Underflow Subnormal Inexact Rounded
mulx828 multiply -9E-999 1e-5 -> -1E-1003 Underflow Subnormal Inexact Rounded
mulx829 multiply 9.9E-999 -1e-5 -> -1E-1003 Underflow Subnormal Inexact Rounded
mulx830 multiply 3.0E-999 -1e-5 -> -0E-1003 Underflow Subnormal Inexact Rounded
mulx831 multiply 1.0E-501 1e-501 -> 1.0E-1002 Subnormal
mulx832 multiply 2.0E-501 2e-501 -> 4.0E-1002 Subnormal
mulx833 multiply 4.0E-501 4e-501 -> 1.60E-1001 Subnormal
mulx834 multiply 10.0E-501 10e-501 -> 1.000E-1000 Subnormal
mulx835 multiply 30.0E-501 30e-501 -> 9.000E-1000 Subnormal
mulx836 multiply 40.0E-501 40e-501 -> 1.6000E-999
-- squares
mulx840 multiply 1E-502 1e-502 -> 0E-1003 Underflow Subnormal Inexact Rounded
mulx841 multiply 1E-501 1e-501 -> 1E-1002 Subnormal
mulx842 multiply 2E-501 2e-501 -> 4E-1002 Subnormal
mulx843 multiply 4E-501 4e-501 -> 1.6E-1001 Subnormal
mulx844 multiply 10E-501 10e-501 -> 1.00E-1000 Subnormal
mulx845 multiply 30E-501 30e-501 -> 9.00E-1000 Subnormal
mulx846 multiply 40E-501 40e-501 -> 1.600E-999
-- cubes
mulx850 multiply 1E-670 1e-335 -> 0E-1003 Underflow Subnormal Inexact Rounded
mulx851 multiply 1E-668 1e-334 -> 1E-1002 Subnormal
mulx852 multiply 4E-668 2e-334 -> 8E-1002 Subnormal
mulx853 multiply 9E-668 3e-334 -> 2.7E-1001 Subnormal
mulx854 multiply 16E-668 4e-334 -> 6.4E-1001 Subnormal
mulx855 multiply 25E-668 5e-334 -> 1.25E-1000 Subnormal
mulx856 multiply 10E-668 100e-334 -> 1.000E-999
-- test from 0.099 ** 999 at 15 digits
precision: 19
mulx860 multiply 6636851557994578716E-520 6636851557994578716E-520 -> 4.40477986028551E-1003 Underflow Subnormal Inexact Rounded
-- Long operand overflow may be a different path
precision: 3
maxExponent: 999999999
minexponent: -999999999
mulx870 multiply 1 9.999E+999999999 -> Infinity Inexact Overflow Rounded
mulx871 multiply 1 -9.999E+999999999 -> -Infinity Inexact Overflow Rounded
mulx872 multiply 9.999E+999999999 1 -> Infinity Inexact Overflow Rounded
mulx873 multiply -9.999E+999999999 1 -> -Infinity Inexact Overflow Rounded
-- check for double-rounded subnormals
precision: 5
maxexponent: 79
minexponent: -79
mulx881 multiply 1.2347E-40 1.2347E-40 -> 1.524E-80 Inexact Rounded Subnormal Underflow
mulx882 multiply 1.234E-40 1.234E-40 -> 1.523E-80 Inexact Rounded Subnormal Underflow
mulx883 multiply 1.23E-40 1.23E-40 -> 1.513E-80 Inexact Rounded Subnormal Underflow
mulx884 multiply 1.2E-40 1.2E-40 -> 1.44E-80 Subnormal
mulx885 multiply 1.2E-40 1.2E-41 -> 1.44E-81 Subnormal
mulx886 multiply 1.2E-40 1.2E-42 -> 1.4E-82 Subnormal Inexact Rounded Underflow
mulx887 multiply 1.2E-40 1.3E-42 -> 1.6E-82 Subnormal Inexact Rounded Underflow
mulx888 multiply 1.3E-40 1.3E-42 -> 1.7E-82 Subnormal Inexact Rounded Underflow
mulx891 multiply 1.2345E-39 1.234E-40 -> 1.5234E-79 Inexact Rounded
mulx892 multiply 1.23456E-39 1.234E-40 -> 1.5234E-79 Inexact Rounded
mulx893 multiply 1.2345E-40 1.234E-40 -> 1.523E-80 Inexact Rounded Subnormal Underflow
mulx894 multiply 1.23456E-40 1.234E-40 -> 1.523E-80 Inexact Rounded Subnormal Underflow
mulx895 multiply 1.2345E-41 1.234E-40 -> 1.52E-81 Inexact Rounded Subnormal Underflow
mulx896 multiply 1.23456E-41 1.234E-40 -> 1.52E-81 Inexact Rounded Subnormal Underflow
-- Null tests
mulx900 multiply 10 # -> NaN Invalid_operation
mulx901 multiply # 10 -> NaN Invalid_operation

225
sys/lib/python/test/decimaltestdata/normalize.decTest
View file

@ -1,225 +0,0 @@
------------------------------------------------------------------------
-- normalize.decTest -- remove trailing zeros --
-- Copyright (c) IBM Corporation, 2003. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
extended: 1
precision: 9
rounding: half_up
maxExponent: 999
minexponent: -999
nrmx001 normalize '1' -> '1'
nrmx002 normalize '-1' -> '-1'
nrmx003 normalize '1.00' -> '1'
nrmx004 normalize '-1.00' -> '-1'
nrmx005 normalize '0' -> '0'
nrmx006 normalize '0.00' -> '0'
nrmx007 normalize '00.0' -> '0'
nrmx008 normalize '00.00' -> '0'
nrmx009 normalize '00' -> '0'
nrmx010 normalize '0E+1' -> '0'
nrmx011 normalize '0E+5' -> '0'
nrmx012 normalize '-2' -> '-2'
nrmx013 normalize '2' -> '2'
nrmx014 normalize '-2.00' -> '-2'
nrmx015 normalize '2.00' -> '2'
nrmx016 normalize '-0' -> '-0'
nrmx017 normalize '-0.00' -> '-0'
nrmx018 normalize '-00.0' -> '-0'
nrmx019 normalize '-00.00' -> '-0'
nrmx020 normalize '-00' -> '-0'
nrmx021 normalize '-0E+5' -> '-0'
nrmx022 normalize '-0E+1' -> '-0'
nrmx030 normalize '+0.1' -> '0.1'
nrmx031 normalize '-0.1' -> '-0.1'
nrmx032 normalize '+0.01' -> '0.01'
nrmx033 normalize '-0.01' -> '-0.01'
nrmx034 normalize '+0.001' -> '0.001'
nrmx035 normalize '-0.001' -> '-0.001'
nrmx036 normalize '+0.000001' -> '0.000001'
nrmx037 normalize '-0.000001' -> '-0.000001'
nrmx038 normalize '+0.000000000001' -> '1E-12'
nrmx039 normalize '-0.000000000001' -> '-1E-12'
nrmx041 normalize 1.1 -> 1.1
nrmx042 normalize 1.10 -> 1.1
nrmx043 normalize 1.100 -> 1.1
nrmx044 normalize 1.110 -> 1.11
nrmx045 normalize -1.1 -> -1.1
nrmx046 normalize -1.10 -> -1.1
nrmx047 normalize -1.100 -> -1.1
nrmx048 normalize -1.110 -> -1.11
nrmx049 normalize 9.9 -> 9.9
nrmx050 normalize 9.90 -> 9.9
nrmx051 normalize 9.900 -> 9.9
nrmx052 normalize 9.990 -> 9.99
nrmx053 normalize -9.9 -> -9.9
nrmx054 normalize -9.90 -> -9.9
nrmx055 normalize -9.900 -> -9.9
nrmx056 normalize -9.990 -> -9.99
-- some trailing fractional zeros with zeros in units
nrmx060 normalize 10.0 -> 1E+1
nrmx061 normalize 10.00 -> 1E+1
nrmx062 normalize 100.0 -> 1E+2
nrmx063 normalize 100.00 -> 1E+2
nrmx064 normalize 1.1000E+3 -> 1.1E+3
nrmx065 normalize 1.10000E+3 -> 1.1E+3
nrmx066 normalize -10.0 -> -1E+1
nrmx067 normalize -10.00 -> -1E+1
nrmx068 normalize -100.0 -> -1E+2
nrmx069 normalize -100.00 -> -1E+2
nrmx070 normalize -1.1000E+3 -> -1.1E+3
nrmx071 normalize -1.10000E+3 -> -1.1E+3
-- some insignificant trailing zeros with positive exponent
nrmx080 normalize 10E+1 -> 1E+2
nrmx081 normalize 100E+1 -> 1E+3
nrmx082 normalize 1.0E+2 -> 1E+2
nrmx083 normalize 1.0E+3 -> 1E+3
nrmx084 normalize 1.1E+3 -> 1.1E+3
nrmx085 normalize 1.00E+3 -> 1E+3
nrmx086 normalize 1.10E+3 -> 1.1E+3
nrmx087 normalize -10E+1 -> -1E+2
nrmx088 normalize -100E+1 -> -1E+3
nrmx089 normalize -1.0E+2 -> -1E+2
nrmx090 normalize -1.0E+3 -> -1E+3
nrmx091 normalize -1.1E+3 -> -1.1E+3
nrmx092 normalize -1.00E+3 -> -1E+3
nrmx093 normalize -1.10E+3 -> -1.1E+3
-- some significant trailing zeros, were we to be trimming
nrmx100 normalize 11 -> 11
nrmx101 normalize 10 -> 1E+1
nrmx102 normalize 10. -> 1E+1
nrmx103 normalize 1.1E+1 -> 11
nrmx104 normalize 1.0E+1 -> 1E+1
nrmx105 normalize 1.10E+2 -> 1.1E+2
nrmx106 normalize 1.00E+2 -> 1E+2
nrmx107 normalize 1.100E+3 -> 1.1E+3
nrmx108 normalize 1.000E+3 -> 1E+3
nrmx109 normalize 1.000000E+6 -> 1E+6
nrmx110 normalize -11 -> -11
nrmx111 normalize -10 -> -1E+1
nrmx112 normalize -10. -> -1E+1
nrmx113 normalize -1.1E+1 -> -11
nrmx114 normalize -1.0E+1 -> -1E+1
nrmx115 normalize -1.10E+2 -> -1.1E+2
nrmx116 normalize -1.00E+2 -> -1E+2
nrmx117 normalize -1.100E+3 -> -1.1E+3
nrmx118 normalize -1.000E+3 -> -1E+3
nrmx119 normalize -1.00000E+5 -> -1E+5
nrmx120 normalize -1.000000E+6 -> -1E+6
nrmx121 normalize -10.00000E+6 -> -1E+7
nrmx122 normalize -100.0000E+6 -> -1E+8
nrmx123 normalize -1000.000E+6 -> -1E+9
nrmx124 normalize -10000.00E+6 -> -1E+10
nrmx125 normalize -100000.0E+6 -> -1E+11
nrmx126 normalize -1000000.E+6 -> -1E+12
-- examples from decArith
nrmx140 normalize '2.1' -> '2.1'
nrmx141 normalize '-2.0' -> '-2'
nrmx142 normalize '1.200' -> '1.2'
nrmx143 normalize '-120' -> '-1.2E+2'
nrmx144 normalize '120.00' -> '1.2E+2'
nrmx145 normalize '0.00' -> '0'
-- overflow tests
maxexponent: 999999999
minexponent: -999999999
precision: 3
nrmx160 normalize 9.999E+999999999 -> Infinity Inexact Overflow Rounded
nrmx161 normalize -9.999E+999999999 -> -Infinity Inexact Overflow Rounded
-- subnormals and underflow
precision: 3
maxexponent: 999
minexponent: -999
nrmx210 normalize 1.00E-999 -> 1E-999
nrmx211 normalize 0.1E-999 -> 1E-1000 Subnormal
nrmx212 normalize 0.10E-999 -> 1E-1000 Subnormal
nrmx213 normalize 0.100E-999 -> 1E-1000 Subnormal Rounded
nrmx214 normalize 0.01E-999 -> 1E-1001 Subnormal
-- next is rounded to Emin
nrmx215 normalize 0.999E-999 -> 1E-999 Inexact Rounded Subnormal Underflow
nrmx216 normalize 0.099E-999 -> 1E-1000 Inexact Rounded Subnormal Underflow
nrmx217 normalize 0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow
nrmx218 normalize 0.001E-999 -> 0 Inexact Rounded Subnormal Underflow
nrmx219 normalize 0.0009E-999 -> 0 Inexact Rounded Subnormal Underflow
nrmx220 normalize 0.0001E-999 -> 0 Inexact Rounded Subnormal Underflow
nrmx230 normalize -1.00E-999 -> -1E-999
nrmx231 normalize -0.1E-999 -> -1E-1000 Subnormal
nrmx232 normalize -0.10E-999 -> -1E-1000 Subnormal
nrmx233 normalize -0.100E-999 -> -1E-1000 Subnormal Rounded
nrmx234 normalize -0.01E-999 -> -1E-1001 Subnormal
-- next is rounded to Emin
nrmx235 normalize -0.999E-999 -> -1E-999 Inexact Rounded Subnormal Underflow
nrmx236 normalize -0.099E-999 -> -1E-1000 Inexact Rounded Subnormal Underflow
nrmx237 normalize -0.009E-999 -> -1E-1001 Inexact Rounded Subnormal Underflow
nrmx238 normalize -0.001E-999 -> -0 Inexact Rounded Subnormal Underflow
nrmx239 normalize -0.0009E-999 -> -0 Inexact Rounded Subnormal Underflow
nrmx240 normalize -0.0001E-999 -> -0 Inexact Rounded Subnormal Underflow
-- more reshaping
precision: 9
nrmx260 normalize '56260E-10' -> '0.000005626'
nrmx261 normalize '56260E-5' -> '0.5626'
nrmx262 normalize '56260E-2' -> '562.6'
nrmx263 normalize '56260E-1' -> '5626'
nrmx265 normalize '56260E-0' -> '5.626E+4'
nrmx266 normalize '56260E+0' -> '5.626E+4'
nrmx267 normalize '56260E+1' -> '5.626E+5'
nrmx268 normalize '56260E+2' -> '5.626E+6'
nrmx269 normalize '56260E+3' -> '5.626E+7'
nrmx270 normalize '56260E+4' -> '5.626E+8'
nrmx271 normalize '56260E+5' -> '5.626E+9'
nrmx272 normalize '56260E+6' -> '5.626E+10'
nrmx280 normalize '-56260E-10' -> '-0.000005626'
nrmx281 normalize '-56260E-5' -> '-0.5626'
nrmx282 normalize '-56260E-2' -> '-562.6'
nrmx283 normalize '-56260E-1' -> '-5626'
nrmx285 normalize '-56260E-0' -> '-5.626E+4'
nrmx286 normalize '-56260E+0' -> '-5.626E+4'
nrmx287 normalize '-56260E+1' -> '-5.626E+5'
nrmx288 normalize '-56260E+2' -> '-5.626E+6'
nrmx289 normalize '-56260E+3' -> '-5.626E+7'
nrmx290 normalize '-56260E+4' -> '-5.626E+8'
nrmx291 normalize '-56260E+5' -> '-5.626E+9'
nrmx292 normalize '-56260E+6' -> '-5.626E+10'
-- specials
nrmx820 normalize 'Inf' -> 'Infinity'
nrmx821 normalize '-Inf' -> '-Infinity'
nrmx822 normalize NaN -> NaN
nrmx823 normalize sNaN -> NaN Invalid_operation
nrmx824 normalize NaN101 -> NaN101
nrmx825 normalize sNaN010 -> NaN10 Invalid_operation
nrmx827 normalize -NaN -> -NaN
nrmx828 normalize -sNaN -> -NaN Invalid_operation
nrmx829 normalize -NaN101 -> -NaN101
nrmx830 normalize -sNaN010 -> -NaN10 Invalid_operation
-- Null test
nrmx900 normalize # -> NaN Invalid_operation

181
sys/lib/python/test/decimaltestdata/plus.decTest
View file

@ -1,181 +0,0 @@
------------------------------------------------------------------------
-- plus.decTest -- decimal monadic addition --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- This set of tests primarily tests the existence of the operator.
-- Addition and rounding, and most overflows, are tested elsewhere.
extended: 1
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
plux001 plus '1' -> '1'
plux002 plus '-1' -> '-1'
plux003 plus '1.00' -> '1.00'
plux004 plus '-1.00' -> '-1.00'
plux005 plus '0' -> '0'
plux006 plus '0.00' -> '0.00'
plux007 plus '00.0' -> '0.0'
plux008 plus '00.00' -> '0.00'
plux009 plus '00' -> '0'
plux010 plus '-2' -> '-2'
plux011 plus '2' -> '2'
plux012 plus '-2.00' -> '-2.00'
plux013 plus '2.00' -> '2.00'
plux014 plus '-0' -> '0'
plux015 plus '-0.00' -> '0.00'
plux016 plus '-00.0' -> '0.0'
plux017 plus '-00.00' -> '0.00'
plux018 plus '-00' -> '0'
plux020 plus '-2000000' -> '-2000000'
plux021 plus '2000000' -> '2000000'
precision: 7
plux022 plus '-2000000' -> '-2000000'
plux023 plus '2000000' -> '2000000'
precision: 6
plux024 plus '-2000000' -> '-2.00000E+6' Rounded
plux025 plus '2000000' -> '2.00000E+6' Rounded
precision: 3
plux026 plus '-2000000' -> '-2.00E+6' Rounded
plux027 plus '2000000' -> '2.00E+6' Rounded
-- more fixed, potential LHS swaps if done by add 0
precision: 9
plux060 plus '56267E-10' -> '0.0000056267'
plux061 plus '56267E-5' -> '0.56267'
plux062 plus '56267E-2' -> '562.67'
plux063 plus '56267E-1' -> '5626.7'
plux065 plus '56267E-0' -> '56267'
plux066 plus '56267E+0' -> '56267'
plux067 plus '56267E+1' -> '5.6267E+5'
plux068 plus '56267E+2' -> '5.6267E+6'
plux069 plus '56267E+3' -> '5.6267E+7'
plux070 plus '56267E+4' -> '5.6267E+8'
plux071 plus '56267E+5' -> '5.6267E+9'
plux072 plus '56267E+6' -> '5.6267E+10'
plux080 plus '-56267E-10' -> '-0.0000056267'
plux081 plus '-56267E-5' -> '-0.56267'
plux082 plus '-56267E-2' -> '-562.67'
plux083 plus '-56267E-1' -> '-5626.7'
plux085 plus '-56267E-0' -> '-56267'
plux086 plus '-56267E+0' -> '-56267'
plux087 plus '-56267E+1' -> '-5.6267E+5'
plux088 plus '-56267E+2' -> '-5.6267E+6'
plux089 plus '-56267E+3' -> '-5.6267E+7'
plux090 plus '-56267E+4' -> '-5.6267E+8'
plux091 plus '-56267E+5' -> '-5.6267E+9'
plux092 plus '-56267E+6' -> '-5.6267E+10'
-- "lhs" zeros in plus and minus have exponent = operand
plux120 plus '-0E3' -> '0E+3'
plux121 plus '-0E2' -> '0E+2'
plux122 plus '-0E1' -> '0E+1'
plux123 plus '-0E0' -> '0'
plux124 plus '+0E0' -> '0'
plux125 plus '+0E1' -> '0E+1'
plux126 plus '+0E2' -> '0E+2'
plux127 plus '+0E3' -> '0E+3'
plux130 plus '-5E3' -> '-5E+3'
plux131 plus '-5E8' -> '-5E+8'
plux132 plus '-5E13' -> '-5E+13'
plux133 plus '-5E18' -> '-5E+18'
plux134 plus '+5E3' -> '5E+3'
plux135 plus '+5E8' -> '5E+8'
plux136 plus '+5E13' -> '5E+13'
plux137 plus '+5E18' -> '5E+18'
-- specials
plux150 plus 'Inf' -> 'Infinity'
plux151 plus '-Inf' -> '-Infinity'
plux152 plus NaN -> NaN
plux153 plus sNaN -> NaN Invalid_operation
plux154 plus NaN77 -> NaN77
plux155 plus sNaN88 -> NaN88 Invalid_operation
plux156 plus -NaN -> -NaN
plux157 plus -sNaN -> -NaN Invalid_operation
plux158 plus -NaN77 -> -NaN77
plux159 plus -sNaN88 -> -NaN88 Invalid_operation
-- overflow tests
maxexponent: 999999999
minexponent: -999999999
precision: 3
plux160 plus 9.999E+999999999 -> Infinity Inexact Overflow Rounded
plux161 plus -9.999E+999999999 -> -Infinity Inexact Overflow Rounded
-- subnormals and underflow
precision: 3
maxexponent: 999
minexponent: -999
plux210 plus 1.00E-999 -> 1.00E-999
plux211 plus 0.1E-999 -> 1E-1000 Subnormal
plux212 plus 0.10E-999 -> 1.0E-1000 Subnormal
plux213 plus 0.100E-999 -> 1.0E-1000 Subnormal Rounded
plux214 plus 0.01E-999 -> 1E-1001 Subnormal
-- next is rounded to Emin
plux215 plus 0.999E-999 -> 1.00E-999 Inexact Rounded Subnormal Underflow
plux216 plus 0.099E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow
plux217 plus 0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow
plux218 plus 0.001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
plux219 plus 0.0009E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
plux220 plus 0.0001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
plux230 plus -1.00E-999 -> -1.00E-999
plux231 plus -0.1E-999 -> -1E-1000 Subnormal
plux232 plus -0.10E-999 -> -1.0E-1000 Subnormal
plux233 plus -0.100E-999 -> -1.0E-1000 Subnormal Rounded
plux234 plus -0.01E-999 -> -1E-1001 Subnormal
-- next is rounded to Emin
plux235 plus -0.999E-999 -> -1.00E-999 Inexact Rounded Subnormal Underflow
plux236 plus -0.099E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow
plux237 plus -0.009E-999 -> -1E-1001 Inexact Rounded Subnormal Underflow
plux238 plus -0.001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow
plux239 plus -0.0009E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow
plux240 plus -0.0001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow
-- long operand checks
maxexponent: 999
minexponent: -999
precision: 9
plux301 plus 12345678000 -> 1.23456780E+10 Rounded
plux302 plus 1234567800 -> 1.23456780E+9 Rounded
plux303 plus 1234567890 -> 1.23456789E+9 Rounded
plux304 plus 1234567891 -> 1.23456789E+9 Inexact Rounded
plux305 plus 12345678901 -> 1.23456789E+10 Inexact Rounded
plux306 plus 1234567896 -> 1.23456790E+9 Inexact Rounded
-- still checking
precision: 15
plux321 plus 12345678000 -> 12345678000
plux322 plus 1234567800 -> 1234567800
plux323 plus 1234567890 -> 1234567890
plux324 plus 1234567891 -> 1234567891
plux325 plus 12345678901 -> 12345678901
plux326 plus 1234567896 -> 1234567896
precision: 9
-- Null tests
plu900 plus # -> NaN Invalid_operation

651
sys/lib/python/test/decimaltestdata/power.decTest
View file

@ -1,651 +0,0 @@
----------------------------------------------------------------------
-- power.decTest -- decimal exponentiation --
-- Copyright (c) IBM Corporation, 1981, 2003. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- This set of testcases tests raising numbers to an integer power only.
-- If arbitrary powers were supported, 1 ulp differences would be
-- permitted.
extended: 1
precision: 9
rounding: half_up
maxExponent: 999
minexponent: -999
-- base checks. Note 0**0 is an error.
powx001 power '0' '0' -> NaN Invalid_operation
powx002 power '0' '1' -> '0'
powx003 power '0' '2' -> '0'
powx004 power '1' '0' -> '1'
powx005 power '1' '1' -> '1'
powx006 power '1' '2' -> '1'
powx010 power '2' '0' -> '1'
powx011 power '2' '1' -> '2'
powx012 power '2' '2' -> '4'
powx013 power '2' '3' -> '8'
powx014 power '2' '4' -> '16'
powx015 power '2' '5' -> '32'
powx016 power '2' '6' -> '64'
powx017 power '2' '7' -> '128'
powx018 power '2' '8' -> '256'
powx019 power '2' '9' -> '512'
powx020 power '2' '10' -> '1024'
powx021 power '2' '11' -> '2048'
powx022 power '2' '12' -> '4096'
powx023 power '2' '15' -> '32768'
powx024 power '2' '16' -> '65536'
powx025 power '2' '31' -> '2.14748365E+9' Inexact Rounded
-- NB 0 not stripped in next
powx026 power '2' '32' -> '4.29496730E+9' Inexact Rounded
precision: 10
powx027 power '2' '31' -> '2147483648'
powx028 power '2' '32' -> '4294967296'
precision: 9
powx030 power '3' '2' -> 9
powx031 power '4' '2' -> 16
powx032 power '5' '2' -> 25
powx033 power '6' '2' -> 36
powx034 power '7' '2' -> 49
powx035 power '8' '2' -> 64
powx036 power '9' '2' -> 81
powx037 power '10' '2' -> 100
powx038 power '11' '2' -> 121
powx039 power '12' '2' -> 144
powx040 power '3' '3' -> 27
powx041 power '4' '3' -> 64
powx042 power '5' '3' -> 125
powx043 power '6' '3' -> 216
powx044 power '7' '3' -> 343
powx050 power '10' '0' -> 1
powx051 power '10' '1' -> 10
powx052 power '10' '2' -> 100
powx053 power '10' '3' -> 1000
powx054 power '10' '4' -> 10000
powx055 power '10' '5' -> 100000
powx056 power '10' '6' -> 1000000
powx057 power '10' '7' -> 10000000
powx058 power '10' '8' -> 100000000
powx059 power '10' '9' -> 1.00000000E+9 Rounded
powx060 power '10' '22' -> 1.00000000E+22 Rounded
powx061 power '10' '77' -> 1.00000000E+77 Rounded
powx062 power '10' '99' -> 1.00000000E+99 Rounded
maxexponent: 999999999
minexponent: -999999999
powx063 power '10' '999999999' -> '1.00000000E+999999999' Rounded
powx064 power '10' '999999998' -> '1.00000000E+999999998' Rounded
powx065 power '10' '999999997' -> '1.00000000E+999999997' Rounded
powx066 power '10' '333333333' -> '1.00000000E+333333333' Rounded
powx070 power '0.3' '0' -> '1'
powx071 power '0.3' '1' -> '0.3'
powx072 power '0.3' '1.00' -> '0.3'
powx073 power '0.3' '2.00' -> '0.09'
powx074 power '0.3' '2.000000000' -> '0.09'
powx075 power '6.0' '1' -> '6.0' -- NB zeros not stripped
powx076 power '6.0' '2' -> '36.00' -- ..
powx077 power '-3' '2' -> '9' -- from NetRexx book
powx078 power '4' '3' -> '64' -- .. (sort of)
powx080 power 0.1 0 -> 1
powx081 power 0.1 1 -> 0.1
powx082 power 0.1 2 -> 0.01
powx083 power 0.1 3 -> 0.001
powx084 power 0.1 4 -> 0.0001
powx085 power 0.1 5 -> 0.00001
powx086 power 0.1 6 -> 0.000001
powx087 power 0.1 7 -> 1E-7
powx088 power 0.1 8 -> 1E-8
powx089 power 0.1 9 -> 1E-9
powx090 power 101 2 -> 10201
powx091 power 101 3 -> 1030301
powx092 power 101 4 -> 104060401
powx093 power 101 5 -> 1.05101005E+10 Inexact Rounded
powx094 power 101 6 -> 1.06152015E+12 Inexact Rounded
powx095 power 101 7 -> 1.07213535E+14 Inexact Rounded
-- negative powers
powx101 power '2' '-1' -> 0.5
powx102 power '2' '-2' -> 0.25
powx103 power '2' '-4' -> 0.0625
powx104 power '2' '-8' -> 0.00390625
powx105 power '2' '-16' -> 0.0000152587891 Inexact Rounded
powx106 power '2' '-32' -> 2.32830644E-10 Inexact Rounded
powx108 power '2' '-64' -> 5.42101086E-20 Inexact Rounded
powx110 power '10' '-8' -> 1E-8
powx111 power '10' '-7' -> 1E-7
powx112 power '10' '-6' -> 0.000001
powx113 power '10' '-5' -> 0.00001
powx114 power '10' '-4' -> 0.0001
powx115 power '10' '-3' -> 0.001
powx116 power '10' '-2' -> 0.01
powx117 power '10' '-1' -> 0.1
powx118 power '10' '-333333333' -> 1E-333333333
powx119 power '10' '-999999998' -> 1E-999999998
powx120 power '10' '-999999999' -> 1E-999999999
powx121 power '10' '-77' -> '1E-77'
powx122 power '10' '-22' -> '1E-22'
powx123 power '2' '-1' -> '0.5'
powx124 power '2' '-2' -> '0.25'
powx125 power '2' '-4' -> '0.0625'
powx126 power '0' '-1' -> Infinity Division_by_zero
powx127 power '0' '-2' -> Infinity Division_by_zero
powx128 power -0 '-1' -> -Infinity Division_by_zero
powx129 power -0 '-2' -> Infinity Division_by_zero
-- out-of-range edge cases
powx181 power '7' '999999998' -> 2.10892313E+845098038 Inexact Rounded
powx182 power '7' '999999999' -> 1.47624619E+845098039 Inexact Rounded
powx183 power '7' '1000000000' -> NaN Invalid_operation
powx184 power '7' '1000000001' -> NaN Invalid_operation
powx185 power '7' '10000000000' -> NaN Invalid_operation
powx186 power '7' '-1000000001' -> NaN Invalid_operation
powx187 power '7' '-1000000000' -> NaN Invalid_operation
powx189 power '7' '-999999999' -> 6.77393787E-845098040 Inexact Rounded
powx190 power '7' '-999999998' -> 4.74175651E-845098039 Inexact Rounded
-- some baddies [more below]
powx191 power '2' '2.000001' -> NaN Invalid_operation
powx192 power '2' '2.00000000' -> 4
powx193 power '2' '2.000000001' -> NaN Invalid_operation
powx194 power '2' '2.0000000001' -> NaN Invalid_operation
-- "0.5" tests from original Rexx diagnostics [loop unrolled]
powx200 power 0.5 0 -> 1
powx201 power 0.5 1 -> 0.5
powx202 power 0.5 2 -> 0.25
powx203 power 0.5 3 -> 0.125
powx204 power 0.5 4 -> 0.0625
powx205 power 0.5 5 -> 0.03125
powx206 power 0.5 6 -> 0.015625
powx207 power 0.5 7 -> 0.0078125
powx208 power 0.5 8 -> 0.00390625
powx209 power 0.5 9 -> 0.001953125
powx210 power 0.5 10 -> 0.0009765625
-- A (rare) case where the last digit is not within 0.5 ULP
precision: 9
powx215 power "-21971575.0E+31454441" "-7" -> "-4.04549503E-220181139" Inexact Rounded
precision: 20
powx216 power "-21971575.0E+31454441" "-7" -> "-4.0454950249324891788E-220181139" Inexact Rounded
-- The Vienna case. Checks both setup and 1/acc working precision
-- Modified 1998.12.14 as RHS no longer rounded before use (must fit)
-- Modified 1990.02.04 as LHS is now rounded (instead of truncated to guard)
-- '123456789E+10' -- lhs .. rounded to 1.23E+18
-- '-1.23000e+2' -- rhs .. [was: -1.23455e+2, rounds to -123]
-- Modified 2002.10.06 -- finally, no input rounding
-- With input rounding, result would be 8.74E-2226
precision: 3
powx219 power '123456789E+10' '-1.23000e+2' -> '5.54E-2226' Inexact Rounded
-- whole number checks
precision: 9
powx221 power 1 1234 -> 1
precision: 4
powx222 power 1 1234 -> 1
precision: 3
powx223 power 1 1234 -> 1
powx224 power 1 12.34e+2 -> 1
powx225 power 1 12.3 -> NaN Invalid_operation
powx226 power 1 12.0 -> 1
powx227 power 1 1.01 -> NaN Invalid_operation
powx228 power 2 1.00 -> 2
powx229 power 2 2.00 -> 4
precision: 9
powx230 power 1 1.0001 -> NaN Invalid_operation
powx231 power 1 1.0000001 -> NaN Invalid_operation
powx232 power 1 1.0000000001 -> NaN Invalid_operation
powx233 power 1 1.0000000000001 -> NaN Invalid_operation
precision: 5
powx234 power 1 1.0001 -> NaN Invalid_operation
powx235 power 1 1.0000001 -> NaN Invalid_operation
powx236 power 1 1.0000000001 -> NaN Invalid_operation
powx237 power 1 1.0000000000001 -> NaN Invalid_operation
powx238 power 1 1.0000000000001 -> NaN Invalid_operation
maxexponent: 999999999
minexponent: -999999999
powx239 power 1 5.67E-987654321 -> NaN Invalid_operation
powx240 power 1 100000000 -> 1
powx241 power 1 999999998 -> 1
powx242 power 1 999999999 -> 1
powx243 power 1 1000000000 -> NaN Invalid_operation
powx244 power 1 9999999999 -> NaN Invalid_operation
-- Checks for 'Too much precision needed'
-- For x^12, digits+elength+1 = digits+3
precision: 999999999
powx249 add 1 1 -> 2 -- check basic operation at this precision
powx250 power 2 12 -> Infinity Overflow
precision: 999999998
powx251 power 2 12 -> Infinity Overflow
precision: 999999997
powx252 power 2 12 -> Infinity Overflow
precision: 999999996
powx253 power 2 12 -> 4096
precision: 999999995
powx254 power 2 12 -> 4096
-- zeros
maxexponent: +96
minexponent: -95
precision: 7
powx260 power 0E-34 3 -> 0E-101 Clamped
powx261 power 0E-33 3 -> 0E-99
powx262 power 0E-32 3 -> 0E-96
powx263 power 0E-30 3 -> 0E-90
powx264 power 0E-10 3 -> 0E-30
powx265 power 0E-1 3 -> 0.000
powx266 power 0E+0 3 -> 0
powx267 power 0 3 -> 0
powx268 power 0E+1 3 -> 0E+3
powx269 power 0E+10 3 -> 0E+30
powx270 power 0E+30 3 -> 0E+90
powx271 power 0E+32 3 -> 0E+96
powx272 power 0E+33 3 -> 0E+96 Clamped
-- overflow and underflow tests
maxexponent: 999999999
minexponent: -999999999
precision: 9
powx280 power 9 999999999 -> 3.05550054E+954242508 Inexact Rounded
powx281 power 10 999999999 -> 1.00000000E+999999999 Rounded
powx282 power 10.0001 999999999 -> Infinity Overflow Inexact Rounded
powx283 power 10.1 999999999 -> Infinity Overflow Inexact Rounded
powx284 power 11 999999999 -> Infinity Overflow Inexact Rounded
powx285 power 12 999999999 -> Infinity Overflow Inexact Rounded
powx286 power 999 999999999 -> Infinity Overflow Inexact Rounded
powx287 power 999999 999999999 -> Infinity Overflow Inexact Rounded
powx288 power 999999999 999999999 -> Infinity Overflow Inexact Rounded
powx289 power 9.9E999999999 999999999 -> Infinity Overflow Inexact Rounded
powx290 power 0.5 999999999 -> 4.33559594E-301029996 Inexact Rounded
powx291 power 0.1 999999999 -> 1E-999999999 -- unrounded
powx292 power 0.09 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx293 power 0.05 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx294 power 0.01 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx295 power 0.0001 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx297 power 0.0000001 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx298 power 0.0000000001 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx299 power 1E-999999999 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx310 power -9 999999999 -> -3.05550054E+954242508 Inexact Rounded
powx311 power -10 999999999 -> -1.00000000E+999999999 Rounded
powx312 power -10.0001 999999999 -> -Infinity Overflow Inexact Rounded
powx313 power -10.1 999999999 -> -Infinity Overflow Inexact Rounded
powx314 power -11 999999999 -> -Infinity Overflow Inexact Rounded
powx315 power -12 999999999 -> -Infinity Overflow Inexact Rounded
powx316 power -999 999999999 -> -Infinity Overflow Inexact Rounded
powx317 power -999999 999999999 -> -Infinity Overflow Inexact Rounded
powx318 power -999999999 999999999 -> -Infinity Overflow Inexact Rounded
powx319 power -9.9E999999999 999999999 -> -Infinity Overflow Inexact Rounded
powx320 power -0.5 999999999 -> -4.33559594E-301029996 Inexact Rounded
powx321 power -0.1 999999999 -> -1E-999999999
powx322 power -0.09 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx323 power -0.05 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx324 power -0.01 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx325 power -0.0001 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx327 power -0.0000001 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx328 power -0.0000000001 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx329 power -1E-999999999 999999999 -> -0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
-- note no trim of next result
powx330 power -9 999999998 -> 3.39500060E+954242507 Inexact Rounded
powx331 power -10 999999998 -> 1.00000000E+999999998 Rounded
powx332 power -10.0001 999999998 -> Infinity Overflow Inexact Rounded
powx333 power -10.1 999999998 -> Infinity Overflow Inexact Rounded
powx334 power -11 999999998 -> Infinity Overflow Inexact Rounded
powx335 power -12 999999998 -> Infinity Overflow Inexact Rounded
powx336 power -999 999999998 -> Infinity Overflow Inexact Rounded
powx337 power -999999 999999998 -> Infinity Overflow Inexact Rounded
powx338 power -999999999 999999998 -> Infinity Overflow Inexact Rounded
powx339 power -9.9E999999999 999999998 -> Infinity Overflow Inexact Rounded
powx340 power -0.5 999999998 -> 8.67119187E-301029996 Inexact Rounded
powx341 power -0.1 999999998 -> 1E-999999998 -- NB exact unrounded
powx342 power -0.09 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx343 power -0.05 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx344 power -0.01 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx345 power -0.0001 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx347 power -0.0000001 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx348 power -0.0000000001 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx349 power -1E-999999999 999999998 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
-- some subnormals
precision: 9
-- [precision is 9, so smallest exponent is -1000000007
powx350 power 1e-1 500000000 -> 1E-500000000
powx351 power 1e-2 999999999 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
powx352 power 1e-2 500000000 -> 1E-1000000000 Subnormal
powx353 power 1e-2 500000001 -> 1E-1000000002 Subnormal
powx354 power 1e-2 500000002 -> 1E-1000000004 Subnormal
powx355 power 1e-2 500000003 -> 1E-1000000006 Subnormal
powx356 power 1e-2 500000004 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
powx360 power 0.010001 500000000 -> 4.34941988E-999978287 Inexact Rounded
powx361 power 0.010000001 500000000 -> 5.18469257E-999999979 Inexact Rounded
powx362 power 0.010000001 500000001 -> 5.18469309E-999999981 Inexact Rounded
powx363 power 0.0100000009 500000000 -> 3.49342003E-999999981 Inexact Rounded
powx364 power 0.0100000001 500000000 -> 1.48413155E-999999998 Inexact Rounded
powx365 power 0.01 500000000 -> 1E-1000000000 Subnormal
powx366 power 0.0099999999 500000000 -> 6.7379E-1000000003 Underflow Subnormal Inexact Rounded
powx367 power 0.0099999998 500000000 -> 4.54E-1000000005 Underflow Subnormal Inexact Rounded
powx368 power 0.0099999997 500000000 -> 3E-1000000007 Underflow Subnormal Inexact Rounded
powx369 power 0.0099999996 500000000 -> 0E-1000000007 Underflow Subnormal Inexact Rounded
powx370 power 0.009 500000000 -> 0E-1000000007 Underflow Subnormal Inexact Rounded Clamped
-- 1/subnormal -> overflow
powx371 power 1e-1 -500000000 -> 1E+500000000
powx372 power 1e-2 -999999999 -> Infinity Overflow Inexact Rounded
powx373 power 1e-2 -500000000 -> Infinity Overflow Inexact Rounded
powx374 power 1e-2 -500000001 -> Infinity Overflow Inexact Rounded
powx375 power 1e-2 -500000002 -> Infinity Overflow Inexact Rounded
powx376 power 1e-2 -500000003 -> Infinity Overflow Inexact Rounded
powx377 power 1e-2 -500000004 -> Infinity Overflow Inexact Rounded
powx381 power 0.010001 -500000000 -> 2.29915719E+999978286 Inexact Rounded
powx382 power 0.010000001 -500000000 -> 1.92875467E+999999978 Inexact Rounded
powx383 power 0.010000001 -500000001 -> 1.92875448E+999999980 Inexact Rounded
powx384 power 0.0100000009 -500000000 -> 2.86252438E+999999980 Inexact Rounded
powx385 power 0.0100000001 -500000000 -> 6.73794717E+999999997 Inexact Rounded
powx386 power 0.01 -500000000 -> Infinity Overflow Inexact Rounded
powx387 power 0.009999 -500000000 -> Infinity Overflow Inexact Rounded
-- negative power giving subnormal
powx388 power 100.000001 -500000000 -> 6.7379E-1000000003 Underflow Subnormal Inexact Rounded
-- some more edge cases
precision: 15
maxExponent: 999
minexponent: -999
powx391 power 0.1 999 -> 1E-999
powx392 power 0.099 999 -> 4.360732062E-1004 Underflow Subnormal Inexact Rounded
powx393 power 0.098 999 -> 1.71731E-1008 Underflow Subnormal Inexact Rounded
powx394 power 0.097 999 -> 6E-1013 Underflow Subnormal Inexact Rounded
powx395 power 0.096 999 -> 0E-1013 Underflow Subnormal Inexact Rounded
powx396 power 0.01 999 -> 0E-1013 Underflow Subnormal Inexact Rounded Clamped
-- multiply tests are here to aid checking and test for consistent handling
-- of underflow
precision: 5
maxexponent: 999
minexponent: -999
-- squares
mulx400 multiply 1E-502 1e-502 -> 0E-1003 Subnormal Inexact Underflow Rounded
mulx401 multiply 1E-501 1e-501 -> 1E-1002 Subnormal
mulx402 multiply 2E-501 2e-501 -> 4E-1002 Subnormal
mulx403 multiply 4E-501 4e-501 -> 1.6E-1001 Subnormal
mulx404 multiply 10E-501 10e-501 -> 1.00E-1000 Subnormal
mulx405 multiply 30E-501 30e-501 -> 9.00E-1000 Subnormal
mulx406 multiply 40E-501 40e-501 -> 1.600E-999
powx400 power 1E-502 2 -> 0E-1003 Underflow Subnormal Inexact Rounded
powx401 power 1E-501 2 -> 1E-1002 Subnormal
powx402 power 2E-501 2 -> 4E-1002 Subnormal
powx403 power 4E-501 2 -> 1.6E-1001 Subnormal
powx404 power 10E-501 2 -> 1.00E-1000 Subnormal
powx405 power 30E-501 2 -> 9.00E-1000 Subnormal
powx406 power 40E-501 2 -> 1.600E-999
-- cubes
mulx410 multiply 1E-670 1e-335 -> 0E-1003 Underflow Subnormal Inexact Rounded
mulx411 multiply 1E-668 1e-334 -> 1E-1002 Subnormal
mulx412 multiply 4E-668 2e-334 -> 8E-1002 Subnormal
mulx413 multiply 9E-668 3e-334 -> 2.7E-1001 Subnormal
mulx414 multiply 16E-668 4e-334 -> 6.4E-1001 Subnormal
mulx415 multiply 25E-668 5e-334 -> 1.25E-1000 Subnormal
mulx416 multiply 10E-668 100e-334 -> 1.000E-999
powx410 power 1E-335 3 -> 0E-1003 Underflow Subnormal Inexact Rounded
powx411 power 1E-334 3 -> 1E-1002 Subnormal
powx412 power 2E-334 3 -> 8E-1002 Subnormal
powx413 power 3E-334 3 -> 2.7E-1001 Subnormal
powx414 power 4E-334 3 -> 6.4E-1001 Subnormal
powx415 power 5E-334 3 -> 1.25E-1000 Subnormal
powx416 power 10E-334 3 -> 1.000E-999
-- negative powers, testing subnormals
precision: 5
maxExponent: 999
minexponent: -999
powx421 power 2.5E-501 -2 -> Infinity Overflow Inexact Rounded
powx422 power 2.5E-500 -2 -> 1.6E+999
powx423 power 2.5E+499 -2 -> 1.6E-999
powx424 power 2.5E+500 -2 -> 1.6E-1001 Subnormal
powx425 power 2.5E+501 -2 -> 2E-1003 Underflow Subnormal Inexact Rounded
powx426 power 2.5E+502 -2 -> 0E-1003 Underflow Subnormal Inexact Rounded
powx427 power 0.25E+499 -2 -> 1.6E-997
powx428 power 0.25E+500 -2 -> 1.6E-999
powx429 power 0.25E+501 -2 -> 1.6E-1001 Subnormal
powx430 power 0.25E+502 -2 -> 2E-1003 Underflow Subnormal Inexact Rounded
powx431 power 0.25E+503 -2 -> 0E-1003 Underflow Subnormal Inexact Rounded
powx432 power 0.04E+499 -2 -> 6.25E-996
powx433 power 0.04E+500 -2 -> 6.25E-998
powx434 power 0.04E+501 -2 -> 6.25E-1000 Subnormal
powx435 power 0.04E+502 -2 -> 6.3E-1002 Underflow Subnormal Inexact Rounded
powx436 power 0.04E+503 -2 -> 1E-1003 Underflow Subnormal Inexact Rounded
powx437 power 0.04E+504 -2 -> 0E-1003 Underflow Subnormal Inexact Rounded
powx441 power 0.04E+334 -3 -> 1.5625E-998
powx442 power 0.04E+335 -3 -> 1.56E-1001 Underflow Subnormal Inexact Rounded
powx443 power 0.04E+336 -3 -> 0E-1003 Underflow Subnormal Inexact Rounded
powx444 power 0.25E+333 -3 -> 6.4E-998
powx445 power 0.25E+334 -3 -> 6.4E-1001 Subnormal
powx446 power 0.25E+335 -3 -> 1E-1003 Underflow Subnormal Inexact Rounded
powx447 power 0.25E+336 -3 -> 0E-1003 Underflow Subnormal Inexact Rounded Clamped
-- check sign for cubes and a few squares
powx448 power -0.04E+334 -3 -> -1.5625E-998
powx449 power -0.04E+335 -3 -> -1.56E-1001 Underflow Subnormal Inexact Rounded
powx450 power -0.04E+336 -3 -> -0E-1003 Underflow Subnormal Inexact Rounded
powx451 power -0.25E+333 -3 -> -6.4E-998
powx452 power -0.25E+334 -3 -> -6.4E-1001 Subnormal
powx453 power -0.25E+335 -3 -> -1E-1003 Underflow Subnormal Inexact Rounded
powx454 power -0.25E+336 -3 -> -0E-1003 Underflow Subnormal Inexact Rounded Clamped
powx455 power -0.04E+499 -2 -> 6.25E-996
powx456 power -0.04E+500 -2 -> 6.25E-998
powx457 power -0.04E+501 -2 -> 6.25E-1000 Subnormal
powx458 power -0.04E+502 -2 -> 6.3E-1002 Underflow Subnormal Inexact Rounded
-- test -0s
precision: 9
powx560 power 0 0 -> NaN Invalid_operation
powx561 power 0 -0 -> NaN Invalid_operation
powx562 power -0 0 -> NaN Invalid_operation
powx563 power -0 -0 -> NaN Invalid_operation
powx564 power 1 0 -> 1
powx565 power 1 -0 -> 1
powx566 power -1 0 -> 1
powx567 power -1 -0 -> 1
powx568 power 0 1 -> 0
powx569 power 0 -1 -> Infinity Division_by_zero
powx570 power -0 1 -> -0
powx571 power -0 -1 -> -Infinity Division_by_zero
powx572 power 0 2 -> 0
powx573 power 0 -2 -> Infinity Division_by_zero
powx574 power -0 2 -> 0
powx575 power -0 -2 -> Infinity Division_by_zero
powx576 power 0 3 -> 0
powx577 power 0 -3 -> Infinity Division_by_zero
powx578 power -0 3 -> -0
powx579 power -0 -3 -> -Infinity Division_by_zero
-- Specials
powx580 power Inf -Inf -> NaN Invalid_operation
powx581 power Inf -1000 -> 0
powx582 power Inf -1 -> 0
powx583 power Inf -0 -> 1
powx584 power Inf 0 -> 1
powx585 power Inf 1 -> Infinity
powx586 power Inf 1000 -> Infinity
powx587 power Inf Inf -> NaN Invalid_operation
powx588 power -1000 Inf -> NaN Invalid_operation
powx589 power -Inf Inf -> NaN Invalid_operation
powx590 power -1 Inf -> NaN Invalid_operation
powx591 power -0 Inf -> NaN Invalid_operation
powx592 power 0 Inf -> NaN Invalid_operation
powx593 power 1 Inf -> NaN Invalid_operation
powx594 power 1000 Inf -> NaN Invalid_operation
powx595 power Inf Inf -> NaN Invalid_operation
powx600 power -Inf -Inf -> NaN Invalid_operation
powx601 power -Inf -1000 -> 0
powx602 power -Inf -1 -> -0
powx603 power -Inf -0 -> 1
powx604 power -Inf 0 -> 1
powx605 power -Inf 1 -> -Infinity
powx606 power -Inf 1000 -> Infinity
powx607 power -Inf Inf -> NaN Invalid_operation
powx608 power -1000 Inf -> NaN Invalid_operation
powx609 power -Inf -Inf -> NaN Invalid_operation
powx610 power -1 -Inf -> NaN Invalid_operation
powx611 power -0 -Inf -> NaN Invalid_operation
powx612 power 0 -Inf -> NaN Invalid_operation
powx613 power 1 -Inf -> NaN Invalid_operation
powx614 power 1000 -Inf -> NaN Invalid_operation
powx615 power Inf -Inf -> NaN Invalid_operation
powx621 power NaN -Inf -> NaN Invalid_operation
powx622 power NaN -1000 -> NaN
powx623 power NaN -1 -> NaN
powx624 power NaN -0 -> NaN
powx625 power NaN 0 -> NaN
powx626 power NaN 1 -> NaN
powx627 power NaN 1000 -> NaN
powx628 power NaN Inf -> NaN Invalid_operation
powx629 power NaN NaN -> NaN
powx630 power -Inf NaN -> NaN
powx631 power -1000 NaN -> NaN
powx632 power -1 NaN -> NaN
powx633 power -0 NaN -> NaN
powx634 power 0 NaN -> NaN
powx635 power 1 NaN -> NaN
powx636 power 1000 NaN -> NaN
powx637 power Inf NaN -> NaN
powx641 power sNaN -Inf -> NaN Invalid_operation
powx642 power sNaN -1000 -> NaN Invalid_operation
powx643 power sNaN -1 -> NaN Invalid_operation
powx644 power sNaN -0 -> NaN Invalid_operation
powx645 power sNaN 0 -> NaN Invalid_operation
powx646 power sNaN 1 -> NaN Invalid_operation
powx647 power sNaN 1000 -> NaN Invalid_operation
powx648 power sNaN NaN -> NaN Invalid_operation
powx649 power sNaN sNaN -> NaN Invalid_operation
powx650 power NaN sNaN -> NaN Invalid_operation
powx651 power -Inf sNaN -> NaN Invalid_operation
powx652 power -1000 sNaN -> NaN Invalid_operation
powx653 power -1 sNaN -> NaN Invalid_operation
powx654 power -0 sNaN -> NaN Invalid_operation
powx655 power 0 sNaN -> NaN Invalid_operation
powx656 power 1 sNaN -> NaN Invalid_operation
powx657 power 1000 sNaN -> NaN Invalid_operation
powx658 power Inf sNaN -> NaN Invalid_operation
powx659 power NaN sNaN -> NaN Invalid_operation
-- NaN propagation
powx660 power NaN3 sNaN7 -> NaN7 Invalid_operation
powx661 power sNaN8 NaN6 -> NaN8 Invalid_operation
powx662 power 1 sNaN7 -> NaN7 Invalid_operation
powx663 power sNaN8 1 -> NaN8 Invalid_operation
powx664 power Inf sNaN7 -> NaN7 Invalid_operation
powx665 power sNaN8 Inf -> NaN Invalid_operation
powx666 power Inf NaN9 -> NaN9
powx667 power NaN6 Inf -> NaN Invalid_operation
powx668 power 1 NaN5 -> NaN5
powx669 power NaN2 1 -> NaN2
powx670 power NaN2 Nan4 -> NaN2
powx671 power NaN Nan4 -> NaN
powx672 power NaN345 Nan -> NaN345
powx673 power Inf -sNaN7 -> -NaN7 Invalid_operation
powx674 power -sNaN8 Inf -> NaN Invalid_operation
powx675 power Inf -NaN9 -> -NaN9
powx676 power -NaN6 Inf -> NaN Invalid_operation
powx677 power -NaN2 -Nan4 -> -NaN2
-- Examples from extended specification
powx690 power Inf -2 -> 0
powx691 power Inf -1 -> 0
powx692 power Inf 0 -> 1
powx693 power Inf 1 -> Infinity
powx694 power Inf 2 -> Infinity
powx695 power -Inf -2 -> 0
powx696 power -Inf -1 -> -0
powx697 power -Inf 0 -> 1
powx698 power -Inf 1 -> -Infinity
powx699 power -Inf 2 -> Infinity
powx700 power 0 0 -> NaN Invalid_operation
-- long operand and RHS range checks
maxexponent: 999
minexponent: -999
precision: 9
powx701 power 12345678000 1 -> 1.23456780E+10 Rounded
powx702 power 1234567800 1 -> 1.23456780E+9 Rounded
powx703 power 1234567890 1 -> 1.23456789E+9 Rounded
powx704 power 1234567891 1 -> 1.23456789E+9 Inexact Rounded
powx705 power 12345678901 1 -> 1.23456789E+10 Inexact Rounded
powx706 power 1234567896 1 -> 1.23456790E+9 Inexact Rounded
powx707 power 1 12345678000 -> NaN Invalid_operation
powx708 power 1 1234567800 -> NaN Invalid_operation
powx709 power 1 1234567890 -> NaN Invalid_operation
powx710 power 1 11234567891 -> NaN Invalid_operation
powx711 power 1 12345678901 -> NaN Invalid_operation
powx712 power 1 1234567896 -> NaN Invalid_operation
powx713 power 1 -1234567896 -> NaN Invalid_operation
powx714 power 1 1000000000 -> NaN Invalid_operation
powx715 power 1 -1000000000 -> NaN Invalid_operation
precision: 15
-- still checking
powx741 power 12345678000 1 -> 12345678000
powx742 power 1234567800 1 -> 1234567800
powx743 power 1234567890 1 -> 1234567890
powx744 power 1234567891 1 -> 1234567891
powx745 power 12345678901 1 -> 12345678901
powx746 power 1234567896 1 -> 1234567896
powx747 power 1 12345678000 -> NaN Invalid_operation
powx748 power 1 -1234567896 -> NaN Invalid_operation
powx749 power 1 1000000000 -> NaN Invalid_operation
powx740 power 1 -1000000000 -> NaN Invalid_operation
-- check for double-rounded subnormals
precision: 5
maxexponent: 79
minexponent: -79
powx750 power 1.2347E-40 2 -> 1.524E-80 Inexact Rounded Subnormal Underflow
-- Null tests
powx900 power 1 # -> NaN Invalid_operation
powx901 power # 1 -> NaN Invalid_operation

780
sys/lib/python/test/decimaltestdata/quantize.decTest
View file

@ -1,780 +0,0 @@
------------------------------------------------------------------------
-- quantize.decTest -- decimal quantize operation --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- Most of the tests here assume a "regular pattern", where the
-- sign and coefficient are +1.
-- 2004.03.15 Underflow for quantize is suppressed
extended: 1
precision: 9
rounding: half_up
maxExponent: 999
minexponent: -999
-- sanity checks
quax001 quantize 0 1e0 -> 0
quax002 quantize 1 1e0 -> 1
quax003 quantize 0.1 1e+2 -> 0E+2 Inexact Rounded
quax005 quantize 0.1 1e+1 -> 0E+1 Inexact Rounded
quax006 quantize 0.1 1e0 -> 0 Inexact Rounded
quax007 quantize 0.1 1e-1 -> 0.1
quax008 quantize 0.1 1e-2 -> 0.10
quax009 quantize 0.1 1e-3 -> 0.100
quax010 quantize 0.9 1e+2 -> 0E+2 Inexact Rounded
quax011 quantize 0.9 1e+1 -> 0E+1 Inexact Rounded
quax012 quantize 0.9 1e+0 -> 1 Inexact Rounded
quax013 quantize 0.9 1e-1 -> 0.9
quax014 quantize 0.9 1e-2 -> 0.90
quax015 quantize 0.9 1e-3 -> 0.900
-- negatives
quax021 quantize -0 1e0 -> -0
quax022 quantize -1 1e0 -> -1
quax023 quantize -0.1 1e+2 -> -0E+2 Inexact Rounded
quax025 quantize -0.1 1e+1 -> -0E+1 Inexact Rounded
quax026 quantize -0.1 1e0 -> -0 Inexact Rounded
quax027 quantize -0.1 1e-1 -> -0.1
quax028 quantize -0.1 1e-2 -> -0.10
quax029 quantize -0.1 1e-3 -> -0.100
quax030 quantize -0.9 1e+2 -> -0E+2 Inexact Rounded
quax031 quantize -0.9 1e+1 -> -0E+1 Inexact Rounded
quax032 quantize -0.9 1e+0 -> -1 Inexact Rounded
quax033 quantize -0.9 1e-1 -> -0.9
quax034 quantize -0.9 1e-2 -> -0.90
quax035 quantize -0.9 1e-3 -> -0.900
quax036 quantize -0.5 1e+2 -> -0E+2 Inexact Rounded
quax037 quantize -0.5 1e+1 -> -0E+1 Inexact Rounded
quax038 quantize -0.5 1e+0 -> -1 Inexact Rounded
quax039 quantize -0.5 1e-1 -> -0.5
quax040 quantize -0.5 1e-2 -> -0.50
quax041 quantize -0.5 1e-3 -> -0.500
quax042 quantize -0.9 1e+2 -> -0E+2 Inexact Rounded
quax043 quantize -0.9 1e+1 -> -0E+1 Inexact Rounded
quax044 quantize -0.9 1e+0 -> -1 Inexact Rounded
quax045 quantize -0.9 1e-1 -> -0.9
quax046 quantize -0.9 1e-2 -> -0.90
quax047 quantize -0.9 1e-3 -> -0.900
-- examples from Specification
quax060 quantize 2.17 0.001 -> 2.170
quax061 quantize 2.17 0.01 -> 2.17
quax062 quantize 2.17 0.1 -> 2.2 Inexact Rounded
quax063 quantize 2.17 1e+0 -> 2 Inexact Rounded
quax064 quantize 2.17 1e+1 -> 0E+1 Inexact Rounded
quax065 quantize -Inf Inf -> -Infinity
quax066 quantize 2 Inf -> NaN Invalid_operation
quax067 quantize -0.1 1 -> -0 Inexact Rounded
quax068 quantize -0 1e+5 -> -0E+5
quax069 quantize +35236450.6 1e-2 -> NaN Invalid_operation
quax070 quantize -35236450.6 1e-2 -> NaN Invalid_operation
quax071 quantize 217 1e-1 -> 217.0
quax072 quantize 217 1e+0 -> 217
quax073 quantize 217 1e+1 -> 2.2E+2 Inexact Rounded
quax074 quantize 217 1e+2 -> 2E+2 Inexact Rounded
-- general tests ..
quax089 quantize 12 1e+4 -> 0E+4 Inexact Rounded
quax090 quantize 12 1e+3 -> 0E+3 Inexact Rounded
quax091 quantize 12 1e+2 -> 0E+2 Inexact Rounded
quax092 quantize 12 1e+1 -> 1E+1 Inexact Rounded
quax093 quantize 1.2345 1e-2 -> 1.23 Inexact Rounded
quax094 quantize 1.2355 1e-2 -> 1.24 Inexact Rounded
quax095 quantize 1.2345 1e-6 -> 1.234500
quax096 quantize 9.9999 1e-2 -> 10.00 Inexact Rounded
quax097 quantize 0.0001 1e-2 -> 0.00 Inexact Rounded
quax098 quantize 0.001 1e-2 -> 0.00 Inexact Rounded
quax099 quantize 0.009 1e-2 -> 0.01 Inexact Rounded
quax100 quantize 92 1e+2 -> 1E+2 Inexact Rounded
quax101 quantize -1 1e0 -> -1
quax102 quantize -1 1e-1 -> -1.0
quax103 quantize -1 1e-2 -> -1.00
quax104 quantize 0 1e0 -> 0
quax105 quantize 0 1e-1 -> 0.0
quax106 quantize 0 1e-2 -> 0.00
quax107 quantize 0.00 1e0 -> 0
quax108 quantize 0 1e+1 -> 0E+1
quax109 quantize 0 1e+2 -> 0E+2
quax110 quantize +1 1e0 -> 1
quax111 quantize +1 1e-1 -> 1.0
quax112 quantize +1 1e-2 -> 1.00
quax120 quantize 1.04 1e-3 -> 1.040
quax121 quantize 1.04 1e-2 -> 1.04
quax122 quantize 1.04 1e-1 -> 1.0 Inexact Rounded
quax123 quantize 1.04 1e0 -> 1 Inexact Rounded
quax124 quantize 1.05 1e-3 -> 1.050
quax125 quantize 1.05 1e-2 -> 1.05
quax126 quantize 1.05 1e-1 -> 1.1 Inexact Rounded
quax127 quantize 1.05 1e0 -> 1 Inexact Rounded
quax128 quantize 1.05 1e-3 -> 1.050
quax129 quantize 1.05 1e-2 -> 1.05
quax130 quantize 1.05 1e-1 -> 1.1 Inexact Rounded
quax131 quantize 1.05 1e0 -> 1 Inexact Rounded
quax132 quantize 1.06 1e-3 -> 1.060
quax133 quantize 1.06 1e-2 -> 1.06
quax134 quantize 1.06 1e-1 -> 1.1 Inexact Rounded
quax135 quantize 1.06 1e0 -> 1 Inexact Rounded
quax140 quantize -10 1e-2 -> -10.00
quax141 quantize +1 1e-2 -> 1.00
quax142 quantize +10 1e-2 -> 10.00
quax143 quantize 1E+10 1e-2 -> NaN Invalid_operation
quax144 quantize 1E-10 1e-2 -> 0.00 Inexact Rounded
quax145 quantize 1E-3 1e-2 -> 0.00 Inexact Rounded
quax146 quantize 1E-2 1e-2 -> 0.01
quax147 quantize 1E-1 1e-2 -> 0.10
quax148 quantize 0E-10 1e-2 -> 0.00
quax150 quantize 1.0600 1e-5 -> 1.06000
quax151 quantize 1.0600 1e-4 -> 1.0600
quax152 quantize 1.0600 1e-3 -> 1.060 Rounded
quax153 quantize 1.0600 1e-2 -> 1.06 Rounded
quax154 quantize 1.0600 1e-1 -> 1.1 Inexact Rounded
quax155 quantize 1.0600 1e0 -> 1 Inexact Rounded
-- base tests with non-1 coefficients
quax161 quantize 0 -9e0 -> 0
quax162 quantize 1 -7e0 -> 1
quax163 quantize 0.1 -1e+2 -> 0E+2 Inexact Rounded
quax165 quantize 0.1 0e+1 -> 0E+1 Inexact Rounded
quax166 quantize 0.1 2e0 -> 0 Inexact Rounded
quax167 quantize 0.1 3e-1 -> 0.1
quax168 quantize 0.1 44e-2 -> 0.10
quax169 quantize 0.1 555e-3 -> 0.100
quax170 quantize 0.9 6666e+2 -> 0E+2 Inexact Rounded
quax171 quantize 0.9 -777e+1 -> 0E+1 Inexact Rounded
quax172 quantize 0.9 -88e+0 -> 1 Inexact Rounded
quax173 quantize 0.9 -9e-1 -> 0.9
quax174 quantize 0.9 0e-2 -> 0.90
quax175 quantize 0.9 1.1e-3 -> 0.9000
-- negatives
quax181 quantize -0 1.1e0 -> -0.0
quax182 quantize -1 -1e0 -> -1
quax183 quantize -0.1 11e+2 -> -0E+2 Inexact Rounded
quax185 quantize -0.1 111e+1 -> -0E+1 Inexact Rounded
quax186 quantize -0.1 71e0 -> -0 Inexact Rounded
quax187 quantize -0.1 -91e-1 -> -0.1
quax188 quantize -0.1 -.1e-2 -> -0.100
quax189 quantize -0.1 -1e-3 -> -0.100
quax190 quantize -0.9 0e+2 -> -0E+2 Inexact Rounded
quax191 quantize -0.9 -0e+1 -> -0E+1 Inexact Rounded
quax192 quantize -0.9 -10e+0 -> -1 Inexact Rounded
quax193 quantize -0.9 100e-1 -> -0.9
quax194 quantize -0.9 999e-2 -> -0.90
-- +ve exponents ..
quax201 quantize -1 1e+0 -> -1
quax202 quantize -1 1e+1 -> -0E+1 Inexact Rounded
quax203 quantize -1 1e+2 -> -0E+2 Inexact Rounded
quax204 quantize 0 1e+0 -> 0
quax205 quantize 0 1e+1 -> 0E+1
quax206 quantize 0 1e+2 -> 0E+2
quax207 quantize +1 1e+0 -> 1
quax208 quantize +1 1e+1 -> 0E+1 Inexact Rounded
quax209 quantize +1 1e+2 -> 0E+2 Inexact Rounded
quax220 quantize 1.04 1e+3 -> 0E+3 Inexact Rounded
quax221 quantize 1.04 1e+2 -> 0E+2 Inexact Rounded
quax222 quantize 1.04 1e+1 -> 0E+1 Inexact Rounded
quax223 quantize 1.04 1e+0 -> 1 Inexact Rounded
quax224 quantize 1.05 1e+3 -> 0E+3 Inexact Rounded
quax225 quantize 1.05 1e+2 -> 0E+2 Inexact Rounded
quax226 quantize 1.05 1e+1 -> 0E+1 Inexact Rounded
quax227 quantize 1.05 1e+0 -> 1 Inexact Rounded
quax228 quantize 1.05 1e+3 -> 0E+3 Inexact Rounded
quax229 quantize 1.05 1e+2 -> 0E+2 Inexact Rounded
quax230 quantize 1.05 1e+1 -> 0E+1 Inexact Rounded
quax231 quantize 1.05 1e+0 -> 1 Inexact Rounded
quax232 quantize 1.06 1e+3 -> 0E+3 Inexact Rounded
quax233 quantize 1.06 1e+2 -> 0E+2 Inexact Rounded
quax234 quantize 1.06 1e+1 -> 0E+1 Inexact Rounded
quax235 quantize 1.06 1e+0 -> 1 Inexact Rounded
quax240 quantize -10 1e+1 -> -1E+1 Rounded
quax241 quantize +1 1e+1 -> 0E+1 Inexact Rounded
quax242 quantize +10 1e+1 -> 1E+1 Rounded
quax243 quantize 1E+1 1e+1 -> 1E+1 -- underneath this is E+1
quax244 quantize 1E+2 1e+1 -> 1.0E+2 -- underneath this is E+1
quax245 quantize 1E+3 1e+1 -> 1.00E+3 -- underneath this is E+1
quax246 quantize 1E+4 1e+1 -> 1.000E+4 -- underneath this is E+1
quax247 quantize 1E+5 1e+1 -> 1.0000E+5 -- underneath this is E+1
quax248 quantize 1E+6 1e+1 -> 1.00000E+6 -- underneath this is E+1
quax249 quantize 1E+7 1e+1 -> 1.000000E+7 -- underneath this is E+1
quax250 quantize 1E+8 1e+1 -> 1.0000000E+8 -- underneath this is E+1
quax251 quantize 1E+9 1e+1 -> 1.00000000E+9 -- underneath this is E+1
-- next one tries to add 9 zeros
quax252 quantize 1E+10 1e+1 -> NaN Invalid_operation
quax253 quantize 1E-10 1e+1 -> 0E+1 Inexact Rounded
quax254 quantize 1E-2 1e+1 -> 0E+1 Inexact Rounded
quax255 quantize 0E-10 1e+1 -> 0E+1
quax256 quantize -0E-10 1e+1 -> -0E+1
quax257 quantize -0E-1 1e+1 -> -0E+1
quax258 quantize -0 1e+1 -> -0E+1
quax259 quantize -0E+1 1e+1 -> -0E+1
quax260 quantize -10 1e+2 -> -0E+2 Inexact Rounded
quax261 quantize +1 1e+2 -> 0E+2 Inexact Rounded
quax262 quantize +10 1e+2 -> 0E+2 Inexact Rounded
quax263 quantize 1E+1 1e+2 -> 0E+2 Inexact Rounded
quax264 quantize 1E+2 1e+2 -> 1E+2
quax265 quantize 1E+3 1e+2 -> 1.0E+3
quax266 quantize 1E+4 1e+2 -> 1.00E+4
quax267 quantize 1E+5 1e+2 -> 1.000E+5
quax268 quantize 1E+6 1e+2 -> 1.0000E+6
quax269 quantize 1E+7 1e+2 -> 1.00000E+7
quax270 quantize 1E+8 1e+2 -> 1.000000E+8
quax271 quantize 1E+9 1e+2 -> 1.0000000E+9
quax272 quantize 1E+10 1e+2 -> 1.00000000E+10
quax273 quantize 1E-10 1e+2 -> 0E+2 Inexact Rounded
quax274 quantize 1E-2 1e+2 -> 0E+2 Inexact Rounded
quax275 quantize 0E-10 1e+2 -> 0E+2
quax280 quantize -10 1e+3 -> -0E+3 Inexact Rounded
quax281 quantize +1 1e+3 -> 0E+3 Inexact Rounded
quax282 quantize +10 1e+3 -> 0E+3 Inexact Rounded
quax283 quantize 1E+1 1e+3 -> 0E+3 Inexact Rounded
quax284 quantize 1E+2 1e+3 -> 0E+3 Inexact Rounded
quax285 quantize 1E+3 1e+3 -> 1E+3
quax286 quantize 1E+4 1e+3 -> 1.0E+4
quax287 quantize 1E+5 1e+3 -> 1.00E+5
quax288 quantize 1E+6 1e+3 -> 1.000E+6
quax289 quantize 1E+7 1e+3 -> 1.0000E+7
quax290 quantize 1E+8 1e+3 -> 1.00000E+8
quax291 quantize 1E+9 1e+3 -> 1.000000E+9
quax292 quantize 1E+10 1e+3 -> 1.0000000E+10
quax293 quantize 1E-10 1e+3 -> 0E+3 Inexact Rounded
quax294 quantize 1E-2 1e+3 -> 0E+3 Inexact Rounded
quax295 quantize 0E-10 1e+3 -> 0E+3
-- round up from below [sign wrong in JIT compiler once]
quax300 quantize 0.0078 1e-5 -> 0.00780
quax301 quantize 0.0078 1e-4 -> 0.0078
quax302 quantize 0.0078 1e-3 -> 0.008 Inexact Rounded
quax303 quantize 0.0078 1e-2 -> 0.01 Inexact Rounded
quax304 quantize 0.0078 1e-1 -> 0.0 Inexact Rounded
quax305 quantize 0.0078 1e0 -> 0 Inexact Rounded
quax306 quantize 0.0078 1e+1 -> 0E+1 Inexact Rounded
quax307 quantize 0.0078 1e+2 -> 0E+2 Inexact Rounded
quax310 quantize -0.0078 1e-5 -> -0.00780
quax311 quantize -0.0078 1e-4 -> -0.0078
quax312 quantize -0.0078 1e-3 -> -0.008 Inexact Rounded
quax313 quantize -0.0078 1e-2 -> -0.01 Inexact Rounded
quax314 quantize -0.0078 1e-1 -> -0.0 Inexact Rounded
quax315 quantize -0.0078 1e0 -> -0 Inexact Rounded
quax316 quantize -0.0078 1e+1 -> -0E+1 Inexact Rounded
quax317 quantize -0.0078 1e+2 -> -0E+2 Inexact Rounded
quax320 quantize 0.078 1e-5 -> 0.07800
quax321 quantize 0.078 1e-4 -> 0.0780
quax322 quantize 0.078 1e-3 -> 0.078
quax323 quantize 0.078 1e-2 -> 0.08 Inexact Rounded
quax324 quantize 0.078 1e-1 -> 0.1 Inexact Rounded
quax325 quantize 0.078 1e0 -> 0 Inexact Rounded
quax326 quantize 0.078 1e+1 -> 0E+1 Inexact Rounded
quax327 quantize 0.078 1e+2 -> 0E+2 Inexact Rounded
quax330 quantize -0.078 1e-5 -> -0.07800
quax331 quantize -0.078 1e-4 -> -0.0780
quax332 quantize -0.078 1e-3 -> -0.078
quax333 quantize -0.078 1e-2 -> -0.08 Inexact Rounded
quax334 quantize -0.078 1e-1 -> -0.1 Inexact Rounded
quax335 quantize -0.078 1e0 -> -0 Inexact Rounded
quax336 quantize -0.078 1e+1 -> -0E+1 Inexact Rounded
quax337 quantize -0.078 1e+2 -> -0E+2 Inexact Rounded
quax340 quantize 0.78 1e-5 -> 0.78000
quax341 quantize 0.78 1e-4 -> 0.7800
quax342 quantize 0.78 1e-3 -> 0.780
quax343 quantize 0.78 1e-2 -> 0.78
quax344 quantize 0.78 1e-1 -> 0.8 Inexact Rounded
quax345 quantize 0.78 1e0 -> 1 Inexact Rounded
quax346 quantize 0.78 1e+1 -> 0E+1 Inexact Rounded
quax347 quantize 0.78 1e+2 -> 0E+2 Inexact Rounded
quax350 quantize -0.78 1e-5 -> -0.78000
quax351 quantize -0.78 1e-4 -> -0.7800
quax352 quantize -0.78 1e-3 -> -0.780
quax353 quantize -0.78 1e-2 -> -0.78
quax354 quantize -0.78 1e-1 -> -0.8 Inexact Rounded
quax355 quantize -0.78 1e0 -> -1 Inexact Rounded
quax356 quantize -0.78 1e+1 -> -0E+1 Inexact Rounded
quax357 quantize -0.78 1e+2 -> -0E+2 Inexact Rounded
quax360 quantize 7.8 1e-5 -> 7.80000
quax361 quantize 7.8 1e-4 -> 7.8000
quax362 quantize 7.8 1e-3 -> 7.800
quax363 quantize 7.8 1e-2 -> 7.80
quax364 quantize 7.8 1e-1 -> 7.8
quax365 quantize 7.8 1e0 -> 8 Inexact Rounded
quax366 quantize 7.8 1e+1 -> 1E+1 Inexact Rounded
quax367 quantize 7.8 1e+2 -> 0E+2 Inexact Rounded
quax368 quantize 7.8 1e+3 -> 0E+3 Inexact Rounded
quax370 quantize -7.8 1e-5 -> -7.80000
quax371 quantize -7.8 1e-4 -> -7.8000
quax372 quantize -7.8 1e-3 -> -7.800
quax373 quantize -7.8 1e-2 -> -7.80
quax374 quantize -7.8 1e-1 -> -7.8
quax375 quantize -7.8 1e0 -> -8 Inexact Rounded
quax376 quantize -7.8 1e+1 -> -1E+1 Inexact Rounded
quax377 quantize -7.8 1e+2 -> -0E+2 Inexact Rounded
quax378 quantize -7.8 1e+3 -> -0E+3 Inexact Rounded
-- some individuals
precision: 9
quax380 quantize 352364.506 1e-2 -> 352364.51 Inexact Rounded
quax381 quantize 3523645.06 1e-2 -> 3523645.06
quax382 quantize 35236450.6 1e-2 -> NaN Invalid_operation
quax383 quantize 352364506 1e-2 -> NaN Invalid_operation
quax384 quantize -352364.506 1e-2 -> -352364.51 Inexact Rounded
quax385 quantize -3523645.06 1e-2 -> -3523645.06
quax386 quantize -35236450.6 1e-2 -> NaN Invalid_operation
quax387 quantize -352364506 1e-2 -> NaN Invalid_operation
rounding: down
quax389 quantize 35236450.6 1e-2 -> NaN Invalid_operation
-- ? should that one instead have been:
-- quax389 quantize 35236450.6 1e-2 -> NaN Invalid_operation
rounding: half_up
-- and a few more from e-mail discussions
precision: 7
quax391 quantize 12.34567 1e-3 -> 12.346 Inexact Rounded
quax392 quantize 123.4567 1e-3 -> 123.457 Inexact Rounded
quax393 quantize 1234.567 1e-3 -> 1234.567
quax394 quantize 12345.67 1e-3 -> NaN Invalid_operation
quax395 quantize 123456.7 1e-3 -> NaN Invalid_operation
quax396 quantize 1234567. 1e-3 -> NaN Invalid_operation
-- some 9999 round-up cases
precision: 9
quax400 quantize 9.999 1e-5 -> 9.99900
quax401 quantize 9.999 1e-4 -> 9.9990
quax402 quantize 9.999 1e-3 -> 9.999
quax403 quantize 9.999 1e-2 -> 10.00 Inexact Rounded
quax404 quantize 9.999 1e-1 -> 10.0 Inexact Rounded
quax405 quantize 9.999 1e0 -> 10 Inexact Rounded
quax406 quantize 9.999 1e1 -> 1E+1 Inexact Rounded
quax407 quantize 9.999 1e2 -> 0E+2 Inexact Rounded
quax410 quantize 0.999 1e-5 -> 0.99900
quax411 quantize 0.999 1e-4 -> 0.9990
quax412 quantize 0.999 1e-3 -> 0.999
quax413 quantize 0.999 1e-2 -> 1.00 Inexact Rounded
quax414 quantize 0.999 1e-1 -> 1.0 Inexact Rounded
quax415 quantize 0.999 1e0 -> 1 Inexact Rounded
quax416 quantize 0.999 1e1 -> 0E+1 Inexact Rounded
quax420 quantize 0.0999 1e-5 -> 0.09990
quax421 quantize 0.0999 1e-4 -> 0.0999
quax422 quantize 0.0999 1e-3 -> 0.100 Inexact Rounded
quax423 quantize 0.0999 1e-2 -> 0.10 Inexact Rounded
quax424 quantize 0.0999 1e-1 -> 0.1 Inexact Rounded
quax425 quantize 0.0999 1e0 -> 0 Inexact Rounded
quax426 quantize 0.0999 1e1 -> 0E+1 Inexact Rounded
quax430 quantize 0.00999 1e-5 -> 0.00999
quax431 quantize 0.00999 1e-4 -> 0.0100 Inexact Rounded
quax432 quantize 0.00999 1e-3 -> 0.010 Inexact Rounded
quax433 quantize 0.00999 1e-2 -> 0.01 Inexact Rounded
quax434 quantize 0.00999 1e-1 -> 0.0 Inexact Rounded
quax435 quantize 0.00999 1e0 -> 0 Inexact Rounded
quax436 quantize 0.00999 1e1 -> 0E+1 Inexact Rounded
quax440 quantize 0.000999 1e-5 -> 0.00100 Inexact Rounded
quax441 quantize 0.000999 1e-4 -> 0.0010 Inexact Rounded
quax442 quantize 0.000999 1e-3 -> 0.001 Inexact Rounded
quax443 quantize 0.000999 1e-2 -> 0.00 Inexact Rounded
quax444 quantize 0.000999 1e-1 -> 0.0 Inexact Rounded
quax445 quantize 0.000999 1e0 -> 0 Inexact Rounded
quax446 quantize 0.000999 1e1 -> 0E+1 Inexact Rounded
precision: 8
quax449 quantize 9.999E-15 1e-23 -> NaN Invalid_operation
quax450 quantize 9.999E-15 1e-22 -> 9.9990000E-15
quax451 quantize 9.999E-15 1e-21 -> 9.999000E-15
quax452 quantize 9.999E-15 1e-20 -> 9.99900E-15
quax453 quantize 9.999E-15 1e-19 -> 9.9990E-15
quax454 quantize 9.999E-15 1e-18 -> 9.999E-15
quax455 quantize 9.999E-15 1e-17 -> 1.000E-14 Inexact Rounded
quax456 quantize 9.999E-15 1e-16 -> 1.00E-14 Inexact Rounded
quax457 quantize 9.999E-15 1e-15 -> 1.0E-14 Inexact Rounded
quax458 quantize 9.999E-15 1e-14 -> 1E-14 Inexact Rounded
quax459 quantize 9.999E-15 1e-13 -> 0E-13 Inexact Rounded
quax460 quantize 9.999E-15 1e-12 -> 0E-12 Inexact Rounded
quax461 quantize 9.999E-15 1e-11 -> 0E-11 Inexact Rounded
quax462 quantize 9.999E-15 1e-10 -> 0E-10 Inexact Rounded
quax463 quantize 9.999E-15 1e-9 -> 0E-9 Inexact Rounded
quax464 quantize 9.999E-15 1e-8 -> 0E-8 Inexact Rounded
quax465 quantize 9.999E-15 1e-7 -> 0E-7 Inexact Rounded
quax466 quantize 9.999E-15 1e-6 -> 0.000000 Inexact Rounded
quax467 quantize 9.999E-15 1e-5 -> 0.00000 Inexact Rounded
quax468 quantize 9.999E-15 1e-4 -> 0.0000 Inexact Rounded
quax469 quantize 9.999E-15 1e-3 -> 0.000 Inexact Rounded
quax470 quantize 9.999E-15 1e-2 -> 0.00 Inexact Rounded
quax471 quantize 9.999E-15 1e-1 -> 0.0 Inexact Rounded
quax472 quantize 9.999E-15 1e0 -> 0 Inexact Rounded
quax473 quantize 9.999E-15 1e1 -> 0E+1 Inexact Rounded
-- long operand checks [rhs checks removed]
maxexponent: 999
minexponent: -999
precision: 9
quax481 quantize 12345678000 1e+3 -> 1.2345678E+10 Rounded
quax482 quantize 1234567800 1e+1 -> 1.23456780E+9 Rounded
quax483 quantize 1234567890 1e+1 -> 1.23456789E+9 Rounded
quax484 quantize 1234567891 1e+1 -> 1.23456789E+9 Inexact Rounded
quax485 quantize 12345678901 1e+2 -> 1.23456789E+10 Inexact Rounded
quax486 quantize 1234567896 1e+1 -> 1.23456790E+9 Inexact Rounded
-- a potential double-round
quax487 quantize 1234.987643 1e-4 -> 1234.9876 Inexact Rounded
quax488 quantize 1234.987647 1e-4 -> 1234.9876 Inexact Rounded
precision: 15
quax491 quantize 12345678000 1e+3 -> 1.2345678E+10 Rounded
quax492 quantize 1234567800 1e+1 -> 1.23456780E+9 Rounded
quax493 quantize 1234567890 1e+1 -> 1.23456789E+9 Rounded
quax494 quantize 1234567891 1e+1 -> 1.23456789E+9 Inexact Rounded
quax495 quantize 12345678901 1e+2 -> 1.23456789E+10 Inexact Rounded
quax496 quantize 1234567896 1e+1 -> 1.23456790E+9 Inexact Rounded
quax497 quantize 1234.987643 1e-4 -> 1234.9876 Inexact Rounded
quax498 quantize 1234.987647 1e-4 -> 1234.9876 Inexact Rounded
-- Zeros
quax500 quantize 0 1e1 -> 0E+1
quax501 quantize 0 1e0 -> 0
quax502 quantize 0 1e-1 -> 0.0
quax503 quantize 0.0 1e-1 -> 0.0
quax504 quantize 0.0 1e0 -> 0
quax505 quantize 0.0 1e+1 -> 0E+1
quax506 quantize 0E+1 1e-1 -> 0.0
quax507 quantize 0E+1 1e0 -> 0
quax508 quantize 0E+1 1e+1 -> 0E+1
quax509 quantize -0 1e1 -> -0E+1
quax510 quantize -0 1e0 -> -0
quax511 quantize -0 1e-1 -> -0.0
quax512 quantize -0.0 1e-1 -> -0.0
quax513 quantize -0.0 1e0 -> -0
quax514 quantize -0.0 1e+1 -> -0E+1
quax515 quantize -0E+1 1e-1 -> -0.0
quax516 quantize -0E+1 1e0 -> -0
quax517 quantize -0E+1 1e+1 -> -0E+1
-- Suspicious RHS values
maxexponent: 999999999
minexponent: -999999999
precision: 15
quax520 quantize 1.234 1e999999000 -> 0E+999999000 Inexact Rounded
quax521 quantize 123.456 1e999999000 -> 0E+999999000 Inexact Rounded
quax522 quantize 1.234 1e999999999 -> 0E+999999999 Inexact Rounded
quax523 quantize 123.456 1e999999999 -> 0E+999999999 Inexact Rounded
quax524 quantize 123.456 1e1000000000 -> NaN Invalid_operation
quax525 quantize 123.456 1e12345678903 -> NaN Invalid_operation
-- next four are "won't fit" overflows
quax526 quantize 1.234 1e-999999000 -> NaN Invalid_operation
quax527 quantize 123.456 1e-999999000 -> NaN Invalid_operation
quax528 quantize 1.234 1e-999999999 -> NaN Invalid_operation
quax529 quantize 123.456 1e-999999999 -> NaN Invalid_operation
quax530 quantize 123.456 1e-1000000014 -> NaN Invalid_operation
quax531 quantize 123.456 1e-12345678903 -> NaN Invalid_operation
maxexponent: 999
minexponent: -999
precision: 15
quax532 quantize 1.234E+999 1e999 -> 1E+999 Inexact Rounded
quax533 quantize 1.234E+998 1e999 -> 0E+999 Inexact Rounded
quax534 quantize 1.234 1e999 -> 0E+999 Inexact Rounded
quax535 quantize 1.234 1e1000 -> NaN Invalid_operation
quax536 quantize 1.234 1e5000 -> NaN Invalid_operation
quax537 quantize 0 1e-999 -> 0E-999
-- next two are "won't fit" overflows
quax538 quantize 1.234 1e-999 -> NaN Invalid_operation
quax539 quantize 1.234 1e-1000 -> NaN Invalid_operation
quax540 quantize 1.234 1e-5000 -> NaN Invalid_operation
-- [more below]
-- check bounds (lhs maybe out of range for destination, etc.)
precision: 7
quax541 quantize 1E+999 1e+999 -> 1E+999
quax542 quantize 1E+1000 1e+999 -> NaN Invalid_operation
quax543 quantize 1E+999 1e+1000 -> NaN Invalid_operation
quax544 quantize 1E-999 1e-999 -> 1E-999
quax545 quantize 1E-1000 1e-999 -> 0E-999 Inexact Rounded
quax546 quantize 1E-999 1e-1000 -> 1.0E-999
quax547 quantize 1E-1005 1e-999 -> 0E-999 Inexact Rounded
quax548 quantize 1E-1006 1e-999 -> 0E-999 Inexact Rounded
quax549 quantize 1E-1007 1e-999 -> 0E-999 Inexact Rounded
quax550 quantize 1E-998 1e-1005 -> NaN Invalid_operation -- won't fit
quax551 quantize 1E-999 1e-1005 -> 1.000000E-999
quax552 quantize 1E-1000 1e-1005 -> 1.00000E-1000 Subnormal
quax553 quantize 1E-999 1e-1006 -> NaN Invalid_operation
quax554 quantize 1E-999 1e-1007 -> NaN Invalid_operation
-- related subnormal rounding
quax555 quantize 1.666666E-999 1e-1005 -> 1.666666E-999
quax556 quantize 1.666666E-1000 1e-1005 -> 1.66667E-1000 Subnormal Inexact Rounded
quax557 quantize 1.666666E-1001 1e-1005 -> 1.6667E-1001 Subnormal Inexact Rounded
quax558 quantize 1.666666E-1002 1e-1005 -> 1.667E-1002 Subnormal Inexact Rounded
quax559 quantize 1.666666E-1003 1e-1005 -> 1.67E-1003 Subnormal Inexact Rounded
quax560 quantize 1.666666E-1004 1e-1005 -> 1.7E-1004 Subnormal Inexact Rounded
quax561 quantize 1.666666E-1005 1e-1005 -> 2E-1005 Subnormal Inexact Rounded
quax562 quantize 1.666666E-1006 1e-1005 -> 0E-1005 Inexact Rounded
quax563 quantize 1.666666E-1007 1e-1005 -> 0E-1005 Inexact Rounded
-- Specials
quax580 quantize Inf -Inf -> Infinity
quax581 quantize Inf 1e-1000 -> NaN Invalid_operation
quax582 quantize Inf 1e-1 -> NaN Invalid_operation
quax583 quantize Inf 1e0 -> NaN Invalid_operation
quax584 quantize Inf 1e1 -> NaN Invalid_operation
quax585 quantize Inf 1e1000 -> NaN Invalid_operation
quax586 quantize Inf Inf -> Infinity
quax587 quantize -1000 Inf -> NaN Invalid_operation
quax588 quantize -Inf Inf -> -Infinity
quax589 quantize -1 Inf -> NaN Invalid_operation
quax590 quantize 0 Inf -> NaN Invalid_operation
quax591 quantize 1 Inf -> NaN Invalid_operation
quax592 quantize 1000 Inf -> NaN Invalid_operation
quax593 quantize Inf Inf -> Infinity
quax594 quantize Inf 1e-0 -> NaN Invalid_operation
quax595 quantize -0 Inf -> NaN Invalid_operation
quax600 quantize -Inf -Inf -> -Infinity
quax601 quantize -Inf 1e-1000 -> NaN Invalid_operation
quax602 quantize -Inf 1e-1 -> NaN Invalid_operation
quax603 quantize -Inf 1e0 -> NaN Invalid_operation
quax604 quantize -Inf 1e1 -> NaN Invalid_operation
quax605 quantize -Inf 1e1000 -> NaN Invalid_operation
quax606 quantize -Inf Inf -> -Infinity
quax607 quantize -1000 Inf -> NaN Invalid_operation
quax608 quantize -Inf -Inf -> -Infinity
quax609 quantize -1 -Inf -> NaN Invalid_operation
quax610 quantize 0 -Inf -> NaN Invalid_operation
quax611 quantize 1 -Inf -> NaN Invalid_operation
quax612 quantize 1000 -Inf -> NaN Invalid_operation
quax613 quantize Inf -Inf -> Infinity
quax614 quantize -Inf 1e-0 -> NaN Invalid_operation
quax615 quantize -0 -Inf -> NaN Invalid_operation
quax621 quantize NaN -Inf -> NaN
quax622 quantize NaN 1e-1000 -> NaN
quax623 quantize NaN 1e-1 -> NaN
quax624 quantize NaN 1e0 -> NaN
quax625 quantize NaN 1e1 -> NaN
quax626 quantize NaN 1e1000 -> NaN
quax627 quantize NaN Inf -> NaN
quax628 quantize NaN NaN -> NaN
quax629 quantize -Inf NaN -> NaN
quax630 quantize -1000 NaN -> NaN
quax631 quantize -1 NaN -> NaN
quax632 quantize 0 NaN -> NaN
quax633 quantize 1 NaN -> NaN
quax634 quantize 1000 NaN -> NaN
quax635 quantize Inf NaN -> NaN
quax636 quantize NaN 1e-0 -> NaN
quax637 quantize -0 NaN -> NaN
quax641 quantize sNaN -Inf -> NaN Invalid_operation
quax642 quantize sNaN 1e-1000 -> NaN Invalid_operation
quax643 quantize sNaN 1e-1 -> NaN Invalid_operation
quax644 quantize sNaN 1e0 -> NaN Invalid_operation
quax645 quantize sNaN 1e1 -> NaN Invalid_operation
quax646 quantize sNaN 1e1000 -> NaN Invalid_operation
quax647 quantize sNaN NaN -> NaN Invalid_operation
quax648 quantize sNaN sNaN -> NaN Invalid_operation
quax649 quantize NaN sNaN -> NaN Invalid_operation
quax650 quantize -Inf sNaN -> NaN Invalid_operation
quax651 quantize -1000 sNaN -> NaN Invalid_operation
quax652 quantize -1 sNaN -> NaN Invalid_operation
quax653 quantize 0 sNaN -> NaN Invalid_operation
quax654 quantize 1 sNaN -> NaN Invalid_operation
quax655 quantize 1000 sNaN -> NaN Invalid_operation
quax656 quantize Inf sNaN -> NaN Invalid_operation
quax657 quantize NaN sNaN -> NaN Invalid_operation
quax658 quantize sNaN 1e-0 -> NaN Invalid_operation
quax659 quantize -0 sNaN -> NaN Invalid_operation
-- propagating NaNs
quax661 quantize NaN9 -Inf -> NaN9
quax662 quantize NaN8 919 -> NaN8
quax663 quantize NaN71 Inf -> NaN71
quax664 quantize NaN6 NaN5 -> NaN6
quax665 quantize -Inf NaN4 -> NaN4
quax666 quantize -919 NaN31 -> NaN31
quax667 quantize Inf NaN2 -> NaN2
quax671 quantize sNaN99 -Inf -> NaN99 Invalid_operation
quax672 quantize sNaN98 -11 -> NaN98 Invalid_operation
quax673 quantize sNaN97 NaN -> NaN97 Invalid_operation
quax674 quantize sNaN16 sNaN94 -> NaN16 Invalid_operation
quax675 quantize NaN95 sNaN93 -> NaN93 Invalid_operation
quax676 quantize -Inf sNaN92 -> NaN92 Invalid_operation
quax677 quantize 088 sNaN91 -> NaN91 Invalid_operation
quax678 quantize Inf sNaN90 -> NaN90 Invalid_operation
quax679 quantize NaN sNaN88 -> NaN88 Invalid_operation
quax681 quantize -NaN9 -Inf -> -NaN9
quax682 quantize -NaN8 919 -> -NaN8
quax683 quantize -NaN71 Inf -> -NaN71
quax684 quantize -NaN6 -NaN5 -> -NaN6
quax685 quantize -Inf -NaN4 -> -NaN4
quax686 quantize -919 -NaN31 -> -NaN31
quax687 quantize Inf -NaN2 -> -NaN2
quax691 quantize -sNaN99 -Inf -> -NaN99 Invalid_operation
quax692 quantize -sNaN98 -11 -> -NaN98 Invalid_operation
quax693 quantize -sNaN97 NaN -> -NaN97 Invalid_operation
quax694 quantize -sNaN16 sNaN94 -> -NaN16 Invalid_operation
quax695 quantize -NaN95 -sNaN93 -> -NaN93 Invalid_operation
quax696 quantize -Inf -sNaN92 -> -NaN92 Invalid_operation
quax697 quantize 088 -sNaN91 -> -NaN91 Invalid_operation
quax698 quantize Inf -sNaN90 -> -NaN90 Invalid_operation
quax699 quantize NaN -sNaN88 -> -NaN88 Invalid_operation
-- subnormals and underflow
precision: 4
maxexponent: 999
minexponent: -999
quax710 quantize 1.00E-999 1e-999 -> 1E-999 Rounded
quax711 quantize 0.1E-999 2e-1000 -> 1E-1000 Subnormal
quax712 quantize 0.10E-999 3e-1000 -> 1E-1000 Subnormal Rounded
quax713 quantize 0.100E-999 4e-1000 -> 1E-1000 Subnormal Rounded
quax714 quantize 0.01E-999 5e-1001 -> 1E-1001 Subnormal
-- next is rounded to Emin
quax715 quantize 0.999E-999 1e-999 -> 1E-999 Inexact Rounded
quax716 quantize 0.099E-999 10e-1000 -> 1E-1000 Inexact Rounded Subnormal
quax717 quantize 0.009E-999 1e-1001 -> 1E-1001 Inexact Rounded Subnormal
quax718 quantize 0.001E-999 1e-1001 -> 0E-1001 Inexact Rounded
quax719 quantize 0.0009E-999 1e-1001 -> 0E-1001 Inexact Rounded
quax720 quantize 0.0001E-999 1e-1001 -> 0E-1001 Inexact Rounded
quax730 quantize -1.00E-999 1e-999 -> -1E-999 Rounded
quax731 quantize -0.1E-999 1e-999 -> -0E-999 Rounded Inexact
quax732 quantize -0.10E-999 1e-999 -> -0E-999 Rounded Inexact
quax733 quantize -0.100E-999 1e-999 -> -0E-999 Rounded Inexact
quax734 quantize -0.01E-999 1e-999 -> -0E-999 Inexact Rounded
-- next is rounded to Emin
quax735 quantize -0.999E-999 90e-999 -> -1E-999 Inexact Rounded
quax736 quantize -0.099E-999 -1e-999 -> -0E-999 Inexact Rounded
quax737 quantize -0.009E-999 -1e-999 -> -0E-999 Inexact Rounded
quax738 quantize -0.001E-999 -0e-999 -> -0E-999 Inexact Rounded
quax739 quantize -0.0001E-999 0e-999 -> -0E-999 Inexact Rounded
quax740 quantize -1.00E-999 1e-1000 -> -1.0E-999 Rounded
quax741 quantize -0.1E-999 1e-1000 -> -1E-1000 Subnormal
quax742 quantize -0.10E-999 1e-1000 -> -1E-1000 Subnormal Rounded
quax743 quantize -0.100E-999 1e-1000 -> -1E-1000 Subnormal Rounded
quax744 quantize -0.01E-999 1e-1000 -> -0E-1000 Inexact Rounded
-- next is rounded to Emin
quax745 quantize -0.999E-999 1e-1000 -> -1.0E-999 Inexact Rounded
quax746 quantize -0.099E-999 1e-1000 -> -1E-1000 Inexact Rounded Subnormal
quax747 quantize -0.009E-999 1e-1000 -> -0E-1000 Inexact Rounded
quax748 quantize -0.001E-999 1e-1000 -> -0E-1000 Inexact Rounded
quax749 quantize -0.0001E-999 1e-1000 -> -0E-1000 Inexact Rounded
quax750 quantize -1.00E-999 1e-1001 -> -1.00E-999
quax751 quantize -0.1E-999 1e-1001 -> -1.0E-1000 Subnormal
quax752 quantize -0.10E-999 1e-1001 -> -1.0E-1000 Subnormal
quax753 quantize -0.100E-999 1e-1001 -> -1.0E-1000 Subnormal Rounded
quax754 quantize -0.01E-999 1e-1001 -> -1E-1001 Subnormal
-- next is rounded to Emin
quax755 quantize -0.999E-999 1e-1001 -> -1.00E-999 Inexact Rounded
quax756 quantize -0.099E-999 1e-1001 -> -1.0E-1000 Inexact Rounded Subnormal
quax757 quantize -0.009E-999 1e-1001 -> -1E-1001 Inexact Rounded Subnormal
quax758 quantize -0.001E-999 1e-1001 -> -0E-1001 Inexact Rounded
quax759 quantize -0.0001E-999 1e-1001 -> -0E-1001 Inexact Rounded
quax760 quantize -1.00E-999 1e-1002 -> -1.000E-999
quax761 quantize -0.1E-999 1e-1002 -> -1.00E-1000 Subnormal
quax762 quantize -0.10E-999 1e-1002 -> -1.00E-1000 Subnormal
quax763 quantize -0.100E-999 1e-1002 -> -1.00E-1000 Subnormal
quax764 quantize -0.01E-999 1e-1002 -> -1.0E-1001 Subnormal
quax765 quantize -0.999E-999 1e-1002 -> -9.99E-1000 Subnormal
quax766 quantize -0.099E-999 1e-1002 -> -9.9E-1001 Subnormal
quax767 quantize -0.009E-999 1e-1002 -> -9E-1002 Subnormal
quax768 quantize -0.001E-999 1e-1002 -> -1E-1002 Subnormal
quax769 quantize -0.0001E-999 1e-1002 -> -0E-1002 Inexact Rounded
-- rhs must be no less than Etiny
quax770 quantize -1.00E-999 1e-1003 -> NaN Invalid_operation
quax771 quantize -0.1E-999 1e-1003 -> NaN Invalid_operation
quax772 quantize -0.10E-999 1e-1003 -> NaN Invalid_operation
quax773 quantize -0.100E-999 1e-1003 -> NaN Invalid_operation
quax774 quantize -0.01E-999 1e-1003 -> NaN Invalid_operation
quax775 quantize -0.999E-999 1e-1003 -> NaN Invalid_operation
quax776 quantize -0.099E-999 1e-1003 -> NaN Invalid_operation
quax777 quantize -0.009E-999 1e-1003 -> NaN Invalid_operation
quax778 quantize -0.001E-999 1e-1003 -> NaN Invalid_operation
quax779 quantize -0.0001E-999 1e-1003 -> NaN Invalid_operation
quax780 quantize -0.0001E-999 1e-1004 -> NaN Invalid_operation
precision: 9
maxExponent: 999999999
minexponent: -999999999
-- some extremes derived from Rescale testcases
quax801 quantize 0 1e1000000000 -> NaN Invalid_operation
quax802 quantize 0 1e-1000000000 -> 0E-1000000000
quax803 quantize 0 1e2000000000 -> NaN Invalid_operation
quax804 quantize 0 1e-2000000000 -> NaN Invalid_operation
quax805 quantize 0 1e3000000000 -> NaN Invalid_operation
quax806 quantize 0 1e-3000000000 -> NaN Invalid_operation
quax807 quantize 0 1e4000000000 -> NaN Invalid_operation
quax808 quantize 0 1e-4000000000 -> NaN Invalid_operation
quax809 quantize 0 1e5000000000 -> NaN Invalid_operation
quax810 quantize 0 1e-5000000000 -> NaN Invalid_operation
quax811 quantize 0 1e6000000000 -> NaN Invalid_operation
quax812 quantize 0 1e-6000000000 -> NaN Invalid_operation
quax813 quantize 0 1e7000000000 -> NaN Invalid_operation
quax814 quantize 0 1e-7000000000 -> NaN Invalid_operation
quax815 quantize 0 1e8000000000 -> NaN Invalid_operation
quax816 quantize 0 1e-8000000000 -> NaN Invalid_operation
quax817 quantize 0 1e9000000000 -> NaN Invalid_operation
quax818 quantize 0 1e-9000000000 -> NaN Invalid_operation
quax819 quantize 0 1e9999999999 -> NaN Invalid_operation
quax820 quantize 0 1e-9999999999 -> NaN Invalid_operation
quax821 quantize 0 1e10000000000 -> NaN Invalid_operation
quax822 quantize 0 1e-10000000000 -> NaN Invalid_operation
quax843 quantize 0 1e999999999 -> 0E+999999999
quax844 quantize 0 1e1000000000 -> NaN Invalid_operation
quax845 quantize 0 1e-999999999 -> 0E-999999999
quax846 quantize 0 1e-1000000000 -> 0E-1000000000
quax847 quantize 0 1e-1000000001 -> 0E-1000000001
quax848 quantize 0 1e-1000000002 -> 0E-1000000002
quax849 quantize 0 1e-1000000003 -> 0E-1000000003
quax850 quantize 0 1e-1000000004 -> 0E-1000000004
quax851 quantize 0 1e-1000000005 -> 0E-1000000005
quax852 quantize 0 1e-1000000006 -> 0E-1000000006
quax853 quantize 0 1e-1000000007 -> 0E-1000000007
quax854 quantize 0 1e-1000000008 -> NaN Invalid_operation
quax861 quantize 1 1e+2147483649 -> NaN Invalid_operation
quax862 quantize 1 1e+2147483648 -> NaN Invalid_operation
quax863 quantize 1 1e+2147483647 -> NaN Invalid_operation
quax864 quantize 1 1e-2147483647 -> NaN Invalid_operation
quax865 quantize 1 1e-2147483648 -> NaN Invalid_operation
quax866 quantize 1 1e-2147483649 -> NaN Invalid_operation
-- Null tests
quax900 quantize 10 # -> NaN Invalid_operation
quax901 quantize # 1e10 -> NaN Invalid_operation

2443
sys/lib/python/test/decimaltestdata/randomBound32.decTest
View file

File diff suppressed because it is too large Load diff

4029
sys/lib/python/test/decimaltestdata/randoms.decTest
View file

File diff suppressed because it is too large Load diff

629
sys/lib/python/test/decimaltestdata/remainder.decTest
View file

@ -1,629 +0,0 @@
------------------------------------------------------------------------
-- remainder.decTest -- decimal remainder --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
extended: 1
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
-- sanity checks (as base, above)
remx001 remainder 1 1 -> 0
remx002 remainder 2 1 -> 0
remx003 remainder 1 2 -> 1
remx004 remainder 2 2 -> 0
remx005 remainder 0 1 -> 0
remx006 remainder 0 2 -> 0
remx007 remainder 1 3 -> 1
remx008 remainder 2 3 -> 2
remx009 remainder 3 3 -> 0
remx010 remainder 2.4 1 -> 0.4
remx011 remainder 2.4 -1 -> 0.4
remx012 remainder -2.4 1 -> -0.4
remx013 remainder -2.4 -1 -> -0.4
remx014 remainder 2.40 1 -> 0.40
remx015 remainder 2.400 1 -> 0.400
remx016 remainder 2.4 2 -> 0.4
remx017 remainder 2.400 2 -> 0.400
remx018 remainder 2. 2 -> 0
remx019 remainder 20 20 -> 0
remx020 remainder 187 187 -> 0
remx021 remainder 5 2 -> 1
remx022 remainder 5 2.0 -> 1.0
remx023 remainder 5 2.000 -> 1.000
remx024 remainder 5 0.200 -> 0.000
remx025 remainder 5 0.200 -> 0.000
remx030 remainder 1 2 -> 1
remx031 remainder 1 4 -> 1
remx032 remainder 1 8 -> 1
remx033 remainder 1 16 -> 1
remx034 remainder 1 32 -> 1
remx035 remainder 1 64 -> 1
remx040 remainder 1 -2 -> 1
remx041 remainder 1 -4 -> 1
remx042 remainder 1 -8 -> 1
remx043 remainder 1 -16 -> 1
remx044 remainder 1 -32 -> 1
remx045 remainder 1 -64 -> 1
remx050 remainder -1 2 -> -1
remx051 remainder -1 4 -> -1
remx052 remainder -1 8 -> -1
remx053 remainder -1 16 -> -1
remx054 remainder -1 32 -> -1
remx055 remainder -1 64 -> -1
remx060 remainder -1 -2 -> -1
remx061 remainder -1 -4 -> -1
remx062 remainder -1 -8 -> -1
remx063 remainder -1 -16 -> -1
remx064 remainder -1 -32 -> -1
remx065 remainder -1 -64 -> -1
remx066 remainder 999999999 1 -> 0
remx067 remainder 999999999.4 1 -> 0.4
remx068 remainder 999999999.5 1 -> 0.5
remx069 remainder 999999999.9 1 -> 0.9
remx070 remainder 999999999.999 1 -> 0.999
precision: 6
remx071 remainder 999999999 1 -> NaN Division_impossible
remx072 remainder 99999999 1 -> NaN Division_impossible
remx073 remainder 9999999 1 -> NaN Division_impossible
remx074 remainder 999999 1 -> 0
remx075 remainder 99999 1 -> 0
remx076 remainder 9999 1 -> 0
remx077 remainder 999 1 -> 0
remx078 remainder 99 1 -> 0
remx079 remainder 9 1 -> 0
precision: 9
remx080 remainder 0. 1 -> 0
remx081 remainder .0 1 -> 0.0
remx082 remainder 0.00 1 -> 0.00
remx083 remainder 0.00E+9 1 -> 0
remx084 remainder 0.00E+3 1 -> 0
remx085 remainder 0.00E+2 1 -> 0
remx086 remainder 0.00E+1 1 -> 0.0
remx087 remainder 0.00E+0 1 -> 0.00
remx088 remainder 0.00E-0 1 -> 0.00
remx089 remainder 0.00E-1 1 -> 0.000
remx090 remainder 0.00E-2 1 -> 0.0000
remx091 remainder 0.00E-3 1 -> 0.00000
remx092 remainder 0.00E-4 1 -> 0.000000
remx093 remainder 0.00E-5 1 -> 0E-7
remx094 remainder 0.00E-6 1 -> 0E-8
remx095 remainder 0.0000E-50 1 -> 0E-54
-- Various flavours of remainder by 0
precision: 9
maxexponent: 999999999
minexponent: -999999999
remx101 remainder 0 0 -> NaN Division_undefined
remx102 remainder 0 -0 -> NaN Division_undefined
remx103 remainder -0 0 -> NaN Division_undefined
remx104 remainder -0 -0 -> NaN Division_undefined
remx105 remainder 0.0E5 0 -> NaN Division_undefined
remx106 remainder 0.000 0 -> NaN Division_undefined
-- [Some think this next group should be Division_by_zero exception, but
-- IEEE 854 is explicit that it is Invalid operation .. for
-- remainder-near, anyway]
remx107 remainder 0.0001 0 -> NaN Invalid_operation
remx108 remainder 0.01 0 -> NaN Invalid_operation
remx109 remainder 0.1 0 -> NaN Invalid_operation
remx110 remainder 1 0 -> NaN Invalid_operation
remx111 remainder 1 0.0 -> NaN Invalid_operation
remx112 remainder 10 0.0 -> NaN Invalid_operation
remx113 remainder 1E+100 0.0 -> NaN Invalid_operation
remx114 remainder 1E+1000 0 -> NaN Invalid_operation
remx115 remainder 0.0001 -0 -> NaN Invalid_operation
remx116 remainder 0.01 -0 -> NaN Invalid_operation
remx119 remainder 0.1 -0 -> NaN Invalid_operation
remx120 remainder 1 -0 -> NaN Invalid_operation
remx121 remainder 1 -0.0 -> NaN Invalid_operation
remx122 remainder 10 -0.0 -> NaN Invalid_operation
remx123 remainder 1E+100 -0.0 -> NaN Invalid_operation
remx124 remainder 1E+1000 -0 -> NaN Invalid_operation
-- and zeros on left
remx130 remainder 0 1 -> 0
remx131 remainder 0 -1 -> 0
remx132 remainder 0.0 1 -> 0.0
remx133 remainder 0.0 -1 -> 0.0
remx134 remainder -0 1 -> -0
remx135 remainder -0 -1 -> -0
remx136 remainder -0.0 1 -> -0.0
remx137 remainder -0.0 -1 -> -0.0
-- 0.5ers
remx143 remainder 0.5 2 -> 0.5
remx144 remainder 0.5 2.1 -> 0.5
remx145 remainder 0.5 2.01 -> 0.50
remx146 remainder 0.5 2.001 -> 0.500
remx147 remainder 0.50 2 -> 0.50
remx148 remainder 0.50 2.01 -> 0.50
remx149 remainder 0.50 2.001 -> 0.500
-- steadies
remx150 remainder 1 1 -> 0
remx151 remainder 1 2 -> 1
remx152 remainder 1 3 -> 1
remx153 remainder 1 4 -> 1
remx154 remainder 1 5 -> 1
remx155 remainder 1 6 -> 1
remx156 remainder 1 7 -> 1
remx157 remainder 1 8 -> 1
remx158 remainder 1 9 -> 1
remx159 remainder 1 10 -> 1
remx160 remainder 1 1 -> 0
remx161 remainder 2 1 -> 0
remx162 remainder 3 1 -> 0
remx163 remainder 4 1 -> 0
remx164 remainder 5 1 -> 0
remx165 remainder 6 1 -> 0
remx166 remainder 7 1 -> 0
remx167 remainder 8 1 -> 0
remx168 remainder 9 1 -> 0
remx169 remainder 10 1 -> 0
-- some differences from remainderNear
remx171 remainder 0.4 1.020 -> 0.400
remx172 remainder 0.50 1.020 -> 0.500
remx173 remainder 0.51 1.020 -> 0.510
remx174 remainder 0.52 1.020 -> 0.520
remx175 remainder 0.6 1.020 -> 0.600
-- More flavours of remainder by 0
maxexponent: 999999999
minexponent: -999999999
remx201 remainder 0 0 -> NaN Division_undefined
remx202 remainder 0.0E5 0 -> NaN Division_undefined
remx203 remainder 0.000 0 -> NaN Division_undefined
remx204 remainder 0.0001 0 -> NaN Invalid_operation
remx205 remainder 0.01 0 -> NaN Invalid_operation
remx206 remainder 0.1 0 -> NaN Invalid_operation
remx207 remainder 1 0 -> NaN Invalid_operation
remx208 remainder 1 0.0 -> NaN Invalid_operation
remx209 remainder 10 0.0 -> NaN Invalid_operation
remx210 remainder 1E+100 0.0 -> NaN Invalid_operation
remx211 remainder 1E+1000 0 -> NaN Invalid_operation
-- some differences from remainderNear
remx231 remainder -0.4 1.020 -> -0.400
remx232 remainder -0.50 1.020 -> -0.500
remx233 remainder -0.51 1.020 -> -0.510
remx234 remainder -0.52 1.020 -> -0.520
remx235 remainder -0.6 1.020 -> -0.600
-- high Xs
remx240 remainder 1E+2 1.00 -> 0.00
-- test some cases that are close to exponent overflow
maxexponent: 999999999
minexponent: -999999999
remx270 remainder 1 1e999999999 -> 1
remx271 remainder 1 0.9e999999999 -> 1
remx272 remainder 1 0.99e999999999 -> 1
remx273 remainder 1 0.999999999e999999999 -> 1
remx274 remainder 9e999999999 1 -> NaN Division_impossible
remx275 remainder 9.9e999999999 1 -> NaN Division_impossible
remx276 remainder 9.99e999999999 1 -> NaN Division_impossible
remx277 remainder 9.99999999e999999999 1 -> NaN Division_impossible
remx280 remainder 0.1 9e-999999999 -> NaN Division_impossible
remx281 remainder 0.1 99e-999999999 -> NaN Division_impossible
remx282 remainder 0.1 999e-999999999 -> NaN Division_impossible
remx283 remainder 0.1 9e-999999998 -> NaN Division_impossible
remx284 remainder 0.1 99e-999999998 -> NaN Division_impossible
remx285 remainder 0.1 999e-999999998 -> NaN Division_impossible
remx286 remainder 0.1 999e-999999997 -> NaN Division_impossible
remx287 remainder 0.1 9999e-999999997 -> NaN Division_impossible
remx288 remainder 0.1 99999e-999999997 -> NaN Division_impossible
-- remx3xx are from DiagBigDecimal
remx301 remainder 1 3 -> 1
remx302 remainder 5 5 -> 0
remx303 remainder 13 10 -> 3
remx304 remainder 13 50 -> 13
remx305 remainder 13 100 -> 13
remx306 remainder 13 1000 -> 13
remx307 remainder .13 1 -> 0.13
remx308 remainder 0.133 1 -> 0.133
remx309 remainder 0.1033 1 -> 0.1033
remx310 remainder 1.033 1 -> 0.033
remx311 remainder 10.33 1 -> 0.33
remx312 remainder 10.33 10 -> 0.33
remx313 remainder 103.3 1 -> 0.3
remx314 remainder 133 10 -> 3
remx315 remainder 1033 10 -> 3
remx316 remainder 1033 50 -> 33
remx317 remainder 101.0 3 -> 2.0
remx318 remainder 102.0 3 -> 0.0
remx319 remainder 103.0 3 -> 1.0
remx320 remainder 2.40 1 -> 0.40
remx321 remainder 2.400 1 -> 0.400
remx322 remainder 2.4 1 -> 0.4
remx323 remainder 2.4 2 -> 0.4
remx324 remainder 2.400 2 -> 0.400
remx325 remainder 1 0.3 -> 0.1
remx326 remainder 1 0.30 -> 0.10
remx327 remainder 1 0.300 -> 0.100
remx328 remainder 1 0.3000 -> 0.1000
remx329 remainder 1.0 0.3 -> 0.1
remx330 remainder 1.00 0.3 -> 0.10
remx331 remainder 1.000 0.3 -> 0.100
remx332 remainder 1.0000 0.3 -> 0.1000
remx333 remainder 0.5 2 -> 0.5
remx334 remainder 0.5 2.1 -> 0.5
remx335 remainder 0.5 2.01 -> 0.50
remx336 remainder 0.5 2.001 -> 0.500
remx337 remainder 0.50 2 -> 0.50
remx338 remainder 0.50 2.01 -> 0.50
remx339 remainder 0.50 2.001 -> 0.500
remx340 remainder 0.5 0.5000001 -> 0.5000000
remx341 remainder 0.5 0.50000001 -> 0.50000000
remx342 remainder 0.5 0.500000001 -> 0.500000000
remx343 remainder 0.5 0.5000000001 -> 0.500000000 Rounded
remx344 remainder 0.5 0.50000000001 -> 0.500000000 Rounded
remx345 remainder 0.5 0.4999999 -> 1E-7
remx346 remainder 0.5 0.49999999 -> 1E-8
remx347 remainder 0.5 0.499999999 -> 1E-9
remx348 remainder 0.5 0.4999999999 -> 1E-10
remx349 remainder 0.5 0.49999999999 -> 1E-11
remx350 remainder 0.5 0.499999999999 -> 1E-12
remx351 remainder 0.03 7 -> 0.03
remx352 remainder 5 2 -> 1
remx353 remainder 4.1 2 -> 0.1
remx354 remainder 4.01 2 -> 0.01
remx355 remainder 4.001 2 -> 0.001
remx356 remainder 4.0001 2 -> 0.0001
remx357 remainder 4.00001 2 -> 0.00001
remx358 remainder 4.000001 2 -> 0.000001
remx359 remainder 4.0000001 2 -> 1E-7
remx360 remainder 1.2 0.7345 -> 0.4655
remx361 remainder 0.8 12 -> 0.8
remx362 remainder 0.8 0.2 -> 0.0
remx363 remainder 0.8 0.3 -> 0.2
remx364 remainder 0.800 12 -> 0.800
remx365 remainder 0.800 1.7 -> 0.800
remx366 remainder 2.400 2 -> 0.400
precision: 6
remx371 remainder 2.400 2 -> 0.400
precision: 3
-- long operand, rounded, case
remx372 remainder 12345678900000 12e+12 -> 3.46E+11 Inexact Rounded
-- 12000000000000
precision: 5
remx381 remainder 12345 1 -> 0
remx382 remainder 12345 1.0001 -> 0.7657
remx383 remainder 12345 1.001 -> 0.668
remx384 remainder 12345 1.01 -> 0.78
remx385 remainder 12345 1.1 -> 0.8
remx386 remainder 12355 4 -> 3
remx387 remainder 12345 4 -> 1
remx388 remainder 12355 4.0001 -> 2.6912
remx389 remainder 12345 4.0001 -> 0.6914
remx390 remainder 12345 4.9 -> 1.9
remx391 remainder 12345 4.99 -> 4.73
remx392 remainder 12345 4.999 -> 2.469
remx393 remainder 12345 4.9999 -> 0.2469
remx394 remainder 12345 5 -> 0
remx395 remainder 12345 5.0001 -> 4.7532
remx396 remainder 12345 5.001 -> 2.532
remx397 remainder 12345 5.01 -> 0.36
remx398 remainder 12345 5.1 -> 3.0
precision: 9
-- the nasty division-by-1 cases
remx401 remainder 0.5 1 -> 0.5
remx402 remainder 0.55 1 -> 0.55
remx403 remainder 0.555 1 -> 0.555
remx404 remainder 0.5555 1 -> 0.5555
remx405 remainder 0.55555 1 -> 0.55555
remx406 remainder 0.555555 1 -> 0.555555
remx407 remainder 0.5555555 1 -> 0.5555555
remx408 remainder 0.55555555 1 -> 0.55555555
remx409 remainder 0.555555555 1 -> 0.555555555
-- Specials
remx680 remainder Inf -Inf -> NaN Invalid_operation
remx681 remainder Inf -1000 -> NaN Invalid_operation
remx682 remainder Inf -1 -> NaN Invalid_operation
remx683 remainder Inf 0 -> NaN Invalid_operation
remx684 remainder Inf -0 -> NaN Invalid_operation
remx685 remainder Inf 1 -> NaN Invalid_operation
remx686 remainder Inf 1000 -> NaN Invalid_operation
remx687 remainder Inf Inf -> NaN Invalid_operation
remx688 remainder -1000 Inf -> -1000
remx689 remainder -Inf Inf -> NaN Invalid_operation
remx691 remainder -1 Inf -> -1
remx692 remainder 0 Inf -> 0
remx693 remainder -0 Inf -> -0
remx694 remainder 1 Inf -> 1
remx695 remainder 1000 Inf -> 1000
remx696 remainder Inf Inf -> NaN Invalid_operation
remx700 remainder -Inf -Inf -> NaN Invalid_operation
remx701 remainder -Inf -1000 -> NaN Invalid_operation
remx702 remainder -Inf -1 -> NaN Invalid_operation
remx703 remainder -Inf -0 -> NaN Invalid_operation
remx704 remainder -Inf 0 -> NaN Invalid_operation
remx705 remainder -Inf 1 -> NaN Invalid_operation
remx706 remainder -Inf 1000 -> NaN Invalid_operation
remx707 remainder -Inf Inf -> NaN Invalid_operation
remx708 remainder -Inf -Inf -> NaN Invalid_operation
remx709 remainder -1000 Inf -> -1000
remx710 remainder -1 -Inf -> -1
remx711 remainder -0 -Inf -> -0
remx712 remainder 0 -Inf -> 0
remx713 remainder 1 -Inf -> 1
remx714 remainder 1000 -Inf -> 1000
remx715 remainder Inf -Inf -> NaN Invalid_operation
remx721 remainder NaN -Inf -> NaN
remx722 remainder NaN -1000 -> NaN
remx723 remainder NaN -1 -> NaN
remx724 remainder NaN -0 -> NaN
remx725 remainder -NaN 0 -> -NaN
remx726 remainder NaN 1 -> NaN
remx727 remainder NaN 1000 -> NaN
remx728 remainder NaN Inf -> NaN
remx729 remainder NaN -NaN -> NaN
remx730 remainder -Inf NaN -> NaN
remx731 remainder -1000 NaN -> NaN
remx732 remainder -1 NaN -> NaN
remx733 remainder -0 -NaN -> -NaN
remx734 remainder 0 NaN -> NaN
remx735 remainder 1 -NaN -> -NaN
remx736 remainder 1000 NaN -> NaN
remx737 remainder Inf NaN -> NaN
remx741 remainder sNaN -Inf -> NaN Invalid_operation
remx742 remainder sNaN -1000 -> NaN Invalid_operation
remx743 remainder -sNaN -1 -> -NaN Invalid_operation
remx744 remainder sNaN -0 -> NaN Invalid_operation
remx745 remainder sNaN 0 -> NaN Invalid_operation
remx746 remainder sNaN 1 -> NaN Invalid_operation
remx747 remainder sNaN 1000 -> NaN Invalid_operation
remx749 remainder sNaN NaN -> NaN Invalid_operation
remx750 remainder sNaN sNaN -> NaN Invalid_operation
remx751 remainder NaN sNaN -> NaN Invalid_operation
remx752 remainder -Inf sNaN -> NaN Invalid_operation
remx753 remainder -1000 sNaN -> NaN Invalid_operation
remx754 remainder -1 sNaN -> NaN Invalid_operation
remx755 remainder -0 sNaN -> NaN Invalid_operation
remx756 remainder 0 sNaN -> NaN Invalid_operation
remx757 remainder 1 sNaN -> NaN Invalid_operation
remx758 remainder 1000 sNaN -> NaN Invalid_operation
remx759 remainder Inf -sNaN -> -NaN Invalid_operation
-- propaging NaNs
remx760 remainder NaN1 NaN7 -> NaN1
remx761 remainder sNaN2 NaN8 -> NaN2 Invalid_operation
remx762 remainder NaN3 sNaN9 -> NaN9 Invalid_operation
remx763 remainder sNaN4 sNaN10 -> NaN4 Invalid_operation
remx764 remainder 15 NaN11 -> NaN11
remx765 remainder NaN6 NaN12 -> NaN6
remx766 remainder Inf NaN13 -> NaN13
remx767 remainder NaN14 -Inf -> NaN14
remx768 remainder 0 NaN15 -> NaN15
remx769 remainder NaN16 -0 -> NaN16
-- test some cases that are close to exponent overflow
maxexponent: 999999999
minexponent: -999999999
remx770 remainder 1 1e999999999 -> 1
remx771 remainder 1 0.9e999999999 -> 1
remx772 remainder 1 0.99e999999999 -> 1
remx773 remainder 1 0.999999999e999999999 -> 1
remx774 remainder 9e999999999 1 -> NaN Division_impossible
remx775 remainder 9.9e999999999 1 -> NaN Division_impossible
remx776 remainder 9.99e999999999 1 -> NaN Division_impossible
remx777 remainder 9.99999999e999999999 1 -> NaN Division_impossible
-- long operand checks
maxexponent: 999
minexponent: -999
precision: 9
remx801 remainder 12345678000 100 -> 0
remx802 remainder 1 12345678000 -> 1
remx803 remainder 1234567800 10 -> 0
remx804 remainder 1 1234567800 -> 1
remx805 remainder 1234567890 10 -> 0
remx806 remainder 1 1234567890 -> 1
remx807 remainder 1234567891 10 -> 1
remx808 remainder 1 1234567891 -> 1
remx809 remainder 12345678901 100 -> 1
remx810 remainder 1 12345678901 -> 1
remx811 remainder 1234567896 10 -> 6
remx812 remainder 1 1234567896 -> 1
precision: 15
remx821 remainder 12345678000 100 -> 0
remx822 remainder 1 12345678000 -> 1
remx823 remainder 1234567800 10 -> 0
remx824 remainder 1 1234567800 -> 1
remx825 remainder 1234567890 10 -> 0
remx826 remainder 1 1234567890 -> 1
remx827 remainder 1234567891 10 -> 1
remx828 remainder 1 1234567891 -> 1
remx829 remainder 12345678901 100 -> 1
remx830 remainder 1 12345678901 -> 1
remx831 remainder 1234567896 10 -> 6
remx832 remainder 1 1234567896 -> 1
-- worries from divideint
precision: 8
remx840 remainder 100000000.0 1 -> NaN Division_impossible
remx841 remainder 100000000.4 1 -> NaN Division_impossible
remx842 remainder 100000000.5 1 -> NaN Division_impossible
remx843 remainder 100000000.9 1 -> NaN Division_impossible
remx844 remainder 100000000.999 1 -> NaN Division_impossible
precision: 6
remx850 remainder 100000003 5 -> NaN Division_impossible
remx851 remainder 10000003 5 -> NaN Division_impossible
remx852 remainder 1000003 5 -> 3
remx853 remainder 100003 5 -> 3
remx854 remainder 10003 5 -> 3
remx855 remainder 1003 5 -> 3
remx856 remainder 103 5 -> 3
remx857 remainder 13 5 -> 3
remx858 remainder 1 5 -> 1
-- Vladimir's cases
remx860 remainder 123.0e1 10000000000000000 -> 1230
remx861 remainder 1230 10000000000000000 -> 1230
remx862 remainder 12.3e2 10000000000000000 -> 1230
remx863 remainder 1.23e3 10000000000000000 -> 1230
remx864 remainder 123e1 10000000000000000 -> 1230
remx870 remainder 123e1 1000000000000000 -> 1230
remx871 remainder 123e1 100000000000000 -> 1230
remx872 remainder 123e1 10000000000000 -> 1230
remx873 remainder 123e1 1000000000000 -> 1230
remx874 remainder 123e1 100000000000 -> 1230
remx875 remainder 123e1 10000000000 -> 1230
remx876 remainder 123e1 1000000000 -> 1230
remx877 remainder 123e1 100000000 -> 1230
remx878 remainder 1230 100000000 -> 1230
remx879 remainder 123e1 10000000 -> 1230
remx880 remainder 123e1 1000000 -> 1230
remx881 remainder 123e1 100000 -> 1230
remx882 remainder 123e1 10000 -> 1230
remx883 remainder 123e1 1000 -> 230
remx884 remainder 123e1 100 -> 30
remx885 remainder 123e1 10 -> 0
remx886 remainder 123e1 1 -> 0
remx889 remainder 123e1 20000000000000000 -> 1230
remx890 remainder 123e1 2000000000000000 -> 1230
remx891 remainder 123e1 200000000000000 -> 1230
remx892 remainder 123e1 20000000000000 -> 1230
remx893 remainder 123e1 2000000000000 -> 1230
remx894 remainder 123e1 200000000000 -> 1230
remx895 remainder 123e1 20000000000 -> 1230
remx896 remainder 123e1 2000000000 -> 1230
remx897 remainder 123e1 200000000 -> 1230
remx899 remainder 123e1 20000000 -> 1230
remx900 remainder 123e1 2000000 -> 1230
remx901 remainder 123e1 200000 -> 1230
remx902 remainder 123e1 20000 -> 1230
remx903 remainder 123e1 2000 -> 1230
remx904 remainder 123e1 200 -> 30
remx905 remainder 123e1 20 -> 10
remx906 remainder 123e1 2 -> 0
remx909 remainder 123e1 50000000000000000 -> 1230
remx910 remainder 123e1 5000000000000000 -> 1230
remx911 remainder 123e1 500000000000000 -> 1230
remx912 remainder 123e1 50000000000000 -> 1230
remx913 remainder 123e1 5000000000000 -> 1230
remx914 remainder 123e1 500000000000 -> 1230
remx915 remainder 123e1 50000000000 -> 1230
remx916 remainder 123e1 5000000000 -> 1230
remx917 remainder 123e1 500000000 -> 1230
remx919 remainder 123e1 50000000 -> 1230
remx920 remainder 123e1 5000000 -> 1230
remx921 remainder 123e1 500000 -> 1230
remx922 remainder 123e1 50000 -> 1230
remx923 remainder 123e1 5000 -> 1230
remx924 remainder 123e1 500 -> 230
remx925 remainder 123e1 50 -> 30
remx926 remainder 123e1 5 -> 0
remx929 remainder 123e1 90000000000000000 -> 1230
remx930 remainder 123e1 9000000000000000 -> 1230
remx931 remainder 123e1 900000000000000 -> 1230
remx932 remainder 123e1 90000000000000 -> 1230
remx933 remainder 123e1 9000000000000 -> 1230
remx934 remainder 123e1 900000000000 -> 1230
remx935 remainder 123e1 90000000000 -> 1230
remx936 remainder 123e1 9000000000 -> 1230
remx937 remainder 123e1 900000000 -> 1230
remx939 remainder 123e1 90000000 -> 1230
remx940 remainder 123e1 9000000 -> 1230
remx941 remainder 123e1 900000 -> 1230
remx942 remainder 123e1 90000 -> 1230
remx943 remainder 123e1 9000 -> 1230
remx944 remainder 123e1 900 -> 330
remx945 remainder 123e1 90 -> 60
remx946 remainder 123e1 9 -> 6
remx950 remainder 123e1 10000000000000000 -> 1230
remx951 remainder 123e1 100000000000000000 -> 1230
remx952 remainder 123e1 1000000000000000000 -> 1230
remx953 remainder 123e1 10000000000000000000 -> 1230
remx954 remainder 123e1 100000000000000000000 -> 1230
remx955 remainder 123e1 1000000000000000000000 -> 1230
remx956 remainder 123e1 10000000000000000000000 -> 1230
remx957 remainder 123e1 100000000000000000000000 -> 1230
remx958 remainder 123e1 1000000000000000000000000 -> 1230
remx959 remainder 123e1 10000000000000000000000000 -> 1230
remx960 remainder 123e1 19999999999999999 -> 1230
remx961 remainder 123e1 199999999999999990 -> 1230
remx962 remainder 123e1 1999999999999999999 -> 1230
remx963 remainder 123e1 19999999999999999990 -> 1230
remx964 remainder 123e1 199999999999999999999 -> 1230
remx965 remainder 123e1 1999999999999999999990 -> 1230
remx966 remainder 123e1 19999999999999999999999 -> 1230
remx967 remainder 123e1 199999999999999999999990 -> 1230
remx968 remainder 123e1 1999999999999999999999999 -> 1230
remx969 remainder 123e1 19999999999999999999999990 -> 1230
remx970 remainder 1e1 10000000000000000 -> 10
remx971 remainder 1e1 100000000000000000 -> 10
remx972 remainder 1e1 1000000000000000000 -> 10
remx973 remainder 1e1 10000000000000000000 -> 10
remx974 remainder 1e1 100000000000000000000 -> 10
remx975 remainder 1e1 1000000000000000000000 -> 10
remx976 remainder 1e1 10000000000000000000000 -> 10
remx977 remainder 1e1 100000000000000000000000 -> 10
remx978 remainder 1e1 1000000000000000000000000 -> 10
remx979 remainder 1e1 10000000000000000000000000 -> 10
remx980 remainder 123e1 1000E999999 -> 1.23E+3 -- 123E+1 internally
-- overflow and underflow tests [from divide]
precision: 9
maxexponent: 999999999
minexponent: -999999999
remx990 remainder +1.23456789012345E-0 9E+999999999 -> 1.23456789 Inexact Rounded
remx991 remainder 9E+999999999 +0.23456789012345E-0 -> NaN Division_impossible
remx992 remainder +0.100 9E+999999999 -> 0.100
remx993 remainder 9E-999999999 +9.100 -> 9E-999999999
remx995 remainder -1.23456789012345E-0 9E+999999999 -> -1.23456789 Inexact Rounded
remx996 remainder 9E+999999999 -0.83456789012345E-0 -> NaN Division_impossible
remx997 remainder -0.100 9E+999999999 -> -0.100
remx998 remainder 9E-999999999 -9.100 -> 9E-999999999
-- Null tests
remx1000 remainder 10 # -> NaN Invalid_operation
remx1001 remainder # 10 -> NaN Invalid_operation

560
sys/lib/python/test/decimaltestdata/remainderNear.decTest
View file

@ -1,560 +0,0 @@
------------------------------------------------------------------------
-- remainderNear.decTest -- decimal remainder-near (IEEE remainder) --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
extended: 1
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
rmnx001 remaindernear 1 1 -> 0
rmnx002 remaindernear 2 1 -> 0
rmnx003 remaindernear 1 2 -> 1
rmnx004 remaindernear 2 2 -> 0
rmnx005 remaindernear 0 1 -> 0
rmnx006 remaindernear 0 2 -> 0
rmnx007 remaindernear 1 3 -> 1
rmnx008 remaindernear 2 3 -> -1
rmnx009 remaindernear 3 3 -> 0
rmnx010 remaindernear 2.4 1 -> 0.4
rmnx011 remaindernear 2.4 -1 -> 0.4
rmnx012 remaindernear -2.4 1 -> -0.4
rmnx013 remaindernear -2.4 -1 -> -0.4
rmnx014 remaindernear 2.40 1 -> 0.40
rmnx015 remaindernear 2.400 1 -> 0.400
rmnx016 remaindernear 2.4 2 -> 0.4
rmnx017 remaindernear 2.400 2 -> 0.400
rmnx018 remaindernear 2. 2 -> 0
rmnx019 remaindernear 20 20 -> 0
rmnx020 remaindernear 187 187 -> 0
rmnx021 remaindernear 5 2 -> 1
rmnx022 remaindernear 5 2.0 -> 1.0
rmnx023 remaindernear 5 2.000 -> 1.000
rmnx024 remaindernear 5 0.200 -> 0.000
rmnx025 remaindernear 5 0.200 -> 0.000
rmnx030 remaindernear 1 2 -> 1
rmnx031 remaindernear 1 4 -> 1
rmnx032 remaindernear 1 8 -> 1
rmnx033 remaindernear 1 16 -> 1
rmnx034 remaindernear 1 32 -> 1
rmnx035 remaindernear 1 64 -> 1
rmnx040 remaindernear 1 -2 -> 1
rmnx041 remaindernear 1 -4 -> 1
rmnx042 remaindernear 1 -8 -> 1
rmnx043 remaindernear 1 -16 -> 1
rmnx044 remaindernear 1 -32 -> 1
rmnx045 remaindernear 1 -64 -> 1
rmnx050 remaindernear -1 2 -> -1
rmnx051 remaindernear -1 4 -> -1
rmnx052 remaindernear -1 8 -> -1
rmnx053 remaindernear -1 16 -> -1
rmnx054 remaindernear -1 32 -> -1
rmnx055 remaindernear -1 64 -> -1
rmnx060 remaindernear -1 -2 -> -1
rmnx061 remaindernear -1 -4 -> -1
rmnx062 remaindernear -1 -8 -> -1
rmnx063 remaindernear -1 -16 -> -1
rmnx064 remaindernear -1 -32 -> -1
rmnx065 remaindernear -1 -64 -> -1
rmnx066 remaindernear 999999997 1 -> 0
rmnx067 remaindernear 999999997.4 1 -> 0.4
rmnx068 remaindernear 999999997.5 1 -> -0.5
rmnx069 remaindernear 999999997.9 1 -> -0.1
rmnx070 remaindernear 999999997.999 1 -> -0.001
rmnx071 remaindernear 999999998 1 -> 0
rmnx072 remaindernear 999999998.4 1 -> 0.4
rmnx073 remaindernear 999999998.5 1 -> 0.5
rmnx074 remaindernear 999999998.9 1 -> -0.1
rmnx075 remaindernear 999999998.999 1 -> -0.001
rmnx076 remaindernear 999999999 1 -> 0
rmnx077 remaindernear 999999999.4 1 -> 0.4
rmnx078 remaindernear 999999999.5 1 -> NaN Division_impossible
rmnx079 remaindernear 999999999.9 1 -> NaN Division_impossible
rmnx080 remaindernear 999999999.999 1 -> NaN Division_impossible
precision: 6
rmnx081 remaindernear 999999999 1 -> NaN Division_impossible
rmnx082 remaindernear 99999999 1 -> NaN Division_impossible
rmnx083 remaindernear 9999999 1 -> NaN Division_impossible
rmnx084 remaindernear 999999 1 -> 0
rmnx085 remaindernear 99999 1 -> 0
rmnx086 remaindernear 9999 1 -> 0
rmnx087 remaindernear 999 1 -> 0
rmnx088 remaindernear 99 1 -> 0
rmnx089 remaindernear 9 1 -> 0
precision: 9
rmnx090 remaindernear 0. 1 -> 0
rmnx091 remaindernear .0 1 -> 0.0
rmnx092 remaindernear 0.00 1 -> 0.00
rmnx093 remaindernear 0.00E+9 1 -> 0
rmnx094 remaindernear 0.0000E-50 1 -> 0E-54
-- Various flavours of remaindernear by 0
precision: 9
maxexponent: 999999999
minexponent: -999999999
rmnx101 remaindernear 0 0 -> NaN Division_undefined
rmnx102 remaindernear 0 -0 -> NaN Division_undefined
rmnx103 remaindernear -0 0 -> NaN Division_undefined
rmnx104 remaindernear -0 -0 -> NaN Division_undefined
rmnx105 remaindernear 0.0E5 0 -> NaN Division_undefined
rmnx106 remaindernear 0.000 0 -> NaN Division_undefined
-- [Some think this next group should be Division_by_zero exception,
-- but IEEE 854 is explicit that it is Invalid operation .. for
-- remaindernear-near, anyway]
rmnx107 remaindernear 0.0001 0 -> NaN Invalid_operation
rmnx108 remaindernear 0.01 0 -> NaN Invalid_operation
rmnx109 remaindernear 0.1 0 -> NaN Invalid_operation
rmnx110 remaindernear 1 0 -> NaN Invalid_operation
rmnx111 remaindernear 1 0.0 -> NaN Invalid_operation
rmnx112 remaindernear 10 0.0 -> NaN Invalid_operation
rmnx113 remaindernear 1E+100 0.0 -> NaN Invalid_operation
rmnx114 remaindernear 1E+1000 0 -> NaN Invalid_operation
rmnx115 remaindernear 0.0001 -0 -> NaN Invalid_operation
rmnx116 remaindernear 0.01 -0 -> NaN Invalid_operation
rmnx119 remaindernear 0.1 -0 -> NaN Invalid_operation
rmnx120 remaindernear 1 -0 -> NaN Invalid_operation
rmnx121 remaindernear 1 -0.0 -> NaN Invalid_operation
rmnx122 remaindernear 10 -0.0 -> NaN Invalid_operation
rmnx123 remaindernear 1E+100 -0.0 -> NaN Invalid_operation
rmnx124 remaindernear 1E+1000 -0 -> NaN Invalid_operation
-- and zeros on left
rmnx130 remaindernear 0 1 -> 0
rmnx131 remaindernear 0 -1 -> 0
rmnx132 remaindernear 0.0 1 -> 0.0
rmnx133 remaindernear 0.0 -1 -> 0.0
rmnx134 remaindernear -0 1 -> -0
rmnx135 remaindernear -0 -1 -> -0
rmnx136 remaindernear -0.0 1 -> -0.0
rmnx137 remaindernear -0.0 -1 -> -0.0
-- 0.5ers
rmmx143 remaindernear 0.5 2 -> 0.5
rmmx144 remaindernear 0.5 2.1 -> 0.5
rmmx145 remaindernear 0.5 2.01 -> 0.50
rmmx146 remaindernear 0.5 2.001 -> 0.500
rmmx147 remaindernear 0.50 2 -> 0.50
rmmx148 remaindernear 0.50 2.01 -> 0.50
rmmx149 remaindernear 0.50 2.001 -> 0.500
-- some differences from remainder
rmnx150 remaindernear 0.4 1.020 -> 0.400
rmnx151 remaindernear 0.50 1.020 -> 0.500
rmnx152 remaindernear 0.51 1.020 -> 0.510
rmnx153 remaindernear 0.52 1.020 -> -0.500
rmnx154 remaindernear 0.6 1.020 -> -0.420
rmnx155 remaindernear 0.49 1 -> 0.49
rmnx156 remaindernear 0.50 1 -> 0.50
rmnx157 remaindernear 1.50 1 -> -0.50
rmnx158 remaindernear 2.50 1 -> 0.50
rmnx159 remaindernear 9.50 1 -> -0.50
rmnx160 remaindernear 0.51 1 -> -0.49
-- the nasty division-by-1 cases
rmnx161 remaindernear 0.4 1 -> 0.4
rmnx162 remaindernear 0.45 1 -> 0.45
rmnx163 remaindernear 0.455 1 -> 0.455
rmnx164 remaindernear 0.4555 1 -> 0.4555
rmnx165 remaindernear 0.45555 1 -> 0.45555
rmnx166 remaindernear 0.455555 1 -> 0.455555
rmnx167 remaindernear 0.4555555 1 -> 0.4555555
rmnx168 remaindernear 0.45555555 1 -> 0.45555555
rmnx169 remaindernear 0.455555555 1 -> 0.455555555
-- with spill...
rmnx171 remaindernear 0.5 1 -> 0.5
rmnx172 remaindernear 0.55 1 -> -0.45
rmnx173 remaindernear 0.555 1 -> -0.445
rmnx174 remaindernear 0.5555 1 -> -0.4445
rmnx175 remaindernear 0.55555 1 -> -0.44445
rmnx176 remaindernear 0.555555 1 -> -0.444445
rmnx177 remaindernear 0.5555555 1 -> -0.4444445
rmnx178 remaindernear 0.55555555 1 -> -0.44444445
rmnx179 remaindernear 0.555555555 1 -> -0.444444445
-- progression
rmnx180 remaindernear 1 1 -> 0
rmnx181 remaindernear 1 2 -> 1
rmnx182 remaindernear 1 3 -> 1
rmnx183 remaindernear 1 4 -> 1
rmnx184 remaindernear 1 5 -> 1
rmnx185 remaindernear 1 6 -> 1
rmnx186 remaindernear 1 7 -> 1
rmnx187 remaindernear 1 8 -> 1
rmnx188 remaindernear 1 9 -> 1
rmnx189 remaindernear 1 10 -> 1
rmnx190 remaindernear 1 1 -> 0
rmnx191 remaindernear 2 1 -> 0
rmnx192 remaindernear 3 1 -> 0
rmnx193 remaindernear 4 1 -> 0
rmnx194 remaindernear 5 1 -> 0
rmnx195 remaindernear 6 1 -> 0
rmnx196 remaindernear 7 1 -> 0
rmnx197 remaindernear 8 1 -> 0
rmnx198 remaindernear 9 1 -> 0
rmnx199 remaindernear 10 1 -> 0
-- Various flavours of remaindernear by 0
maxexponent: 999999999
minexponent: -999999999
rmnx201 remaindernear 0 0 -> NaN Division_undefined
rmnx202 remaindernear 0.0E5 0 -> NaN Division_undefined
rmnx203 remaindernear 0.000 0 -> NaN Division_undefined
rmnx204 remaindernear 0.0001 0 -> NaN Invalid_operation
rmnx205 remaindernear 0.01 0 -> NaN Invalid_operation
rmnx206 remaindernear 0.1 0 -> NaN Invalid_operation
rmnx207 remaindernear 1 0 -> NaN Invalid_operation
rmnx208 remaindernear 1 0.0 -> NaN Invalid_operation
rmnx209 remaindernear 10 0.0 -> NaN Invalid_operation
rmnx210 remaindernear 1E+100 0.0 -> NaN Invalid_operation
rmnx211 remaindernear 1E+1000 0 -> NaN Invalid_operation
-- tests from the extended specification
rmnx221 remaindernear 2.1 3 -> -0.9
rmnx222 remaindernear 10 6 -> -2
rmnx223 remaindernear 10 3 -> 1
rmnx224 remaindernear -10 3 -> -1
rmnx225 remaindernear 10.2 1 -> 0.2
rmnx226 remaindernear 10 0.3 -> 0.1
rmnx227 remaindernear 3.6 1.3 -> -0.3
-- some differences from remainder
rmnx231 remaindernear 0.4 1.020 -> 0.400
rmnx232 remaindernear 0.50 1.020 -> 0.500
rmnx233 remaindernear 0.51 1.020 -> 0.510
rmnx234 remaindernear 0.52 1.020 -> -0.500
rmnx235 remaindernear 0.6 1.020 -> -0.420
-- test some cases that are close to exponent overflow
maxexponent: 999999999
minexponent: -999999999
rmnx270 remaindernear 1 1e999999999 -> 1
rmnx271 remaindernear 1 0.9e999999999 -> 1
rmnx272 remaindernear 1 0.99e999999999 -> 1
rmnx273 remaindernear 1 0.999999999e999999999 -> 1
rmnx274 remaindernear 9e999999999 1 -> NaN Division_impossible
rmnx275 remaindernear 9.9e999999999 1 -> NaN Division_impossible
rmnx276 remaindernear 9.99e999999999 1 -> NaN Division_impossible
rmnx277 remaindernear 9.99999999e999999999 1 -> NaN Division_impossible
rmnx280 remaindernear 0.1 9e-999999999 -> NaN Division_impossible
rmnx281 remaindernear 0.1 99e-999999999 -> NaN Division_impossible
rmnx282 remaindernear 0.1 999e-999999999 -> NaN Division_impossible
rmnx283 remaindernear 0.1 9e-999999998 -> NaN Division_impossible
rmnx284 remaindernear 0.1 99e-999999998 -> NaN Division_impossible
rmnx285 remaindernear 0.1 999e-999999998 -> NaN Division_impossible
rmnx286 remaindernear 0.1 999e-999999997 -> NaN Division_impossible
rmnx287 remaindernear 0.1 9999e-999999997 -> NaN Division_impossible
rmnx288 remaindernear 0.1 99999e-999999997 -> NaN Division_impossible
-- rmnx3xx are from DiagBigDecimal
rmnx301 remaindernear 1 3 -> 1
rmnx302 remaindernear 5 5 -> 0
rmnx303 remaindernear 13 10 -> 3
rmnx304 remaindernear 13 50 -> 13
rmnx305 remaindernear 13 100 -> 13
rmnx306 remaindernear 13 1000 -> 13
rmnx307 remaindernear .13 1 -> 0.13
rmnx308 remaindernear 0.133 1 -> 0.133
rmnx309 remaindernear 0.1033 1 -> 0.1033
rmnx310 remaindernear 1.033 1 -> 0.033
rmnx311 remaindernear 10.33 1 -> 0.33
rmnx312 remaindernear 10.33 10 -> 0.33
rmnx313 remaindernear 103.3 1 -> 0.3
rmnx314 remaindernear 133 10 -> 3
rmnx315 remaindernear 1033 10 -> 3
rmnx316 remaindernear 1033 50 -> -17
rmnx317 remaindernear 101.0 3 -> -1.0
rmnx318 remaindernear 102.0 3 -> 0.0
rmnx319 remaindernear 103.0 3 -> 1.0
rmnx320 remaindernear 2.40 1 -> 0.40
rmnx321 remaindernear 2.400 1 -> 0.400
rmnx322 remaindernear 2.4 1 -> 0.4
rmnx323 remaindernear 2.4 2 -> 0.4
rmnx324 remaindernear 2.400 2 -> 0.400
rmnx325 remaindernear 1 0.3 -> 0.1
rmnx326 remaindernear 1 0.30 -> 0.10
rmnx327 remaindernear 1 0.300 -> 0.100
rmnx328 remaindernear 1 0.3000 -> 0.1000
rmnx329 remaindernear 1.0 0.3 -> 0.1
rmnx330 remaindernear 1.00 0.3 -> 0.10
rmnx331 remaindernear 1.000 0.3 -> 0.100
rmnx332 remaindernear 1.0000 0.3 -> 0.1000
rmnx333 remaindernear 0.5 2 -> 0.5
rmnx334 remaindernear 0.5 2.1 -> 0.5
rmnx335 remaindernear 0.5 2.01 -> 0.50
rmnx336 remaindernear 0.5 2.001 -> 0.500
rmnx337 remaindernear 0.50 2 -> 0.50
rmnx338 remaindernear 0.50 2.01 -> 0.50
rmnx339 remaindernear 0.50 2.001 -> 0.500
rmnx340 remaindernear 0.5 0.5000001 -> -1E-7
rmnx341 remaindernear 0.5 0.50000001 -> -1E-8
rmnx342 remaindernear 0.5 0.500000001 -> -1E-9
rmnx343 remaindernear 0.5 0.5000000001 -> -1E-10
rmnx344 remaindernear 0.5 0.50000000001 -> -1E-11
rmnx345 remaindernear 0.5 0.4999999 -> 1E-7
rmnx346 remaindernear 0.5 0.49999999 -> 1E-8
rmnx347 remaindernear 0.5 0.499999999 -> 1E-9
rmnx348 remaindernear 0.5 0.4999999999 -> 1E-10
rmnx349 remaindernear 0.5 0.49999999999 -> 1E-11
rmnx350 remaindernear 0.03 7 -> 0.03
rmnx351 remaindernear 5 2 -> 1
rmnx352 remaindernear 4.1 2 -> 0.1
rmnx353 remaindernear 4.01 2 -> 0.01
rmnx354 remaindernear 4.001 2 -> 0.001
rmnx355 remaindernear 4.0001 2 -> 0.0001
rmnx356 remaindernear 4.00001 2 -> 0.00001
rmnx357 remaindernear 4.000001 2 -> 0.000001
rmnx358 remaindernear 4.0000001 2 -> 1E-7
rmnx360 remaindernear 1.2 0.7345 -> -0.2690
rmnx361 remaindernear 0.8 12 -> 0.8
rmnx362 remaindernear 0.8 0.2 -> 0.0
rmnx363 remaindernear 0.8 0.3 -> -0.1
rmnx364 remaindernear 0.800 12 -> 0.800
rmnx365 remaindernear 0.800 1.7 -> 0.800
rmnx366 remaindernear 2.400 2 -> 0.400
precision: 6
rmnx371 remaindernear 2.400 2 -> 0.400
precision: 3
rmnx372 remaindernear 12345678900000 12e+12 -> 3.46E+11 Inexact Rounded
precision: 5
rmnx381 remaindernear 12345 1 -> 0
rmnx382 remaindernear 12345 1.0001 -> -0.2344
rmnx383 remaindernear 12345 1.001 -> -0.333
rmnx384 remaindernear 12345 1.01 -> -0.23
rmnx385 remaindernear 12345 1.1 -> -0.3
rmnx386 remaindernear 12355 4 -> -1
rmnx387 remaindernear 12345 4 -> 1
rmnx388 remaindernear 12355 4.0001 -> -1.3089
rmnx389 remaindernear 12345 4.0001 -> 0.6914
rmnx390 remaindernear 12345 4.9 -> 1.9
rmnx391 remaindernear 12345 4.99 -> -0.26
rmnx392 remaindernear 12345 4.999 -> 2.469
rmnx393 remaindernear 12345 4.9999 -> 0.2469
rmnx394 remaindernear 12345 5 -> 0
rmnx395 remaindernear 12345 5.0001 -> -0.2469
rmnx396 remaindernear 12345 5.001 -> -2.469
rmnx397 remaindernear 12345 5.01 -> 0.36
rmnx398 remaindernear 12345 5.1 -> -2.1
precision: 9
-- some nasty division-by-1 cases [some similar above]
rmnx401 remaindernear 0.4 1 -> 0.4
rmnx402 remaindernear 0.45 1 -> 0.45
rmnx403 remaindernear 0.455 1 -> 0.455
rmnx404 remaindernear 0.4555 1 -> 0.4555
rmnx405 remaindernear 0.45555 1 -> 0.45555
rmnx406 remaindernear 0.455555 1 -> 0.455555
rmnx407 remaindernear 0.4555555 1 -> 0.4555555
rmnx408 remaindernear 0.45555555 1 -> 0.45555555
rmnx409 remaindernear 0.455555555 1 -> 0.455555555
-- some tricky LHSs
rmnx420 remaindernear 99999999.999999999 1E+8 -> -1E-9
rmnx421 remaindernear 999999999.999999999 1E+9 -> -1E-9
precision: 9
rmnx430 remaindernear 0.455555555 1 -> 0.455555555
precision: 8
rmnx431 remaindernear 0.455555555 1 -> 0.45555556 Inexact Rounded
precision: 7
rmnx432 remaindernear 0.455555555 1 -> 0.4555556 Inexact Rounded
precision: 6
rmnx433 remaindernear 0.455555555 1 -> 0.455556 Inexact Rounded
precision: 5
rmnx434 remaindernear 0.455555555 1 -> 0.45556 Inexact Rounded
precision: 4
rmnx435 remaindernear 0.455555555 1 -> 0.4556 Inexact Rounded
precision: 3
rmnx436 remaindernear 0.455555555 1 -> 0.456 Inexact Rounded
precision: 2
rmnx437 remaindernear 0.455555555 1 -> 0.46 Inexact Rounded
precision: 1
rmnx438 remaindernear 0.455555555 1 -> 0.5 Inexact Rounded
-- early tests; from text descriptions
precision: 9
rmnx601 remaindernear 10 6 -> -2
rmnx602 remaindernear -10 6 -> 2
rmnx603 remaindernear 11 3 -> -1
rmnx604 remaindernear 11 5 -> 1
rmnx605 remaindernear 7.7 8 -> -0.3
rmnx606 remaindernear 31.5 3 -> 1.5 -- i=10
rmnx607 remaindernear 34.5 3 -> -1.5 -- i=11
-- Specials
rmnx680 remaindernear Inf -Inf -> NaN Invalid_operation
rmnx681 remaindernear Inf -1000 -> NaN Invalid_operation
rmnx682 remaindernear Inf -1 -> NaN Invalid_operation
rmnx683 remaindernear Inf 0 -> NaN Invalid_operation
rmnx684 remaindernear Inf -0 -> NaN Invalid_operation
rmnx685 remaindernear Inf 1 -> NaN Invalid_operation
rmnx686 remaindernear Inf 1000 -> NaN Invalid_operation
rmnx687 remaindernear Inf Inf -> NaN Invalid_operation
rmnx688 remaindernear -1000 Inf -> -1000
rmnx689 remaindernear -Inf Inf -> NaN Invalid_operation
rmnx691 remaindernear -1 Inf -> -1
rmnx692 remaindernear 0 Inf -> 0
rmnx693 remaindernear -0 Inf -> -0
rmnx694 remaindernear 1 Inf -> 1
rmnx695 remaindernear 1000 Inf -> 1000
rmnx696 remaindernear Inf Inf -> NaN Invalid_operation
rmnx700 remaindernear -Inf -Inf -> NaN Invalid_operation
rmnx701 remaindernear -Inf -1000 -> NaN Invalid_operation
rmnx702 remaindernear -Inf -1 -> NaN Invalid_operation
rmnx703 remaindernear -Inf -0 -> NaN Invalid_operation
rmnx704 remaindernear -Inf 0 -> NaN Invalid_operation
rmnx705 remaindernear -Inf 1 -> NaN Invalid_operation
rmnx706 remaindernear -Inf 1000 -> NaN Invalid_operation
rmnx707 remaindernear -Inf Inf -> NaN Invalid_operation
rmnx708 remaindernear -Inf -Inf -> NaN Invalid_operation
rmnx709 remaindernear -1000 Inf -> -1000
rmnx710 remaindernear -1 -Inf -> -1
rmnx711 remaindernear -0 -Inf -> -0
rmnx712 remaindernear 0 -Inf -> 0
rmnx713 remaindernear 1 -Inf -> 1
rmnx714 remaindernear 1000 -Inf -> 1000
rmnx715 remaindernear Inf -Inf -> NaN Invalid_operation
rmnx721 remaindernear NaN -Inf -> NaN
rmnx722 remaindernear NaN -1000 -> NaN
rmnx723 remaindernear NaN -1 -> NaN
rmnx724 remaindernear NaN -0 -> NaN
rmnx725 remaindernear NaN 0 -> NaN
rmnx726 remaindernear NaN 1 -> NaN
rmnx727 remaindernear NaN 1000 -> NaN
rmnx728 remaindernear NaN Inf -> NaN
rmnx729 remaindernear NaN NaN -> NaN
rmnx730 remaindernear -Inf NaN -> NaN
rmnx731 remaindernear -1000 NaN -> NaN
rmnx732 remaindernear -1 -NaN -> -NaN
rmnx733 remaindernear -0 NaN -> NaN
rmnx734 remaindernear 0 NaN -> NaN
rmnx735 remaindernear 1 NaN -> NaN
rmnx736 remaindernear 1000 NaN -> NaN
rmnx737 remaindernear Inf NaN -> NaN
rmnx741 remaindernear sNaN -Inf -> NaN Invalid_operation
rmnx742 remaindernear sNaN -1000 -> NaN Invalid_operation
rmnx743 remaindernear -sNaN -1 -> -NaN Invalid_operation
rmnx744 remaindernear sNaN -0 -> NaN Invalid_operation
rmnx745 remaindernear sNaN 0 -> NaN Invalid_operation
rmnx746 remaindernear sNaN 1 -> NaN Invalid_operation
rmnx747 remaindernear sNaN 1000 -> NaN Invalid_operation
rmnx749 remaindernear sNaN NaN -> NaN Invalid_operation
rmnx750 remaindernear sNaN sNaN -> NaN Invalid_operation
rmnx751 remaindernear NaN sNaN -> NaN Invalid_operation
rmnx752 remaindernear -Inf sNaN -> NaN Invalid_operation
rmnx753 remaindernear -1000 sNaN -> NaN Invalid_operation
rmnx754 remaindernear -1 sNaN -> NaN Invalid_operation
rmnx755 remaindernear -0 -sNaN -> -NaN Invalid_operation
rmnx756 remaindernear 0 sNaN -> NaN Invalid_operation
rmnx757 remaindernear 1 sNaN -> NaN Invalid_operation
rmnx758 remaindernear 1000 sNaN -> NaN Invalid_operation
rmnx759 remaindernear Inf sNaN -> NaN Invalid_operation
rmnx760 remaindernear NaN sNaN -> NaN Invalid_operation
-- propaging NaNs
rmnx761 remaindernear NaN1 NaN7 -> NaN1
rmnx762 remaindernear sNaN2 NaN8 -> NaN2 Invalid_operation
rmnx763 remaindernear NaN3 -sNaN9 -> -NaN9 Invalid_operation
rmnx764 remaindernear sNaN4 sNaN10 -> NaN4 Invalid_operation
rmnx765 remaindernear 15 NaN11 -> NaN11
rmnx766 remaindernear NaN6 NaN12 -> NaN6
rmnx767 remaindernear Inf -NaN13 -> -NaN13
rmnx768 remaindernear NaN14 -Inf -> NaN14
rmnx769 remaindernear 0 NaN15 -> NaN15
rmnx770 remaindernear -NaN16 -0 -> -NaN16
-- test some cases that are close to exponent overflow
maxexponent: 999999999
minexponent: -999999999
rmnx780 remaindernear 1 1e999999999 -> 1
rmnx781 remaindernear 1 0.9e999999999 -> 1
rmnx782 remaindernear 1 0.99e999999999 -> 1
rmnx783 remaindernear 1 0.999999999e999999999 -> 1
rmnx784 remaindernear 9e999999999 1 -> NaN Division_impossible
rmnx785 remaindernear 9.9e999999999 1 -> NaN Division_impossible
rmnx786 remaindernear 9.99e999999999 1 -> NaN Division_impossible
rmnx787 remaindernear 9.99999999e999999999 1 -> NaN Division_impossible
-- overflow and underflow tests [from divide]
precision: 9
maxexponent: 999999999
minexponent: -999999999
rmnx790 remaindernear +1.23456789012345E-0 9E+999999999 -> 1.23456789 Inexact Rounded
rmnx791 remaindernear 9E+999999999 +0.23456789012345E-0 -> NaN Division_impossible
rmnx792 remaindernear +0.100 9E+999999999 -> 0.100
rmnx793 remaindernear 9E-999999999 +9.100 -> 9E-999999999
rmnx795 remaindernear -1.23456789012345E-0 9E+999999999 -> -1.23456789 Inexact Rounded
rmnx796 remaindernear 9E+999999999 -0.83456789012345E-0 -> NaN Division_impossible
rmnx797 remaindernear -0.100 9E+999999999 -> -0.100
rmnx798 remaindernear 9E-999999999 -9.100 -> 9E-999999999
-- long operands checks
maxexponent: 999
minexponent: -999
precision: 9
rmnx801 remaindernear 12345678000 100 -> 0
rmnx802 remaindernear 1 12345678000 -> 1
rmnx803 remaindernear 1234567800 10 -> 0
rmnx804 remaindernear 1 1234567800 -> 1
rmnx805 remaindernear 1234567890 10 -> 0
rmnx806 remaindernear 1 1234567890 -> 1
rmnx807 remaindernear 1234567891 10 -> 1
rmnx808 remaindernear 1 1234567891 -> 1
rmnx809 remaindernear 12345678901 100 -> 1
rmnx810 remaindernear 1 12345678901 -> 1
rmnx811 remaindernear 1234567896 10 -> -4
rmnx812 remaindernear 1 1234567896 -> 1
precision: 15
rmnx841 remaindernear 12345678000 100 -> 0
rmnx842 remaindernear 1 12345678000 -> 1
rmnx843 remaindernear 1234567800 10 -> 0
rmnx844 remaindernear 1 1234567800 -> 1
rmnx845 remaindernear 1234567890 10 -> 0
rmnx846 remaindernear 1 1234567890 -> 1
rmnx847 remaindernear 1234567891 10 -> 1
rmnx848 remaindernear 1 1234567891 -> 1
rmnx849 remaindernear 12345678901 100 -> 1
rmnx850 remaindernear 1 12345678901 -> 1
rmnx851 remaindernear 1234567896 10 -> -4
rmnx852 remaindernear 1 1234567896 -> 1
-- Null tests
rmnx900 remaindernear 10 # -> NaN Invalid_operation
rmnx901 remaindernear # 10 -> NaN Invalid_operation

758
sys/lib/python/test/decimaltestdata/rescale.decTest
View file

@ -1,758 +0,0 @@
------------------------------------------------------------------------
-- rescale.decTest -- decimal rescale operation --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- [obsolete] Quantize.decTest has the improved version
-- 2004.03.15 Underflow for quantize is suppressed
extended: 1
precision: 9
rounding: half_up
maxExponent: 999
minexponent: -999
-- sanity checks
resx001 rescale 0 0 -> 0
resx002 rescale 1 0 -> 1
resx003 rescale 0.1 +2 -> 0E+2 Inexact Rounded
resx005 rescale 0.1 +1 -> 0E+1 Inexact Rounded
resx006 rescale 0.1 0 -> 0 Inexact Rounded
resx007 rescale 0.1 -1 -> 0.1
resx008 rescale 0.1 -2 -> 0.10
resx009 rescale 0.1 -3 -> 0.100
resx010 rescale 0.9 +2 -> 0E+2 Inexact Rounded
resx011 rescale 0.9 +1 -> 0E+1 Inexact Rounded
resx012 rescale 0.9 +0 -> 1 Inexact Rounded
resx013 rescale 0.9 -1 -> 0.9
resx014 rescale 0.9 -2 -> 0.90
resx015 rescale 0.9 -3 -> 0.900
-- negatives
resx021 rescale -0 0 -> -0
resx022 rescale -1 0 -> -1
resx023 rescale -0.1 +2 -> -0E+2 Inexact Rounded
resx025 rescale -0.1 +1 -> -0E+1 Inexact Rounded
resx026 rescale -0.1 0 -> -0 Inexact Rounded
resx027 rescale -0.1 -1 -> -0.1
resx028 rescale -0.1 -2 -> -0.10
resx029 rescale -0.1 -3 -> -0.100
resx030 rescale -0.9 +2 -> -0E+2 Inexact Rounded
resx031 rescale -0.9 +1 -> -0E+1 Inexact Rounded
resx032 rescale -0.9 +0 -> -1 Inexact Rounded
resx033 rescale -0.9 -1 -> -0.9
resx034 rescale -0.9 -2 -> -0.90
resx035 rescale -0.9 -3 -> -0.900
resx036 rescale -0.5 +2 -> -0E+2 Inexact Rounded
resx037 rescale -0.5 +1 -> -0E+1 Inexact Rounded
resx038 rescale -0.5 +0 -> -1 Inexact Rounded
resx039 rescale -0.5 -1 -> -0.5
resx040 rescale -0.5 -2 -> -0.50
resx041 rescale -0.5 -3 -> -0.500
resx042 rescale -0.9 +2 -> -0E+2 Inexact Rounded
resx043 rescale -0.9 +1 -> -0E+1 Inexact Rounded
resx044 rescale -0.9 +0 -> -1 Inexact Rounded
resx045 rescale -0.9 -1 -> -0.9
resx046 rescale -0.9 -2 -> -0.90
resx047 rescale -0.9 -3 -> -0.900
-- examples from Specification
resx060 rescale 2.17 -3 -> 2.170
resx061 rescale 2.17 -2 -> 2.17
resx062 rescale 2.17 -1 -> 2.2 Inexact Rounded
resx063 rescale 2.17 0 -> 2 Inexact Rounded
resx064 rescale 2.17 +1 -> 0E+1 Inexact Rounded
resx065 rescale 2 Inf -> NaN Invalid_operation
resx066 rescale -0.1 0 -> -0 Inexact Rounded
resx067 rescale -0 5 -> -0E+5
resx068 rescale +35236450.6 -2 -> NaN Invalid_operation
resx069 rescale -35236450.6 -2 -> NaN Invalid_operation
resx070 rescale 217 -1 -> 217.0
resx071 rescale 217 0 -> 217
resx072 rescale 217 +1 -> 2.2E+2 Inexact Rounded
resx073 rescale 217 +2 -> 2E+2 Inexact Rounded
-- general tests ..
resx089 rescale 12 +4 -> 0E+4 Inexact Rounded
resx090 rescale 12 +3 -> 0E+3 Inexact Rounded
resx091 rescale 12 +2 -> 0E+2 Inexact Rounded
resx092 rescale 12 +1 -> 1E+1 Inexact Rounded
resx093 rescale 1.2345 -2 -> 1.23 Inexact Rounded
resx094 rescale 1.2355 -2 -> 1.24 Inexact Rounded
resx095 rescale 1.2345 -6 -> 1.234500
resx096 rescale 9.9999 -2 -> 10.00 Inexact Rounded
resx097 rescale 0.0001 -2 -> 0.00 Inexact Rounded
resx098 rescale 0.001 -2 -> 0.00 Inexact Rounded
resx099 rescale 0.009 -2 -> 0.01 Inexact Rounded
resx100 rescale 92 +2 -> 1E+2 Inexact Rounded
resx101 rescale -1 0 -> -1
resx102 rescale -1 -1 -> -1.0
resx103 rescale -1 -2 -> -1.00
resx104 rescale 0 0 -> 0
resx105 rescale 0 -1 -> 0.0
resx106 rescale 0 -2 -> 0.00
resx107 rescale 0.00 0 -> 0
resx108 rescale 0 +1 -> 0E+1
resx109 rescale 0 +2 -> 0E+2
resx110 rescale +1 0 -> 1
resx111 rescale +1 -1 -> 1.0
resx112 rescale +1 -2 -> 1.00
resx120 rescale 1.04 -3 -> 1.040
resx121 rescale 1.04 -2 -> 1.04
resx122 rescale 1.04 -1 -> 1.0 Inexact Rounded
resx123 rescale 1.04 0 -> 1 Inexact Rounded
resx124 rescale 1.05 -3 -> 1.050
resx125 rescale 1.05 -2 -> 1.05
resx126 rescale 1.05 -1 -> 1.1 Inexact Rounded
resx127 rescale 1.05 0 -> 1 Inexact Rounded
resx128 rescale 1.05 -3 -> 1.050
resx129 rescale 1.05 -2 -> 1.05
resx130 rescale 1.05 -1 -> 1.1 Inexact Rounded
resx131 rescale 1.05 0 -> 1 Inexact Rounded
resx132 rescale 1.06 -3 -> 1.060
resx133 rescale 1.06 -2 -> 1.06
resx134 rescale 1.06 -1 -> 1.1 Inexact Rounded
resx135 rescale 1.06 0 -> 1 Inexact Rounded
resx140 rescale -10 -2 -> -10.00
resx141 rescale +1 -2 -> 1.00
resx142 rescale +10 -2 -> 10.00
resx143 rescale 1E+10 -2 -> NaN Invalid_operation
resx144 rescale 1E-10 -2 -> 0.00 Inexact Rounded
resx145 rescale 1E-3 -2 -> 0.00 Inexact Rounded
resx146 rescale 1E-2 -2 -> 0.01
resx147 rescale 1E-1 -2 -> 0.10
resx148 rescale 0E-10 -2 -> 0.00
resx150 rescale 1.0600 -5 -> 1.06000
resx151 rescale 1.0600 -4 -> 1.0600
resx152 rescale 1.0600 -3 -> 1.060 Rounded
resx153 rescale 1.0600 -2 -> 1.06 Rounded
resx154 rescale 1.0600 -1 -> 1.1 Inexact Rounded
resx155 rescale 1.0600 0 -> 1 Inexact Rounded
-- +ve exponents ..
resx201 rescale -1 +0 -> -1
resx202 rescale -1 +1 -> -0E+1 Inexact Rounded
resx203 rescale -1 +2 -> -0E+2 Inexact Rounded
resx204 rescale 0 +0 -> 0
resx205 rescale 0 +1 -> 0E+1
resx206 rescale 0 +2 -> 0E+2
resx207 rescale +1 +0 -> 1
resx208 rescale +1 +1 -> 0E+1 Inexact Rounded
resx209 rescale +1 +2 -> 0E+2 Inexact Rounded
resx220 rescale 1.04 +3 -> 0E+3 Inexact Rounded
resx221 rescale 1.04 +2 -> 0E+2 Inexact Rounded
resx222 rescale 1.04 +1 -> 0E+1 Inexact Rounded
resx223 rescale 1.04 +0 -> 1 Inexact Rounded
resx224 rescale 1.05 +3 -> 0E+3 Inexact Rounded
resx225 rescale 1.05 +2 -> 0E+2 Inexact Rounded
resx226 rescale 1.05 +1 -> 0E+1 Inexact Rounded
resx227 rescale 1.05 +0 -> 1 Inexact Rounded
resx228 rescale 1.05 +3 -> 0E+3 Inexact Rounded
resx229 rescale 1.05 +2 -> 0E+2 Inexact Rounded
resx230 rescale 1.05 +1 -> 0E+1 Inexact Rounded
resx231 rescale 1.05 +0 -> 1 Inexact Rounded
resx232 rescale 1.06 +3 -> 0E+3 Inexact Rounded
resx233 rescale 1.06 +2 -> 0E+2 Inexact Rounded
resx234 rescale 1.06 +1 -> 0E+1 Inexact Rounded
resx235 rescale 1.06 +0 -> 1 Inexact Rounded
resx240 rescale -10 +1 -> -1E+1 Rounded
resx241 rescale +1 +1 -> 0E+1 Inexact Rounded
resx242 rescale +10 +1 -> 1E+1 Rounded
resx243 rescale 1E+1 +1 -> 1E+1 -- underneath this is E+1
resx244 rescale 1E+2 +1 -> 1.0E+2 -- underneath this is E+1
resx245 rescale 1E+3 +1 -> 1.00E+3 -- underneath this is E+1
resx246 rescale 1E+4 +1 -> 1.000E+4 -- underneath this is E+1
resx247 rescale 1E+5 +1 -> 1.0000E+5 -- underneath this is E+1
resx248 rescale 1E+6 +1 -> 1.00000E+6 -- underneath this is E+1
resx249 rescale 1E+7 +1 -> 1.000000E+7 -- underneath this is E+1
resx250 rescale 1E+8 +1 -> 1.0000000E+8 -- underneath this is E+1
resx251 rescale 1E+9 +1 -> 1.00000000E+9 -- underneath this is E+1
-- next one tries to add 9 zeros
resx252 rescale 1E+10 +1 -> NaN Invalid_operation
resx253 rescale 1E-10 +1 -> 0E+1 Inexact Rounded
resx254 rescale 1E-2 +1 -> 0E+1 Inexact Rounded
resx255 rescale 0E-10 +1 -> 0E+1
resx256 rescale -0E-10 +1 -> -0E+1
resx257 rescale -0E-1 +1 -> -0E+1
resx258 rescale -0 +1 -> -0E+1
resx259 rescale -0E+1 +1 -> -0E+1
resx260 rescale -10 +2 -> -0E+2 Inexact Rounded
resx261 rescale +1 +2 -> 0E+2 Inexact Rounded
resx262 rescale +10 +2 -> 0E+2 Inexact Rounded
resx263 rescale 1E+1 +2 -> 0E+2 Inexact Rounded
resx264 rescale 1E+2 +2 -> 1E+2
resx265 rescale 1E+3 +2 -> 1.0E+3
resx266 rescale 1E+4 +2 -> 1.00E+4
resx267 rescale 1E+5 +2 -> 1.000E+5
resx268 rescale 1E+6 +2 -> 1.0000E+6
resx269 rescale 1E+7 +2 -> 1.00000E+7
resx270 rescale 1E+8 +2 -> 1.000000E+8
resx271 rescale 1E+9 +2 -> 1.0000000E+9
resx272 rescale 1E+10 +2 -> 1.00000000E+10
resx273 rescale 1E-10 +2 -> 0E+2 Inexact Rounded
resx274 rescale 1E-2 +2 -> 0E+2 Inexact Rounded
resx275 rescale 0E-10 +2 -> 0E+2
resx280 rescale -10 +3 -> -0E+3 Inexact Rounded
resx281 rescale +1 +3 -> 0E+3 Inexact Rounded
resx282 rescale +10 +3 -> 0E+3 Inexact Rounded
resx283 rescale 1E+1 +3 -> 0E+3 Inexact Rounded
resx284 rescale 1E+2 +3 -> 0E+3 Inexact Rounded
resx285 rescale 1E+3 +3 -> 1E+3
resx286 rescale 1E+4 +3 -> 1.0E+4
resx287 rescale 1E+5 +3 -> 1.00E+5
resx288 rescale 1E+6 +3 -> 1.000E+6
resx289 rescale 1E+7 +3 -> 1.0000E+7
resx290 rescale 1E+8 +3 -> 1.00000E+8
resx291 rescale 1E+9 +3 -> 1.000000E+9
resx292 rescale 1E+10 +3 -> 1.0000000E+10
resx293 rescale 1E-10 +3 -> 0E+3 Inexact Rounded
resx294 rescale 1E-2 +3 -> 0E+3 Inexact Rounded
resx295 rescale 0E-10 +3 -> 0E+3
-- round up from below [sign wrong in JIT compiler once]
resx300 rescale 0.0078 -5 -> 0.00780
resx301 rescale 0.0078 -4 -> 0.0078
resx302 rescale 0.0078 -3 -> 0.008 Inexact Rounded
resx303 rescale 0.0078 -2 -> 0.01 Inexact Rounded
resx304 rescale 0.0078 -1 -> 0.0 Inexact Rounded
resx305 rescale 0.0078 0 -> 0 Inexact Rounded
resx306 rescale 0.0078 +1 -> 0E+1 Inexact Rounded
resx307 rescale 0.0078 +2 -> 0E+2 Inexact Rounded
resx310 rescale -0.0078 -5 -> -0.00780
resx311 rescale -0.0078 -4 -> -0.0078
resx312 rescale -0.0078 -3 -> -0.008 Inexact Rounded
resx313 rescale -0.0078 -2 -> -0.01 Inexact Rounded
resx314 rescale -0.0078 -1 -> -0.0 Inexact Rounded
resx315 rescale -0.0078 0 -> -0 Inexact Rounded
resx316 rescale -0.0078 +1 -> -0E+1 Inexact Rounded
resx317 rescale -0.0078 +2 -> -0E+2 Inexact Rounded
resx320 rescale 0.078 -5 -> 0.07800
resx321 rescale 0.078 -4 -> 0.0780
resx322 rescale 0.078 -3 -> 0.078
resx323 rescale 0.078 -2 -> 0.08 Inexact Rounded
resx324 rescale 0.078 -1 -> 0.1 Inexact Rounded
resx325 rescale 0.078 0 -> 0 Inexact Rounded
resx326 rescale 0.078 +1 -> 0E+1 Inexact Rounded
resx327 rescale 0.078 +2 -> 0E+2 Inexact Rounded
resx330 rescale -0.078 -5 -> -0.07800
resx331 rescale -0.078 -4 -> -0.0780
resx332 rescale -0.078 -3 -> -0.078
resx333 rescale -0.078 -2 -> -0.08 Inexact Rounded
resx334 rescale -0.078 -1 -> -0.1 Inexact Rounded
resx335 rescale -0.078 0 -> -0 Inexact Rounded
resx336 rescale -0.078 +1 -> -0E+1 Inexact Rounded
resx337 rescale -0.078 +2 -> -0E+2 Inexact Rounded
resx340 rescale 0.78 -5 -> 0.78000
resx341 rescale 0.78 -4 -> 0.7800
resx342 rescale 0.78 -3 -> 0.780
resx343 rescale 0.78 -2 -> 0.78
resx344 rescale 0.78 -1 -> 0.8 Inexact Rounded
resx345 rescale 0.78 0 -> 1 Inexact Rounded
resx346 rescale 0.78 +1 -> 0E+1 Inexact Rounded
resx347 rescale 0.78 +2 -> 0E+2 Inexact Rounded
resx350 rescale -0.78 -5 -> -0.78000
resx351 rescale -0.78 -4 -> -0.7800
resx352 rescale -0.78 -3 -> -0.780
resx353 rescale -0.78 -2 -> -0.78
resx354 rescale -0.78 -1 -> -0.8 Inexact Rounded
resx355 rescale -0.78 0 -> -1 Inexact Rounded
resx356 rescale -0.78 +1 -> -0E+1 Inexact Rounded
resx357 rescale -0.78 +2 -> -0E+2 Inexact Rounded
resx360 rescale 7.8 -5 -> 7.80000
resx361 rescale 7.8 -4 -> 7.8000
resx362 rescale 7.8 -3 -> 7.800
resx363 rescale 7.8 -2 -> 7.80
resx364 rescale 7.8 -1 -> 7.8
resx365 rescale 7.8 0 -> 8 Inexact Rounded
resx366 rescale 7.8 +1 -> 1E+1 Inexact Rounded
resx367 rescale 7.8 +2 -> 0E+2 Inexact Rounded
resx368 rescale 7.8 +3 -> 0E+3 Inexact Rounded
resx370 rescale -7.8 -5 -> -7.80000
resx371 rescale -7.8 -4 -> -7.8000
resx372 rescale -7.8 -3 -> -7.800
resx373 rescale -7.8 -2 -> -7.80
resx374 rescale -7.8 -1 -> -7.8
resx375 rescale -7.8 0 -> -8 Inexact Rounded
resx376 rescale -7.8 +1 -> -1E+1 Inexact Rounded
resx377 rescale -7.8 +2 -> -0E+2 Inexact Rounded
resx378 rescale -7.8 +3 -> -0E+3 Inexact Rounded
-- some individuals
precision: 9
resx380 rescale 352364.506 -2 -> 352364.51 Inexact Rounded
resx381 rescale 3523645.06 -2 -> 3523645.06
resx382 rescale 35236450.6 -2 -> NaN Invalid_operation
resx383 rescale 352364506 -2 -> NaN Invalid_operation
resx384 rescale -352364.506 -2 -> -352364.51 Inexact Rounded
resx385 rescale -3523645.06 -2 -> -3523645.06
resx386 rescale -35236450.6 -2 -> NaN Invalid_operation
resx387 rescale -352364506 -2 -> NaN Invalid_operation
rounding: down
resx389 rescale 35236450.6 -2 -> NaN Invalid_operation
-- ? should that one instead have been:
-- resx389 rescale 35236450.6 -2 -> NaN Invalid_operation
rounding: half_up
-- and a few more from e-mail discussions
precision: 7
resx391 rescale 12.34567 -3 -> 12.346 Inexact Rounded
resx392 rescale 123.4567 -3 -> 123.457 Inexact Rounded
resx393 rescale 1234.567 -3 -> 1234.567
resx394 rescale 12345.67 -3 -> NaN Invalid_operation
resx395 rescale 123456.7 -3 -> NaN Invalid_operation
resx396 rescale 1234567. -3 -> NaN Invalid_operation
-- some 9999 round-up cases
precision: 9
resx400 rescale 9.999 -5 -> 9.99900
resx401 rescale 9.999 -4 -> 9.9990
resx402 rescale 9.999 -3 -> 9.999
resx403 rescale 9.999 -2 -> 10.00 Inexact Rounded
resx404 rescale 9.999 -1 -> 10.0 Inexact Rounded
resx405 rescale 9.999 0 -> 10 Inexact Rounded
resx406 rescale 9.999 1 -> 1E+1 Inexact Rounded
resx407 rescale 9.999 2 -> 0E+2 Inexact Rounded
resx410 rescale 0.999 -5 -> 0.99900
resx411 rescale 0.999 -4 -> 0.9990
resx412 rescale 0.999 -3 -> 0.999
resx413 rescale 0.999 -2 -> 1.00 Inexact Rounded
resx414 rescale 0.999 -1 -> 1.0 Inexact Rounded
resx415 rescale 0.999 0 -> 1 Inexact Rounded
resx416 rescale 0.999 1 -> 0E+1 Inexact Rounded
resx420 rescale 0.0999 -5 -> 0.09990
resx421 rescale 0.0999 -4 -> 0.0999
resx422 rescale 0.0999 -3 -> 0.100 Inexact Rounded
resx423 rescale 0.0999 -2 -> 0.10 Inexact Rounded
resx424 rescale 0.0999 -1 -> 0.1 Inexact Rounded
resx425 rescale 0.0999 0 -> 0 Inexact Rounded
resx426 rescale 0.0999 1 -> 0E+1 Inexact Rounded
resx430 rescale 0.00999 -5 -> 0.00999
resx431 rescale 0.00999 -4 -> 0.0100 Inexact Rounded
resx432 rescale 0.00999 -3 -> 0.010 Inexact Rounded
resx433 rescale 0.00999 -2 -> 0.01 Inexact Rounded
resx434 rescale 0.00999 -1 -> 0.0 Inexact Rounded
resx435 rescale 0.00999 0 -> 0 Inexact Rounded
resx436 rescale 0.00999 1 -> 0E+1 Inexact Rounded
resx440 rescale 0.000999 -5 -> 0.00100 Inexact Rounded
resx441 rescale 0.000999 -4 -> 0.0010 Inexact Rounded
resx442 rescale 0.000999 -3 -> 0.001 Inexact Rounded
resx443 rescale 0.000999 -2 -> 0.00 Inexact Rounded
resx444 rescale 0.000999 -1 -> 0.0 Inexact Rounded
resx445 rescale 0.000999 0 -> 0 Inexact Rounded
resx446 rescale 0.000999 1 -> 0E+1 Inexact Rounded
precision: 8
resx449 rescale 9.999E-15 -23 -> NaN Invalid_operation
resx450 rescale 9.999E-15 -22 -> 9.9990000E-15
resx451 rescale 9.999E-15 -21 -> 9.999000E-15
resx452 rescale 9.999E-15 -20 -> 9.99900E-15
resx453 rescale 9.999E-15 -19 -> 9.9990E-15
resx454 rescale 9.999E-15 -18 -> 9.999E-15
resx455 rescale 9.999E-15 -17 -> 1.000E-14 Inexact Rounded
resx456 rescale 9.999E-15 -16 -> 1.00E-14 Inexact Rounded
resx457 rescale 9.999E-15 -15 -> 1.0E-14 Inexact Rounded
resx458 rescale 9.999E-15 -14 -> 1E-14 Inexact Rounded
resx459 rescale 9.999E-15 -13 -> 0E-13 Inexact Rounded
resx460 rescale 9.999E-15 -12 -> 0E-12 Inexact Rounded
resx461 rescale 9.999E-15 -11 -> 0E-11 Inexact Rounded
resx462 rescale 9.999E-15 -10 -> 0E-10 Inexact Rounded
resx463 rescale 9.999E-15 -9 -> 0E-9 Inexact Rounded
resx464 rescale 9.999E-15 -8 -> 0E-8 Inexact Rounded
resx465 rescale 9.999E-15 -7 -> 0E-7 Inexact Rounded
resx466 rescale 9.999E-15 -6 -> 0.000000 Inexact Rounded
resx467 rescale 9.999E-15 -5 -> 0.00000 Inexact Rounded
resx468 rescale 9.999E-15 -4 -> 0.0000 Inexact Rounded
resx469 rescale 9.999E-15 -3 -> 0.000 Inexact Rounded
resx470 rescale 9.999E-15 -2 -> 0.00 Inexact Rounded
resx471 rescale 9.999E-15 -1 -> 0.0 Inexact Rounded
resx472 rescale 9.999E-15 0 -> 0 Inexact Rounded
resx473 rescale 9.999E-15 1 -> 0E+1 Inexact Rounded
-- long operand checks [rhs checks removed]
maxexponent: 999
minexponent: -999
precision: 9
resx481 rescale 12345678000 +3 -> 1.2345678E+10 Rounded
resx482 rescale 1234567800 +1 -> 1.23456780E+9 Rounded
resx483 rescale 1234567890 +1 -> 1.23456789E+9 Rounded
resx484 rescale 1234567891 +1 -> 1.23456789E+9 Inexact Rounded
resx485 rescale 12345678901 +2 -> 1.23456789E+10 Inexact Rounded
resx486 rescale 1234567896 +1 -> 1.23456790E+9 Inexact Rounded
-- a potential double-round
resx487 rescale 1234.987643 -4 -> 1234.9876 Inexact Rounded
resx488 rescale 1234.987647 -4 -> 1234.9876 Inexact Rounded
precision: 15
resx491 rescale 12345678000 +3 -> 1.2345678E+10 Rounded
resx492 rescale 1234567800 +1 -> 1.23456780E+9 Rounded
resx493 rescale 1234567890 +1 -> 1.23456789E+9 Rounded
resx494 rescale 1234567891 +1 -> 1.23456789E+9 Inexact Rounded
resx495 rescale 12345678901 +2 -> 1.23456789E+10 Inexact Rounded
resx496 rescale 1234567896 +1 -> 1.23456790E+9 Inexact Rounded
resx497 rescale 1234.987643 -4 -> 1234.9876 Inexact Rounded
resx498 rescale 1234.987647 -4 -> 1234.9876 Inexact Rounded
-- Zeros
resx500 rescale 0 1 -> 0E+1
resx501 rescale 0 0 -> 0
resx502 rescale 0 -1 -> 0.0
resx503 rescale 0.0 -1 -> 0.0
resx504 rescale 0.0 0 -> 0
resx505 rescale 0.0 +1 -> 0E+1
resx506 rescale 0E+1 -1 -> 0.0
resx507 rescale 0E+1 0 -> 0
resx508 rescale 0E+1 +1 -> 0E+1
resx509 rescale -0 1 -> -0E+1
resx510 rescale -0 0 -> -0
resx511 rescale -0 -1 -> -0.0
resx512 rescale -0.0 -1 -> -0.0
resx513 rescale -0.0 0 -> -0
resx514 rescale -0.0 +1 -> -0E+1
resx515 rescale -0E+1 -1 -> -0.0
resx516 rescale -0E+1 0 -> -0
resx517 rescale -0E+1 +1 -> -0E+1
-- Suspicious RHS values
maxexponent: 999999999
minexponent: -999999999
precision: 15
resx520 rescale 1.234 999999E+3 -> 0E+999999000 Inexact Rounded
resx521 rescale 123.456 999999E+3 -> 0E+999999000 Inexact Rounded
resx522 rescale 1.234 999999999 -> 0E+999999999 Inexact Rounded
resx523 rescale 123.456 999999999 -> 0E+999999999 Inexact Rounded
resx524 rescale 123.456 1000000000 -> NaN Invalid_operation
resx525 rescale 123.456 12345678903 -> NaN Invalid_operation
-- next four are "won't fit" overflows
resx526 rescale 1.234 -999999E+3 -> NaN Invalid_operation
resx527 rescale 123.456 -999999E+3 -> NaN Invalid_operation
resx528 rescale 1.234 -999999999 -> NaN Invalid_operation
resx529 rescale 123.456 -999999999 -> NaN Invalid_operation
resx530 rescale 123.456 -1000000014 -> NaN Invalid_operation
resx531 rescale 123.456 -12345678903 -> NaN Invalid_operation
maxexponent: 999
minexponent: -999
precision: 15
resx532 rescale 1.234E+999 999 -> 1E+999 Inexact Rounded
resx533 rescale 1.234E+998 999 -> 0E+999 Inexact Rounded
resx534 rescale 1.234 999 -> 0E+999 Inexact Rounded
resx535 rescale 1.234 1000 -> NaN Invalid_operation
resx536 rescale 1.234 5000 -> NaN Invalid_operation
resx537 rescale 0 -999 -> 0E-999
-- next two are "won't fit" overflows
resx538 rescale 1.234 -999 -> NaN Invalid_operation
resx539 rescale 1.234 -1000 -> NaN Invalid_operation
resx540 rescale 1.234 -5000 -> NaN Invalid_operation
-- [more below]
-- check bounds (lhs maybe out of range for destination, etc.)
precision: 7
resx541 rescale 1E+999 +999 -> 1E+999
resx542 rescale 1E+1000 +999 -> NaN Invalid_operation
resx543 rescale 1E+999 +1000 -> NaN Invalid_operation
resx544 rescale 1E-999 -999 -> 1E-999
resx545 rescale 1E-1000 -999 -> 0E-999 Inexact Rounded
resx546 rescale 1E-999 -1000 -> 1.0E-999
resx547 rescale 1E-1005 -999 -> 0E-999 Inexact Rounded
resx548 rescale 1E-1006 -999 -> 0E-999 Inexact Rounded
resx549 rescale 1E-1007 -999 -> 0E-999 Inexact Rounded
resx550 rescale 1E-998 -1005 -> NaN Invalid_operation -- won't fit
resx551 rescale 1E-999 -1005 -> 1.000000E-999
resx552 rescale 1E-1000 -1005 -> 1.00000E-1000 Subnormal
resx553 rescale 1E-999 -1006 -> NaN Invalid_operation
resx554 rescale 1E-999 -1007 -> NaN Invalid_operation
-- related subnormal rounding
resx555 rescale 1.666666E-999 -1005 -> 1.666666E-999
resx556 rescale 1.666666E-1000 -1005 -> 1.66667E-1000 Subnormal Inexact Rounded
resx557 rescale 1.666666E-1001 -1005 -> 1.6667E-1001 Subnormal Inexact Rounded
resx558 rescale 1.666666E-1002 -1005 -> 1.667E-1002 Subnormal Inexact Rounded
resx559 rescale 1.666666E-1003 -1005 -> 1.67E-1003 Subnormal Inexact Rounded
resx560 rescale 1.666666E-1004 -1005 -> 1.7E-1004 Subnormal Inexact Rounded
resx561 rescale 1.666666E-1005 -1005 -> 2E-1005 Subnormal Inexact Rounded
resx562 rescale 1.666666E-1006 -1005 -> 0E-1005 Inexact Rounded
resx563 rescale 1.666666E-1007 -1005 -> 0E-1005 Inexact Rounded
-- fractional RHS, some good and some bad
precision: 9
resx564 rescale 222 +2.0 -> 2E+2 Inexact Rounded
resx565 rescale 222 +2.00000000 -> 2E+2 Inexact Rounded
resx566 rescale 222 +2.00100000000 -> NaN Invalid_operation
resx567 rescale 222 +2.000001 -> NaN Invalid_operation
resx568 rescale 222 +2.000000001 -> NaN Invalid_operation
resx569 rescale 222 +2.0000000001 -> NaN Invalid_operation
resx570 rescale 222 +2.00000000001 -> NaN Invalid_operation
resx571 rescale 222 +2.99999999999 -> NaN Invalid_operation
resx572 rescale 222 -2.00000000 -> 222.00
resx573 rescale 222 -2.00100000000 -> NaN Invalid_operation
resx574 rescale 222 -2.0000001000 -> NaN Invalid_operation
resx575 rescale 222 -2.00000000001 -> NaN Invalid_operation
resx576 rescale 222 -2.99999999999 -> NaN Invalid_operation
-- Specials
resx580 rescale Inf -Inf -> Infinity
resx581 rescale Inf -1000 -> NaN Invalid_operation
resx582 rescale Inf -1 -> NaN Invalid_operation
resx583 rescale Inf 0 -> NaN Invalid_operation
resx584 rescale Inf 1 -> NaN Invalid_operation
resx585 rescale Inf 1000 -> NaN Invalid_operation
resx586 rescale Inf Inf -> Infinity
resx587 rescale -1000 Inf -> NaN Invalid_operation
resx588 rescale -Inf Inf -> -Infinity
resx589 rescale -1 Inf -> NaN Invalid_operation
resx590 rescale 0 Inf -> NaN Invalid_operation
resx591 rescale 1 Inf -> NaN Invalid_operation
resx592 rescale 1000 Inf -> NaN Invalid_operation
resx593 rescale Inf Inf -> Infinity
resx594 rescale Inf -0 -> NaN Invalid_operation
resx595 rescale -0 Inf -> NaN Invalid_operation
resx600 rescale -Inf -Inf -> -Infinity
resx601 rescale -Inf -1000 -> NaN Invalid_operation
resx602 rescale -Inf -1 -> NaN Invalid_operation
resx603 rescale -Inf 0 -> NaN Invalid_operation
resx604 rescale -Inf 1 -> NaN Invalid_operation
resx605 rescale -Inf 1000 -> NaN Invalid_operation
resx606 rescale -Inf Inf -> -Infinity
resx607 rescale -1000 Inf -> NaN Invalid_operation
resx608 rescale -Inf -Inf -> -Infinity
resx609 rescale -1 -Inf -> NaN Invalid_operation
resx610 rescale 0 -Inf -> NaN Invalid_operation
resx611 rescale 1 -Inf -> NaN Invalid_operation
resx612 rescale 1000 -Inf -> NaN Invalid_operation
resx613 rescale Inf -Inf -> Infinity
resx614 rescale -Inf -0 -> NaN Invalid_operation
resx615 rescale -0 -Inf -> NaN Invalid_operation
resx621 rescale NaN -Inf -> NaN
resx622 rescale NaN -1000 -> NaN
resx623 rescale NaN -1 -> NaN
resx624 rescale NaN 0 -> NaN
resx625 rescale NaN 1 -> NaN
resx626 rescale NaN 1000 -> NaN
resx627 rescale NaN Inf -> NaN
resx628 rescale NaN NaN -> NaN
resx629 rescale -Inf NaN -> NaN
resx630 rescale -1000 NaN -> NaN
resx631 rescale -1 NaN -> NaN
resx632 rescale 0 NaN -> NaN
resx633 rescale 1 -NaN -> -NaN
resx634 rescale 1000 NaN -> NaN
resx635 rescale Inf NaN -> NaN
resx636 rescale NaN -0 -> NaN
resx637 rescale -0 NaN -> NaN
resx641 rescale sNaN -Inf -> NaN Invalid_operation
resx642 rescale sNaN -1000 -> NaN Invalid_operation
resx643 rescale sNaN -1 -> NaN Invalid_operation
resx644 rescale sNaN 0 -> NaN Invalid_operation
resx645 rescale sNaN 1 -> NaN Invalid_operation
resx646 rescale sNaN 1000 -> NaN Invalid_operation
resx647 rescale -sNaN NaN -> -NaN Invalid_operation
resx648 rescale sNaN -sNaN -> NaN Invalid_operation
resx649 rescale NaN sNaN -> NaN Invalid_operation
resx650 rescale -Inf sNaN -> NaN Invalid_operation
resx651 rescale -1000 sNaN -> NaN Invalid_operation
resx652 rescale -1 sNaN -> NaN Invalid_operation
resx653 rescale 0 sNaN -> NaN Invalid_operation
resx654 rescale 1 -sNaN -> -NaN Invalid_operation
resx655 rescale 1000 sNaN -> NaN Invalid_operation
resx656 rescale Inf sNaN -> NaN Invalid_operation
resx657 rescale NaN sNaN -> NaN Invalid_operation
resx658 rescale sNaN -0 -> NaN Invalid_operation
resx659 rescale -0 sNaN -> NaN Invalid_operation
-- propagating NaNs
resx661 rescale NaN9 -Inf -> NaN9
resx662 rescale NaN81 919 -> NaN81
resx663 rescale NaN72 Inf -> NaN72
resx664 rescale -NaN66 NaN5 -> -NaN66
resx665 rescale -Inf NaN4 -> NaN4
resx666 rescale -919 NaN32 -> NaN32
resx667 rescale Inf NaN2 -> NaN2
resx671 rescale sNaN99 -Inf -> NaN99 Invalid_operation
resx672 rescale -sNaN98 -11 -> -NaN98 Invalid_operation
resx673 rescale sNaN97 NaN -> NaN97 Invalid_operation
resx674 rescale sNaN16 sNaN94 -> NaN16 Invalid_operation
resx675 rescale NaN95 sNaN93 -> NaN93 Invalid_operation
resx676 rescale -Inf sNaN92 -> NaN92 Invalid_operation
resx677 rescale 088 -sNaN91 -> -NaN91 Invalid_operation
resx678 rescale Inf -sNaN90 -> -NaN90 Invalid_operation
resx679 rescale NaN sNaN87 -> NaN87 Invalid_operation
-- subnormals and underflow
precision: 4
maxexponent: 999
minexponent: -999
resx710 rescale 1.00E-999 -999 -> 1E-999 Rounded
resx711 rescale 0.1E-999 -1000 -> 1E-1000 Subnormal
resx712 rescale 0.10E-999 -1000 -> 1E-1000 Subnormal Rounded
resx713 rescale 0.100E-999 -1000 -> 1E-1000 Subnormal Rounded
resx714 rescale 0.01E-999 -1001 -> 1E-1001 Subnormal
-- next is rounded to Emin
resx715 rescale 0.999E-999 -999 -> 1E-999 Inexact Rounded
resx716 rescale 0.099E-999 -1000 -> 1E-1000 Inexact Rounded Subnormal
resx717 rescale 0.009E-999 -1001 -> 1E-1001 Inexact Rounded Subnormal
resx718 rescale 0.001E-999 -1001 -> 0E-1001 Inexact Rounded
resx719 rescale 0.0009E-999 -1001 -> 0E-1001 Inexact Rounded
resx720 rescale 0.0001E-999 -1001 -> 0E-1001 Inexact Rounded
resx730 rescale -1.00E-999 -999 -> -1E-999 Rounded
resx731 rescale -0.1E-999 -999 -> -0E-999 Rounded Inexact
resx732 rescale -0.10E-999 -999 -> -0E-999 Rounded Inexact
resx733 rescale -0.100E-999 -999 -> -0E-999 Rounded Inexact
resx734 rescale -0.01E-999 -999 -> -0E-999 Inexact Rounded
-- next is rounded to Emin
resx735 rescale -0.999E-999 -999 -> -1E-999 Inexact Rounded
resx736 rescale -0.099E-999 -999 -> -0E-999 Inexact Rounded
resx737 rescale -0.009E-999 -999 -> -0E-999 Inexact Rounded
resx738 rescale -0.001E-999 -999 -> -0E-999 Inexact Rounded
resx739 rescale -0.0001E-999 -999 -> -0E-999 Inexact Rounded
resx740 rescale -1.00E-999 -1000 -> -1.0E-999 Rounded
resx741 rescale -0.1E-999 -1000 -> -1E-1000 Subnormal
resx742 rescale -0.10E-999 -1000 -> -1E-1000 Subnormal Rounded
resx743 rescale -0.100E-999 -1000 -> -1E-1000 Subnormal Rounded
resx744 rescale -0.01E-999 -1000 -> -0E-1000 Inexact Rounded
-- next is rounded to Emin
resx745 rescale -0.999E-999 -1000 -> -1.0E-999 Inexact Rounded
resx746 rescale -0.099E-999 -1000 -> -1E-1000 Inexact Rounded Subnormal
resx747 rescale -0.009E-999 -1000 -> -0E-1000 Inexact Rounded
resx748 rescale -0.001E-999 -1000 -> -0E-1000 Inexact Rounded
resx749 rescale -0.0001E-999 -1000 -> -0E-1000 Inexact Rounded
resx750 rescale -1.00E-999 -1001 -> -1.00E-999
resx751 rescale -0.1E-999 -1001 -> -1.0E-1000 Subnormal
resx752 rescale -0.10E-999 -1001 -> -1.0E-1000 Subnormal
resx753 rescale -0.100E-999 -1001 -> -1.0E-1000 Subnormal Rounded
resx754 rescale -0.01E-999 -1001 -> -1E-1001 Subnormal
-- next is rounded to Emin
resx755 rescale -0.999E-999 -1001 -> -1.00E-999 Inexact Rounded
resx756 rescale -0.099E-999 -1001 -> -1.0E-1000 Inexact Rounded Subnormal
resx757 rescale -0.009E-999 -1001 -> -1E-1001 Inexact Rounded Subnormal
resx758 rescale -0.001E-999 -1001 -> -0E-1001 Inexact Rounded
resx759 rescale -0.0001E-999 -1001 -> -0E-1001 Inexact Rounded
resx760 rescale -1.00E-999 -1002 -> -1.000E-999
resx761 rescale -0.1E-999 -1002 -> -1.00E-1000 Subnormal
resx762 rescale -0.10E-999 -1002 -> -1.00E-1000 Subnormal
resx763 rescale -0.100E-999 -1002 -> -1.00E-1000 Subnormal
resx764 rescale -0.01E-999 -1002 -> -1.0E-1001 Subnormal
resx765 rescale -0.999E-999 -1002 -> -9.99E-1000 Subnormal
resx766 rescale -0.099E-999 -1002 -> -9.9E-1001 Subnormal
resx767 rescale -0.009E-999 -1002 -> -9E-1002 Subnormal
resx768 rescale -0.001E-999 -1002 -> -1E-1002 Subnormal
resx769 rescale -0.0001E-999 -1002 -> -0E-1002 Inexact Rounded
-- rhs must be no less than Etiny
resx770 rescale -1.00E-999 -1003 -> NaN Invalid_operation
resx771 rescale -0.1E-999 -1003 -> NaN Invalid_operation
resx772 rescale -0.10E-999 -1003 -> NaN Invalid_operation
resx773 rescale -0.100E-999 -1003 -> NaN Invalid_operation
resx774 rescale -0.01E-999 -1003 -> NaN Invalid_operation
resx775 rescale -0.999E-999 -1003 -> NaN Invalid_operation
resx776 rescale -0.099E-999 -1003 -> NaN Invalid_operation
resx777 rescale -0.009E-999 -1003 -> NaN Invalid_operation
resx778 rescale -0.001E-999 -1003 -> NaN Invalid_operation
resx779 rescale -0.0001E-999 -1003 -> NaN Invalid_operation
precision: 9
maxExponent: 999999999
minexponent: -999999999
-- getInt worries
resx801 rescale 0 1000000000 -> NaN Invalid_operation
resx802 rescale 0 -1000000000 -> 0E-1000000000
resx803 rescale 0 2000000000 -> NaN Invalid_operation
resx804 rescale 0 -2000000000 -> NaN Invalid_operation
resx805 rescale 0 3000000000 -> NaN Invalid_operation
resx806 rescale 0 -3000000000 -> NaN Invalid_operation
resx807 rescale 0 4000000000 -> NaN Invalid_operation
resx808 rescale 0 -4000000000 -> NaN Invalid_operation
resx809 rescale 0 5000000000 -> NaN Invalid_operation
resx810 rescale 0 -5000000000 -> NaN Invalid_operation
resx811 rescale 0 6000000000 -> NaN Invalid_operation
resx812 rescale 0 -6000000000 -> NaN Invalid_operation
resx813 rescale 0 7000000000 -> NaN Invalid_operation
resx814 rescale 0 -7000000000 -> NaN Invalid_operation
resx815 rescale 0 8000000000 -> NaN Invalid_operation
resx816 rescale 0 -8000000000 -> NaN Invalid_operation
resx817 rescale 0 9000000000 -> NaN Invalid_operation
resx818 rescale 0 -9000000000 -> NaN Invalid_operation
resx819 rescale 0 9999999999 -> NaN Invalid_operation
resx820 rescale 0 -9999999999 -> NaN Invalid_operation
resx821 rescale 0 10000000000 -> NaN Invalid_operation
resx822 rescale 0 -10000000000 -> NaN Invalid_operation
resx831 rescale 1 0E-1 -> 1
resx832 rescale 1 0E-2 -> 1
resx833 rescale 1 0E-3 -> 1
resx834 rescale 1 0E-4 -> 1
resx835 rescale 1 0E-100 -> 1
resx836 rescale 1 0E-100000 -> 1
resx837 rescale 1 0E+100 -> 1
resx838 rescale 1 0E+100000 -> 1
resx841 rescale 0 5E-1000000 -> NaN Invalid_operation
resx842 rescale 0 5E-1000000 -> NaN Invalid_operation
resx843 rescale 0 999999999 -> 0E+999999999
resx844 rescale 0 1000000000 -> NaN Invalid_operation
resx845 rescale 0 -999999999 -> 0E-999999999
resx846 rescale 0 -1000000000 -> 0E-1000000000
resx847 rescale 0 -1000000001 -> 0E-1000000001
resx848 rescale 0 -1000000002 -> 0E-1000000002
resx849 rescale 0 -1000000003 -> 0E-1000000003
resx850 rescale 0 -1000000004 -> 0E-1000000004
resx851 rescale 0 -1000000005 -> 0E-1000000005
resx852 rescale 0 -1000000006 -> 0E-1000000006
resx853 rescale 0 -1000000007 -> 0E-1000000007
resx854 rescale 0 -1000000008 -> NaN Invalid_operation
resx861 rescale 1 +2147483649 -> NaN Invalid_operation
resx862 rescale 1 +2147483648 -> NaN Invalid_operation
resx863 rescale 1 +2147483647 -> NaN Invalid_operation
resx864 rescale 1 -2147483647 -> NaN Invalid_operation
resx865 rescale 1 -2147483648 -> NaN Invalid_operation
resx866 rescale 1 -2147483649 -> NaN Invalid_operation
-- Null tests
res900 rescale 10 # -> NaN Invalid_operation
res901 rescale # 10 -> NaN Invalid_operation

1079
sys/lib/python/test/decimaltestdata/rounding.decTest
View file

File diff suppressed because it is too large Load diff

353
sys/lib/python/test/decimaltestdata/samequantum.decTest
View file

@ -1,353 +0,0 @@
------------------------------------------------------------------------
-- samequantum.decTest -- check quantums match --
-- Copyright (c) IBM Corporation, 2001, 2003. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
extended: 1
precision: 9
rounding: half_up
maxExponent: 999
minExponent: -999
samq001 samequantum 0 0 -> 1
samq002 samequantum 0 1 -> 1
samq003 samequantum 1 0 -> 1
samq004 samequantum 1 1 -> 1
samq011 samequantum 10 1E+1 -> 0
samq012 samequantum 10E+1 10E+1 -> 1
samq013 samequantum 100 10E+1 -> 0
samq014 samequantum 100 1E+2 -> 0
samq015 samequantum 0.1 1E-2 -> 0
samq016 samequantum 0.1 1E-1 -> 1
samq017 samequantum 0.1 1E-0 -> 0
samq018 samequantum 999 999 -> 1
samq019 samequantum 999E-1 99.9 -> 1
samq020 samequantum 111E-1 22.2 -> 1
samq021 samequantum 111E-1 1234.2 -> 1
-- zeros
samq030 samequantum 0.0 1.1 -> 1
samq031 samequantum 0.0 1.11 -> 0
samq032 samequantum 0.0 0 -> 0
samq033 samequantum 0.0 0.0 -> 1
samq034 samequantum 0.0 0.00 -> 0
samq035 samequantum 0E+1 0E+0 -> 0
samq036 samequantum 0E+1 0E+1 -> 1
samq037 samequantum 0E+1 0E+2 -> 0
samq038 samequantum 0E-17 0E-16 -> 0
samq039 samequantum 0E-17 0E-17 -> 1
samq040 samequantum 0E-17 0E-18 -> 0
samq041 samequantum 0E-17 0.0E-15 -> 0
samq042 samequantum 0E-17 0.0E-16 -> 1
samq043 samequantum 0E-17 0.0E-17 -> 0
samq044 samequantum -0E-17 0.0E-16 -> 1
samq045 samequantum 0E-17 -0.0E-17 -> 0
samq046 samequantum 0E-17 -0.0E-16 -> 1
samq047 samequantum -0E-17 0.0E-17 -> 0
samq048 samequantum -0E-17 -0.0E-16 -> 1
samq049 samequantum -0E-17 -0.0E-17 -> 0
-- specials & combinations
samq0110 samequantum -Inf -Inf -> 1
samq0111 samequantum -Inf Inf -> 1
samq0112 samequantum -Inf NaN -> 0
samq0113 samequantum -Inf -7E+3 -> 0
samq0114 samequantum -Inf -7 -> 0
samq0115 samequantum -Inf -7E-3 -> 0
samq0116 samequantum -Inf -0E-3 -> 0
samq0117 samequantum -Inf -0 -> 0
samq0118 samequantum -Inf -0E+3 -> 0
samq0119 samequantum -Inf 0E-3 -> 0
samq0120 samequantum -Inf 0 -> 0
samq0121 samequantum -Inf 0E+3 -> 0
samq0122 samequantum -Inf 7E-3 -> 0
samq0123 samequantum -Inf 7 -> 0
samq0124 samequantum -Inf 7E+3 -> 0
samq0125 samequantum -Inf sNaN -> 0
samq0210 samequantum Inf -Inf -> 1
samq0211 samequantum Inf Inf -> 1
samq0212 samequantum Inf NaN -> 0
samq0213 samequantum Inf -7E+3 -> 0
samq0214 samequantum Inf -7 -> 0
samq0215 samequantum Inf -7E-3 -> 0
samq0216 samequantum Inf -0E-3 -> 0
samq0217 samequantum Inf -0 -> 0
samq0218 samequantum Inf -0E+3 -> 0
samq0219 samequantum Inf 0E-3 -> 0
samq0220 samequantum Inf 0 -> 0
samq0221 samequantum Inf 0E+3 -> 0
samq0222 samequantum Inf 7E-3 -> 0
samq0223 samequantum Inf 7 -> 0
samq0224 samequantum Inf 7E+3 -> 0
samq0225 samequantum Inf sNaN -> 0
samq0310 samequantum NaN -Inf -> 0
samq0311 samequantum NaN Inf -> 0
samq0312 samequantum NaN NaN -> 1
samq0313 samequantum NaN -7E+3 -> 0
samq0314 samequantum NaN -7 -> 0
samq0315 samequantum NaN -7E-3 -> 0
samq0316 samequantum NaN -0E-3 -> 0
samq0317 samequantum NaN -0 -> 0
samq0318 samequantum NaN -0E+3 -> 0
samq0319 samequantum NaN 0E-3 -> 0
samq0320 samequantum NaN 0 -> 0
samq0321 samequantum NaN 0E+3 -> 0
samq0322 samequantum NaN 7E-3 -> 0
samq0323 samequantum NaN 7 -> 0
samq0324 samequantum NaN 7E+3 -> 0
samq0325 samequantum NaN sNaN -> 1
samq0410 samequantum -7E+3 -Inf -> 0
samq0411 samequantum -7E+3 Inf -> 0
samq0412 samequantum -7E+3 NaN -> 0
samq0413 samequantum -7E+3 -7E+3 -> 1
samq0414 samequantum -7E+3 -7 -> 0
samq0415 samequantum -7E+3 -7E-3 -> 0
samq0416 samequantum -7E+3 -0E-3 -> 0
samq0417 samequantum -7E+3 -0 -> 0
samq0418 samequantum -7E+3 -0E+3 -> 1
samq0419 samequantum -7E+3 0E-3 -> 0
samq0420 samequantum -7E+3 0 -> 0
samq0421 samequantum -7E+3 0E+3 -> 1
samq0422 samequantum -7E+3 7E-3 -> 0
samq0423 samequantum -7E+3 7 -> 0
samq0424 samequantum -7E+3 7E+3 -> 1
samq0425 samequantum -7E+3 sNaN -> 0
samq0510 samequantum -7 -Inf -> 0
samq0511 samequantum -7 Inf -> 0
samq0512 samequantum -7 NaN -> 0
samq0513 samequantum -7 -7E+3 -> 0
samq0514 samequantum -7 -7 -> 1
samq0515 samequantum -7 -7E-3 -> 0
samq0516 samequantum -7 -0E-3 -> 0
samq0517 samequantum -7 -0 -> 1
samq0518 samequantum -7 -0E+3 -> 0
samq0519 samequantum -7 0E-3 -> 0
samq0520 samequantum -7 0 -> 1
samq0521 samequantum -7 0E+3 -> 0
samq0522 samequantum -7 7E-3 -> 0
samq0523 samequantum -7 7 -> 1
samq0524 samequantum -7 7E+3 -> 0
samq0525 samequantum -7 sNaN -> 0
samq0610 samequantum -7E-3 -Inf -> 0
samq0611 samequantum -7E-3 Inf -> 0
samq0612 samequantum -7E-3 NaN -> 0
samq0613 samequantum -7E-3 -7E+3 -> 0
samq0614 samequantum -7E-3 -7 -> 0
samq0615 samequantum -7E-3 -7E-3 -> 1
samq0616 samequantum -7E-3 -0E-3 -> 1
samq0617 samequantum -7E-3 -0 -> 0
samq0618 samequantum -7E-3 -0E+3 -> 0
samq0619 samequantum -7E-3 0E-3 -> 1
samq0620 samequantum -7E-3 0 -> 0
samq0621 samequantum -7E-3 0E+3 -> 0
samq0622 samequantum -7E-3 7E-3 -> 1
samq0623 samequantum -7E-3 7 -> 0
samq0624 samequantum -7E-3 7E+3 -> 0
samq0625 samequantum -7E-3 sNaN -> 0
samq0710 samequantum -0E-3 -Inf -> 0
samq0711 samequantum -0E-3 Inf -> 0
samq0712 samequantum -0E-3 NaN -> 0
samq0713 samequantum -0E-3 -7E+3 -> 0
samq0714 samequantum -0E-3 -7 -> 0
samq0715 samequantum -0E-3 -7E-3 -> 1
samq0716 samequantum -0E-3 -0E-3 -> 1
samq0717 samequantum -0E-3 -0 -> 0
samq0718 samequantum -0E-3 -0E+3 -> 0
samq0719 samequantum -0E-3 0E-3 -> 1
samq0720 samequantum -0E-3 0 -> 0
samq0721 samequantum -0E-3 0E+3 -> 0
samq0722 samequantum -0E-3 7E-3 -> 1
samq0723 samequantum -0E-3 7 -> 0
samq0724 samequantum -0E-3 7E+3 -> 0
samq0725 samequantum -0E-3 sNaN -> 0
samq0810 samequantum -0 -Inf -> 0
samq0811 samequantum -0 Inf -> 0
samq0812 samequantum -0 NaN -> 0
samq0813 samequantum -0 -7E+3 -> 0
samq0814 samequantum -0 -7 -> 1
samq0815 samequantum -0 -7E-3 -> 0
samq0816 samequantum -0 -0E-3 -> 0
samq0817 samequantum -0 -0 -> 1
samq0818 samequantum -0 -0E+3 -> 0
samq0819 samequantum -0 0E-3 -> 0
samq0820 samequantum -0 0 -> 1
samq0821 samequantum -0 0E+3 -> 0
samq0822 samequantum -0 7E-3 -> 0
samq0823 samequantum -0 7 -> 1
samq0824 samequantum -0 7E+3 -> 0
samq0825 samequantum -0 sNaN -> 0
samq0910 samequantum -0E+3 -Inf -> 0
samq0911 samequantum -0E+3 Inf -> 0
samq0912 samequantum -0E+3 NaN -> 0
samq0913 samequantum -0E+3 -7E+3 -> 1
samq0914 samequantum -0E+3 -7 -> 0
samq0915 samequantum -0E+3 -7E-3 -> 0
samq0916 samequantum -0E+3 -0E-3 -> 0
samq0917 samequantum -0E+3 -0 -> 0
samq0918 samequantum -0E+3 -0E+3 -> 1
samq0919 samequantum -0E+3 0E-3 -> 0
samq0920 samequantum -0E+3 0 -> 0
samq0921 samequantum -0E+3 0E+3 -> 1
samq0922 samequantum -0E+3 7E-3 -> 0
samq0923 samequantum -0E+3 7 -> 0
samq0924 samequantum -0E+3 7E+3 -> 1
samq0925 samequantum -0E+3 sNaN -> 0
samq1110 samequantum 0E-3 -Inf -> 0
samq1111 samequantum 0E-3 Inf -> 0
samq1112 samequantum 0E-3 NaN -> 0
samq1113 samequantum 0E-3 -7E+3 -> 0
samq1114 samequantum 0E-3 -7 -> 0
samq1115 samequantum 0E-3 -7E-3 -> 1
samq1116 samequantum 0E-3 -0E-3 -> 1
samq1117 samequantum 0E-3 -0 -> 0
samq1118 samequantum 0E-3 -0E+3 -> 0
samq1119 samequantum 0E-3 0E-3 -> 1
samq1120 samequantum 0E-3 0 -> 0
samq1121 samequantum 0E-3 0E+3 -> 0
samq1122 samequantum 0E-3 7E-3 -> 1
samq1123 samequantum 0E-3 7 -> 0
samq1124 samequantum 0E-3 7E+3 -> 0
samq1125 samequantum 0E-3 sNaN -> 0
samq1210 samequantum 0 -Inf -> 0
samq1211 samequantum 0 Inf -> 0
samq1212 samequantum 0 NaN -> 0
samq1213 samequantum 0 -7E+3 -> 0
samq1214 samequantum 0 -7 -> 1
samq1215 samequantum 0 -7E-3 -> 0
samq1216 samequantum 0 -0E-3 -> 0
samq1217 samequantum 0 -0 -> 1
samq1218 samequantum 0 -0E+3 -> 0
samq1219 samequantum 0 0E-3 -> 0
samq1220 samequantum 0 0 -> 1
samq1221 samequantum 0 0E+3 -> 0
samq1222 samequantum 0 7E-3 -> 0
samq1223 samequantum 0 7 -> 1
samq1224 samequantum 0 7E+3 -> 0
samq1225 samequantum 0 sNaN -> 0
samq1310 samequantum 0E+3 -Inf -> 0
samq1311 samequantum 0E+3 Inf -> 0
samq1312 samequantum 0E+3 NaN -> 0
samq1313 samequantum 0E+3 -7E+3 -> 1
samq1314 samequantum 0E+3 -7 -> 0
samq1315 samequantum 0E+3 -7E-3 -> 0
samq1316 samequantum 0E+3 -0E-3 -> 0
samq1317 samequantum 0E+3 -0 -> 0
samq1318 samequantum 0E+3 -0E+3 -> 1
samq1319 samequantum 0E+3 0E-3 -> 0
samq1320 samequantum 0E+3 0 -> 0
samq1321 samequantum 0E+3 0E+3 -> 1
samq1322 samequantum 0E+3 7E-3 -> 0
samq1323 samequantum 0E+3 7 -> 0
samq1324 samequantum 0E+3 7E+3 -> 1
samq1325 samequantum 0E+3 sNaN -> 0
samq1410 samequantum 7E-3 -Inf -> 0
samq1411 samequantum 7E-3 Inf -> 0
samq1412 samequantum 7E-3 NaN -> 0
samq1413 samequantum 7E-3 -7E+3 -> 0
samq1414 samequantum 7E-3 -7 -> 0
samq1415 samequantum 7E-3 -7E-3 -> 1
samq1416 samequantum 7E-3 -0E-3 -> 1
samq1417 samequantum 7E-3 -0 -> 0
samq1418 samequantum 7E-3 -0E+3 -> 0
samq1419 samequantum 7E-3 0E-3 -> 1
samq1420 samequantum 7E-3 0 -> 0
samq1421 samequantum 7E-3 0E+3 -> 0
samq1422 samequantum 7E-3 7E-3 -> 1
samq1423 samequantum 7E-3 7 -> 0
samq1424 samequantum 7E-3 7E+3 -> 0
samq1425 samequantum 7E-3 sNaN -> 0
samq1510 samequantum 7 -Inf -> 0
samq1511 samequantum 7 Inf -> 0
samq1512 samequantum 7 NaN -> 0
samq1513 samequantum 7 -7E+3 -> 0
samq1514 samequantum 7 -7 -> 1
samq1515 samequantum 7 -7E-3 -> 0
samq1516 samequantum 7 -0E-3 -> 0
samq1517 samequantum 7 -0 -> 1
samq1518 samequantum 7 -0E+3 -> 0
samq1519 samequantum 7 0E-3 -> 0
samq1520 samequantum 7 0 -> 1
samq1521 samequantum 7 0E+3 -> 0
samq1522 samequantum 7 7E-3 -> 0
samq1523 samequantum 7 7 -> 1
samq1524 samequantum 7 7E+3 -> 0
samq1525 samequantum 7 sNaN -> 0
samq1610 samequantum 7E+3 -Inf -> 0
samq1611 samequantum 7E+3 Inf -> 0
samq1612 samequantum 7E+3 NaN -> 0
samq1613 samequantum 7E+3 -7E+3 -> 1
samq1614 samequantum 7E+3 -7 -> 0
samq1615 samequantum 7E+3 -7E-3 -> 0
samq1616 samequantum 7E+3 -0E-3 -> 0
samq1617 samequantum 7E+3 -0 -> 0
samq1618 samequantum 7E+3 -0E+3 -> 1
samq1619 samequantum 7E+3 0E-3 -> 0
samq1620 samequantum 7E+3 0 -> 0
samq1621 samequantum 7E+3 0E+3 -> 1
samq1622 samequantum 7E+3 7E-3 -> 0
samq1623 samequantum 7E+3 7 -> 0
samq1624 samequantum 7E+3 7E+3 -> 1
samq1625 samequantum 7E+3 sNaN -> 0
samq1710 samequantum sNaN -Inf -> 0
samq1711 samequantum sNaN Inf -> 0
samq1712 samequantum sNaN NaN -> 1
samq1713 samequantum sNaN -7E+3 -> 0
samq1714 samequantum sNaN -7 -> 0
samq1715 samequantum sNaN -7E-3 -> 0
samq1716 samequantum sNaN -0E-3 -> 0
samq1717 samequantum sNaN -0 -> 0
samq1718 samequantum sNaN -0E+3 -> 0
samq1719 samequantum sNaN 0E-3 -> 0
samq1720 samequantum sNaN 0 -> 0
samq1721 samequantum sNaN 0E+3 -> 0
samq1722 samequantum sNaN 7E-3 -> 0
samq1723 samequantum sNaN 7 -> 0
samq1724 samequantum sNaN 7E+3 -> 0
samq1725 samequantum sNaN sNaN -> 1
-- noisy NaNs
samq1730 samequantum sNaN3 sNaN3 -> 1
samq1731 samequantum sNaN3 sNaN4 -> 1
samq1732 samequantum NaN3 NaN3 -> 1
samq1733 samequantum NaN3 NaN4 -> 1
samq1734 samequantum sNaN3 3 -> 0
samq1735 samequantum NaN3 3 -> 0
samq1736 samequantum 4 sNaN4 -> 0
samq1737 samequantum 3 NaN3 -> 0
samq1738 samequantum Inf sNaN4 -> 0
samq1739 samequantum -Inf NaN3 -> 0

2958
sys/lib/python/test/decimaltestdata/squareroot.decTest
View file

File diff suppressed because it is too large Load diff

863
sys/lib/python/test/decimaltestdata/subtract.decTest
View file

@ -1,863 +0,0 @@
------------------------------------------------------------------------
-- subtract.decTest -- decimal subtraction --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
extended: 1
precision: 9
rounding: half_up
maxExponent: 384
minexponent: -383
-- [first group are 'quick confidence check']
subx001 subtract 0 0 -> '0'
subx002 subtract 1 1 -> '0'
subx003 subtract 1 2 -> '-1'
subx004 subtract 2 1 -> '1'
subx005 subtract 2 2 -> '0'
subx006 subtract 3 2 -> '1'
subx007 subtract 2 3 -> '-1'
subx011 subtract -0 0 -> '-0'
subx012 subtract -1 1 -> '-2'
subx013 subtract -1 2 -> '-3'
subx014 subtract -2 1 -> '-3'
subx015 subtract -2 2 -> '-4'
subx016 subtract -3 2 -> '-5'
subx017 subtract -2 3 -> '-5'
subx021 subtract 0 -0 -> '0'
subx022 subtract 1 -1 -> '2'
subx023 subtract 1 -2 -> '3'
subx024 subtract 2 -1 -> '3'
subx025 subtract 2 -2 -> '4'
subx026 subtract 3 -2 -> '5'
subx027 subtract 2 -3 -> '5'
subx030 subtract 11 1 -> 10
subx031 subtract 10 1 -> 9
subx032 subtract 9 1 -> 8
subx033 subtract 1 1 -> 0
subx034 subtract 0 1 -> -1
subx035 subtract -1 1 -> -2
subx036 subtract -9 1 -> -10
subx037 subtract -10 1 -> -11
subx038 subtract -11 1 -> -12
subx040 subtract '5.75' '3.3' -> '2.45'
subx041 subtract '5' '-3' -> '8'
subx042 subtract '-5' '-3' -> '-2'
subx043 subtract '-7' '2.5' -> '-9.5'
subx044 subtract '0.7' '0.3' -> '0.4'
subx045 subtract '1.3' '0.3' -> '1.0'
subx046 subtract '1.25' '1.25' -> '0.00'
subx050 subtract '1.23456789' '1.00000000' -> '0.23456789'
subx051 subtract '1.23456789' '1.00000089' -> '0.23456700'
subx052 subtract '0.5555555559' '0.0000000001' -> '0.555555556' Inexact Rounded
subx053 subtract '0.5555555559' '0.0000000005' -> '0.555555555' Inexact Rounded
subx054 subtract '0.4444444444' '0.1111111111' -> '0.333333333' Inexact Rounded
subx055 subtract '1.0000000000' '0.00000001' -> '0.999999990' Rounded
subx056 subtract '0.4444444444999' '0' -> '0.444444444' Inexact Rounded
subx057 subtract '0.4444444445000' '0' -> '0.444444445' Inexact Rounded
subx060 subtract '70' '10000e+9' -> '-1.00000000E+13' Inexact Rounded
subx061 subtract '700' '10000e+9' -> '-1.00000000E+13' Inexact Rounded
subx062 subtract '7000' '10000e+9' -> '-9.99999999E+12' Inexact Rounded
subx063 subtract '70000' '10000e+9' -> '-9.99999993E+12' Rounded
subx064 subtract '700000' '10000e+9' -> '-9.99999930E+12' Rounded
-- symmetry:
subx065 subtract '10000e+9' '70' -> '1.00000000E+13' Inexact Rounded
subx066 subtract '10000e+9' '700' -> '1.00000000E+13' Inexact Rounded
subx067 subtract '10000e+9' '7000' -> '9.99999999E+12' Inexact Rounded
subx068 subtract '10000e+9' '70000' -> '9.99999993E+12' Rounded
subx069 subtract '10000e+9' '700000' -> '9.99999930E+12' Rounded
-- change precision
subx080 subtract '10000e+9' '70000' -> '9.99999993E+12' Rounded
precision: 6
subx081 subtract '10000e+9' '70000' -> '1.00000E+13' Inexact Rounded
precision: 9
-- some of the next group are really constructor tests
subx090 subtract '00.0' '0.0' -> '0.0'
subx091 subtract '00.0' '0.00' -> '0.00'
subx092 subtract '0.00' '00.0' -> '0.00'
subx093 subtract '00.0' '0.00' -> '0.00'
subx094 subtract '0.00' '00.0' -> '0.00'
subx095 subtract '3' '.3' -> '2.7'
subx096 subtract '3.' '.3' -> '2.7'
subx097 subtract '3.0' '.3' -> '2.7'
subx098 subtract '3.00' '.3' -> '2.70'
subx099 subtract '3' '3' -> '0'
subx100 subtract '3' '+3' -> '0'
subx101 subtract '3' '-3' -> '6'
subx102 subtract '3' '0.3' -> '2.7'
subx103 subtract '3.' '0.3' -> '2.7'
subx104 subtract '3.0' '0.3' -> '2.7'
subx105 subtract '3.00' '0.3' -> '2.70'
subx106 subtract '3' '3.0' -> '0.0'
subx107 subtract '3' '+3.0' -> '0.0'
subx108 subtract '3' '-3.0' -> '6.0'
-- the above all from add; massaged and extended. Now some new ones...
-- [particularly important for comparisons]
-- NB: -xE-8 below were non-exponents pre-ANSI X3-274, and -1E-7 or 0E-7
-- with input rounding.
subx120 subtract '10.23456784' '10.23456789' -> '-5E-8'
subx121 subtract '10.23456785' '10.23456789' -> '-4E-8'
subx122 subtract '10.23456786' '10.23456789' -> '-3E-8'
subx123 subtract '10.23456787' '10.23456789' -> '-2E-8'
subx124 subtract '10.23456788' '10.23456789' -> '-1E-8'
subx125 subtract '10.23456789' '10.23456789' -> '0E-8'
subx126 subtract '10.23456790' '10.23456789' -> '1E-8'
subx127 subtract '10.23456791' '10.23456789' -> '2E-8'
subx128 subtract '10.23456792' '10.23456789' -> '3E-8'
subx129 subtract '10.23456793' '10.23456789' -> '4E-8'
subx130 subtract '10.23456794' '10.23456789' -> '5E-8'
subx131 subtract '10.23456781' '10.23456786' -> '-5E-8'
subx132 subtract '10.23456782' '10.23456786' -> '-4E-8'
subx133 subtract '10.23456783' '10.23456786' -> '-3E-8'
subx134 subtract '10.23456784' '10.23456786' -> '-2E-8'
subx135 subtract '10.23456785' '10.23456786' -> '-1E-8'
subx136 subtract '10.23456786' '10.23456786' -> '0E-8'
subx137 subtract '10.23456787' '10.23456786' -> '1E-8'
subx138 subtract '10.23456788' '10.23456786' -> '2E-8'
subx139 subtract '10.23456789' '10.23456786' -> '3E-8'
subx140 subtract '10.23456790' '10.23456786' -> '4E-8'
subx141 subtract '10.23456791' '10.23456786' -> '5E-8'
subx142 subtract '1' '0.999999999' -> '1E-9'
subx143 subtract '0.999999999' '1' -> '-1E-9'
subx144 subtract '-10.23456780' '-10.23456786' -> '6E-8'
subx145 subtract '-10.23456790' '-10.23456786' -> '-4E-8'
subx146 subtract '-10.23456791' '-10.23456786' -> '-5E-8'
precision: 3
subx150 subtract '12345678900000' '9999999999999' -> 2.35E+12 Inexact Rounded
subx151 subtract '9999999999999' '12345678900000' -> -2.35E+12 Inexact Rounded
precision: 6
subx152 subtract '12345678900000' '9999999999999' -> 2.34568E+12 Inexact Rounded
subx153 subtract '9999999999999' '12345678900000' -> -2.34568E+12 Inexact Rounded
precision: 9
subx154 subtract '12345678900000' '9999999999999' -> 2.34567890E+12 Inexact Rounded
subx155 subtract '9999999999999' '12345678900000' -> -2.34567890E+12 Inexact Rounded
precision: 12
subx156 subtract '12345678900000' '9999999999999' -> 2.34567890000E+12 Inexact Rounded
subx157 subtract '9999999999999' '12345678900000' -> -2.34567890000E+12 Inexact Rounded
precision: 15
subx158 subtract '12345678900000' '9999999999999' -> 2345678900001
subx159 subtract '9999999999999' '12345678900000' -> -2345678900001
precision: 9
-- additional scaled arithmetic tests [0.97 problem]
subx160 subtract '0' '.1' -> '-0.1'
subx161 subtract '00' '.97983' -> '-0.97983'
subx162 subtract '0' '.9' -> '-0.9'
subx163 subtract '0' '0.102' -> '-0.102'
subx164 subtract '0' '.4' -> '-0.4'
subx165 subtract '0' '.307' -> '-0.307'
subx166 subtract '0' '.43822' -> '-0.43822'
subx167 subtract '0' '.911' -> '-0.911'
subx168 subtract '.0' '.02' -> '-0.02'
subx169 subtract '00' '.392' -> '-0.392'
subx170 subtract '0' '.26' -> '-0.26'
subx171 subtract '0' '0.51' -> '-0.51'
subx172 subtract '0' '.2234' -> '-0.2234'
subx173 subtract '0' '.2' -> '-0.2'
subx174 subtract '.0' '.0008' -> '-0.0008'
-- 0. on left
subx180 subtract '0.0' '-.1' -> '0.1'
subx181 subtract '0.00' '-.97983' -> '0.97983'
subx182 subtract '0.0' '-.9' -> '0.9'
subx183 subtract '0.0' '-0.102' -> '0.102'
subx184 subtract '0.0' '-.4' -> '0.4'
subx185 subtract '0.0' '-.307' -> '0.307'
subx186 subtract '0.0' '-.43822' -> '0.43822'
subx187 subtract '0.0' '-.911' -> '0.911'
subx188 subtract '0.0' '-.02' -> '0.02'
subx189 subtract '0.00' '-.392' -> '0.392'
subx190 subtract '0.0' '-.26' -> '0.26'
subx191 subtract '0.0' '-0.51' -> '0.51'
subx192 subtract '0.0' '-.2234' -> '0.2234'
subx193 subtract '0.0' '-.2' -> '0.2'
subx194 subtract '0.0' '-.0008' -> '0.0008'
-- negatives of same
subx200 subtract '0' '-.1' -> '0.1'
subx201 subtract '00' '-.97983' -> '0.97983'
subx202 subtract '0' '-.9' -> '0.9'
subx203 subtract '0' '-0.102' -> '0.102'
subx204 subtract '0' '-.4' -> '0.4'
subx205 subtract '0' '-.307' -> '0.307'
subx206 subtract '0' '-.43822' -> '0.43822'
subx207 subtract '0' '-.911' -> '0.911'
subx208 subtract '.0' '-.02' -> '0.02'
subx209 subtract '00' '-.392' -> '0.392'
subx210 subtract '0' '-.26' -> '0.26'
subx211 subtract '0' '-0.51' -> '0.51'
subx212 subtract '0' '-.2234' -> '0.2234'
subx213 subtract '0' '-.2' -> '0.2'
subx214 subtract '.0' '-.0008' -> '0.0008'
-- more fixed, LHS swaps [really the same as testcases under add]
subx220 subtract '-56267E-12' 0 -> '-5.6267E-8'
subx221 subtract '-56267E-11' 0 -> '-5.6267E-7'
subx222 subtract '-56267E-10' 0 -> '-0.0000056267'
subx223 subtract '-56267E-9' 0 -> '-0.000056267'
subx224 subtract '-56267E-8' 0 -> '-0.00056267'
subx225 subtract '-56267E-7' 0 -> '-0.0056267'
subx226 subtract '-56267E-6' 0 -> '-0.056267'
subx227 subtract '-56267E-5' 0 -> '-0.56267'
subx228 subtract '-56267E-2' 0 -> '-562.67'
subx229 subtract '-56267E-1' 0 -> '-5626.7'
subx230 subtract '-56267E-0' 0 -> '-56267'
-- symmetry ...
subx240 subtract 0 '-56267E-12' -> '5.6267E-8'
subx241 subtract 0 '-56267E-11' -> '5.6267E-7'
subx242 subtract 0 '-56267E-10' -> '0.0000056267'
subx243 subtract 0 '-56267E-9' -> '0.000056267'
subx244 subtract 0 '-56267E-8' -> '0.00056267'
subx245 subtract 0 '-56267E-7' -> '0.0056267'
subx246 subtract 0 '-56267E-6' -> '0.056267'
subx247 subtract 0 '-56267E-5' -> '0.56267'
subx248 subtract 0 '-56267E-2' -> '562.67'
subx249 subtract 0 '-56267E-1' -> '5626.7'
subx250 subtract 0 '-56267E-0' -> '56267'
-- now some more from the 'new' add
precision: 9
subx301 subtract '1.23456789' '1.00000000' -> '0.23456789'
subx302 subtract '1.23456789' '1.00000011' -> '0.23456778'
subx311 subtract '0.4444444444' '0.5555555555' -> '-0.111111111' Inexact Rounded
subx312 subtract '0.4444444440' '0.5555555555' -> '-0.111111112' Inexact Rounded
subx313 subtract '0.4444444444' '0.5555555550' -> '-0.111111111' Inexact Rounded
subx314 subtract '0.44444444449' '0' -> '0.444444444' Inexact Rounded
subx315 subtract '0.444444444499' '0' -> '0.444444444' Inexact Rounded
subx316 subtract '0.4444444444999' '0' -> '0.444444444' Inexact Rounded
subx317 subtract '0.4444444445000' '0' -> '0.444444445' Inexact Rounded
subx318 subtract '0.4444444445001' '0' -> '0.444444445' Inexact Rounded
subx319 subtract '0.444444444501' '0' -> '0.444444445' Inexact Rounded
subx320 subtract '0.44444444451' '0' -> '0.444444445' Inexact Rounded
-- some carrying effects
subx321 subtract '0.9998' '0.0000' -> '0.9998'
subx322 subtract '0.9998' '0.0001' -> '0.9997'
subx323 subtract '0.9998' '0.0002' -> '0.9996'
subx324 subtract '0.9998' '0.0003' -> '0.9995'
subx325 subtract '0.9998' '-0.0000' -> '0.9998'
subx326 subtract '0.9998' '-0.0001' -> '0.9999'
subx327 subtract '0.9998' '-0.0002' -> '1.0000'
subx328 subtract '0.9998' '-0.0003' -> '1.0001'
subx330 subtract '70' '10000e+9' -> '-1.00000000E+13' Inexact Rounded
subx331 subtract '700' '10000e+9' -> '-1.00000000E+13' Inexact Rounded
subx332 subtract '7000' '10000e+9' -> '-9.99999999E+12' Inexact Rounded
subx333 subtract '70000' '10000e+9' -> '-9.99999993E+12' Rounded
subx334 subtract '700000' '10000e+9' -> '-9.99999930E+12' Rounded
subx335 subtract '7000000' '10000e+9' -> '-9.99999300E+12' Rounded
-- symmetry:
subx340 subtract '10000e+9' '70' -> '1.00000000E+13' Inexact Rounded
subx341 subtract '10000e+9' '700' -> '1.00000000E+13' Inexact Rounded
subx342 subtract '10000e+9' '7000' -> '9.99999999E+12' Inexact Rounded
subx343 subtract '10000e+9' '70000' -> '9.99999993E+12' Rounded
subx344 subtract '10000e+9' '700000' -> '9.99999930E+12' Rounded
subx345 subtract '10000e+9' '7000000' -> '9.99999300E+12' Rounded
-- same, higher precision
precision: 15
subx346 subtract '10000e+9' '7' -> '9999999999993'
subx347 subtract '10000e+9' '70' -> '9999999999930'
subx348 subtract '10000e+9' '700' -> '9999999999300'
subx349 subtract '10000e+9' '7000' -> '9999999993000'
subx350 subtract '10000e+9' '70000' -> '9999999930000'
subx351 subtract '10000e+9' '700000' -> '9999999300000'
subx352 subtract '7' '10000e+9' -> '-9999999999993'
subx353 subtract '70' '10000e+9' -> '-9999999999930'
subx354 subtract '700' '10000e+9' -> '-9999999999300'
subx355 subtract '7000' '10000e+9' -> '-9999999993000'
subx356 subtract '70000' '10000e+9' -> '-9999999930000'
subx357 subtract '700000' '10000e+9' -> '-9999999300000'
-- zero preservation
precision: 6
subx360 subtract '10000e+9' '70000' -> '1.00000E+13' Inexact Rounded
subx361 subtract 1 '0.0001' -> '0.9999'
subx362 subtract 1 '0.00001' -> '0.99999'
subx363 subtract 1 '0.000001' -> '0.999999'
subx364 subtract 1 '0.0000001' -> '1.00000' Inexact Rounded
subx365 subtract 1 '0.00000001' -> '1.00000' Inexact Rounded
-- some funny zeros [in case of bad signum]
subx370 subtract 1 0 -> 1
subx371 subtract 1 0. -> 1
subx372 subtract 1 .0 -> 1.0
subx373 subtract 1 0.0 -> 1.0
subx374 subtract 0 1 -> -1
subx375 subtract 0. 1 -> -1
subx376 subtract .0 1 -> -1.0
subx377 subtract 0.0 1 -> -1.0
precision: 9
-- leading 0 digit before round
subx910 subtract -103519362 -51897955.3 -> -51621406.7
subx911 subtract 159579.444 89827.5229 -> 69751.9211
subx920 subtract 333.123456 33.1234566 -> 299.999999 Inexact Rounded
subx921 subtract 333.123456 33.1234565 -> 300.000000 Inexact Rounded
subx922 subtract 133.123456 33.1234565 -> 99.9999995
subx923 subtract 133.123456 33.1234564 -> 99.9999996
subx924 subtract 133.123456 33.1234540 -> 100.000002 Rounded
subx925 subtract 133.123456 43.1234560 -> 90.0000000
subx926 subtract 133.123456 43.1234561 -> 89.9999999
subx927 subtract 133.123456 43.1234566 -> 89.9999994
subx928 subtract 101.123456 91.1234566 -> 9.9999994
subx929 subtract 101.123456 99.1234566 -> 1.9999994
-- more of the same; probe for cluster boundary problems
precision: 1
subx930 subtract 11 2 -> 9
precision: 2
subx932 subtract 101 2 -> 99
precision: 3
subx934 subtract 101 2.1 -> 98.9
subx935 subtract 101 92.01 -> 8.99
precision: 4
subx936 subtract 101 2.01 -> 98.99
subx937 subtract 101 92.01 -> 8.99
subx938 subtract 101 92.006 -> 8.994
precision: 5
subx939 subtract 101 2.001 -> 98.999
subx940 subtract 101 92.001 -> 8.999
subx941 subtract 101 92.0006 -> 8.9994
precision: 6
subx942 subtract 101 2.0001 -> 98.9999
subx943 subtract 101 92.0001 -> 8.9999
subx944 subtract 101 92.00006 -> 8.99994
precision: 7
subx945 subtract 101 2.00001 -> 98.99999
subx946 subtract 101 92.00001 -> 8.99999
subx947 subtract 101 92.000006 -> 8.999994
precision: 8
subx948 subtract 101 2.000001 -> 98.999999
subx949 subtract 101 92.000001 -> 8.999999
subx950 subtract 101 92.0000006 -> 8.9999994
precision: 9
subx951 subtract 101 2.0000001 -> 98.9999999
subx952 subtract 101 92.0000001 -> 8.9999999
subx953 subtract 101 92.00000006 -> 8.99999994
precision: 9
-- more LHS swaps [were fixed]
subx390 subtract '-56267E-10' 0 -> '-0.0000056267'
subx391 subtract '-56267E-6' 0 -> '-0.056267'
subx392 subtract '-56267E-5' 0 -> '-0.56267'
subx393 subtract '-56267E-4' 0 -> '-5.6267'
subx394 subtract '-56267E-3' 0 -> '-56.267'
subx395 subtract '-56267E-2' 0 -> '-562.67'
subx396 subtract '-56267E-1' 0 -> '-5626.7'
subx397 subtract '-56267E-0' 0 -> '-56267'
subx398 subtract '-5E-10' 0 -> '-5E-10'
subx399 subtract '-5E-7' 0 -> '-5E-7'
subx400 subtract '-5E-6' 0 -> '-0.000005'
subx401 subtract '-5E-5' 0 -> '-0.00005'
subx402 subtract '-5E-4' 0 -> '-0.0005'
subx403 subtract '-5E-1' 0 -> '-0.5'
subx404 subtract '-5E0' 0 -> '-5'
subx405 subtract '-5E1' 0 -> '-50'
subx406 subtract '-5E5' 0 -> '-500000'
subx407 subtract '-5E8' 0 -> '-500000000'
subx408 subtract '-5E9' 0 -> '-5.00000000E+9' Rounded
subx409 subtract '-5E10' 0 -> '-5.00000000E+10' Rounded
subx410 subtract '-5E11' 0 -> '-5.00000000E+11' Rounded
subx411 subtract '-5E100' 0 -> '-5.00000000E+100' Rounded
-- more RHS swaps [were fixed]
subx420 subtract 0 '-56267E-10' -> '0.0000056267'
subx421 subtract 0 '-56267E-6' -> '0.056267'
subx422 subtract 0 '-56267E-5' -> '0.56267'
subx423 subtract 0 '-56267E-4' -> '5.6267'
subx424 subtract 0 '-56267E-3' -> '56.267'
subx425 subtract 0 '-56267E-2' -> '562.67'
subx426 subtract 0 '-56267E-1' -> '5626.7'
subx427 subtract 0 '-56267E-0' -> '56267'
subx428 subtract 0 '-5E-10' -> '5E-10'
subx429 subtract 0 '-5E-7' -> '5E-7'
subx430 subtract 0 '-5E-6' -> '0.000005'
subx431 subtract 0 '-5E-5' -> '0.00005'
subx432 subtract 0 '-5E-4' -> '0.0005'
subx433 subtract 0 '-5E-1' -> '0.5'
subx434 subtract 0 '-5E0' -> '5'
subx435 subtract 0 '-5E1' -> '50'
subx436 subtract 0 '-5E5' -> '500000'
subx437 subtract 0 '-5E8' -> '500000000'
subx438 subtract 0 '-5E9' -> '5.00000000E+9' Rounded
subx439 subtract 0 '-5E10' -> '5.00000000E+10' Rounded
subx440 subtract 0 '-5E11' -> '5.00000000E+11' Rounded
subx441 subtract 0 '-5E100' -> '5.00000000E+100' Rounded
-- try borderline precision, with carries, etc.
precision: 15
subx461 subtract '1E+12' '1' -> '999999999999'
subx462 subtract '1E+12' '-1.11' -> '1000000000001.11'
subx463 subtract '1.11' '-1E+12' -> '1000000000001.11'
subx464 subtract '-1' '-1E+12' -> '999999999999'
subx465 subtract '7E+12' '1' -> '6999999999999'
subx466 subtract '7E+12' '-1.11' -> '7000000000001.11'
subx467 subtract '1.11' '-7E+12' -> '7000000000001.11'
subx468 subtract '-1' '-7E+12' -> '6999999999999'
-- 123456789012345 123456789012345 1 23456789012345
subx470 subtract '0.444444444444444' '-0.555555555555563' -> '1.00000000000001' Inexact Rounded
subx471 subtract '0.444444444444444' '-0.555555555555562' -> '1.00000000000001' Inexact Rounded
subx472 subtract '0.444444444444444' '-0.555555555555561' -> '1.00000000000001' Inexact Rounded
subx473 subtract '0.444444444444444' '-0.555555555555560' -> '1.00000000000000' Inexact Rounded
subx474 subtract '0.444444444444444' '-0.555555555555559' -> '1.00000000000000' Inexact Rounded
subx475 subtract '0.444444444444444' '-0.555555555555558' -> '1.00000000000000' Inexact Rounded
subx476 subtract '0.444444444444444' '-0.555555555555557' -> '1.00000000000000' Inexact Rounded
subx477 subtract '0.444444444444444' '-0.555555555555556' -> '1.00000000000000' Rounded
subx478 subtract '0.444444444444444' '-0.555555555555555' -> '0.999999999999999'
subx479 subtract '0.444444444444444' '-0.555555555555554' -> '0.999999999999998'
subx480 subtract '0.444444444444444' '-0.555555555555553' -> '0.999999999999997'
subx481 subtract '0.444444444444444' '-0.555555555555552' -> '0.999999999999996'
subx482 subtract '0.444444444444444' '-0.555555555555551' -> '0.999999999999995'
subx483 subtract '0.444444444444444' '-0.555555555555550' -> '0.999999999999994'
-- and some more, including residue effects and different roundings
precision: 9
rounding: half_up
subx500 subtract '123456789' 0 -> '123456789'
subx501 subtract '123456789' 0.000000001 -> '123456789' Inexact Rounded
subx502 subtract '123456789' 0.000001 -> '123456789' Inexact Rounded
subx503 subtract '123456789' 0.1 -> '123456789' Inexact Rounded
subx504 subtract '123456789' 0.4 -> '123456789' Inexact Rounded
subx505 subtract '123456789' 0.49 -> '123456789' Inexact Rounded
subx506 subtract '123456789' 0.499999 -> '123456789' Inexact Rounded
subx507 subtract '123456789' 0.499999999 -> '123456789' Inexact Rounded
subx508 subtract '123456789' 0.5 -> '123456789' Inexact Rounded
subx509 subtract '123456789' 0.500000001 -> '123456788' Inexact Rounded
subx510 subtract '123456789' 0.500001 -> '123456788' Inexact Rounded
subx511 subtract '123456789' 0.51 -> '123456788' Inexact Rounded
subx512 subtract '123456789' 0.6 -> '123456788' Inexact Rounded
subx513 subtract '123456789' 0.9 -> '123456788' Inexact Rounded
subx514 subtract '123456789' 0.99999 -> '123456788' Inexact Rounded
subx515 subtract '123456789' 0.999999999 -> '123456788' Inexact Rounded
subx516 subtract '123456789' 1 -> '123456788'
subx517 subtract '123456789' 1.000000001 -> '123456788' Inexact Rounded
subx518 subtract '123456789' 1.00001 -> '123456788' Inexact Rounded
subx519 subtract '123456789' 1.1 -> '123456788' Inexact Rounded
rounding: half_even
subx520 subtract '123456789' 0 -> '123456789'
subx521 subtract '123456789' 0.000000001 -> '123456789' Inexact Rounded
subx522 subtract '123456789' 0.000001 -> '123456789' Inexact Rounded
subx523 subtract '123456789' 0.1 -> '123456789' Inexact Rounded
subx524 subtract '123456789' 0.4 -> '123456789' Inexact Rounded
subx525 subtract '123456789' 0.49 -> '123456789' Inexact Rounded
subx526 subtract '123456789' 0.499999 -> '123456789' Inexact Rounded
subx527 subtract '123456789' 0.499999999 -> '123456789' Inexact Rounded
subx528 subtract '123456789' 0.5 -> '123456788' Inexact Rounded
subx529 subtract '123456789' 0.500000001 -> '123456788' Inexact Rounded
subx530 subtract '123456789' 0.500001 -> '123456788' Inexact Rounded
subx531 subtract '123456789' 0.51 -> '123456788' Inexact Rounded
subx532 subtract '123456789' 0.6 -> '123456788' Inexact Rounded
subx533 subtract '123456789' 0.9 -> '123456788' Inexact Rounded
subx534 subtract '123456789' 0.99999 -> '123456788' Inexact Rounded
subx535 subtract '123456789' 0.999999999 -> '123456788' Inexact Rounded
subx536 subtract '123456789' 1 -> '123456788'
subx537 subtract '123456789' 1.00000001 -> '123456788' Inexact Rounded
subx538 subtract '123456789' 1.00001 -> '123456788' Inexact Rounded
subx539 subtract '123456789' 1.1 -> '123456788' Inexact Rounded
-- critical few with even bottom digit...
subx540 subtract '123456788' 0.499999999 -> '123456788' Inexact Rounded
subx541 subtract '123456788' 0.5 -> '123456788' Inexact Rounded
subx542 subtract '123456788' 0.500000001 -> '123456787' Inexact Rounded
rounding: down
subx550 subtract '123456789' 0 -> '123456789'
subx551 subtract '123456789' 0.000000001 -> '123456788' Inexact Rounded
subx552 subtract '123456789' 0.000001 -> '123456788' Inexact Rounded
subx553 subtract '123456789' 0.1 -> '123456788' Inexact Rounded
subx554 subtract '123456789' 0.4 -> '123456788' Inexact Rounded
subx555 subtract '123456789' 0.49 -> '123456788' Inexact Rounded
subx556 subtract '123456789' 0.499999 -> '123456788' Inexact Rounded
subx557 subtract '123456789' 0.499999999 -> '123456788' Inexact Rounded
subx558 subtract '123456789' 0.5 -> '123456788' Inexact Rounded
subx559 subtract '123456789' 0.500000001 -> '123456788' Inexact Rounded
subx560 subtract '123456789' 0.500001 -> '123456788' Inexact Rounded
subx561 subtract '123456789' 0.51 -> '123456788' Inexact Rounded
subx562 subtract '123456789' 0.6 -> '123456788' Inexact Rounded
subx563 subtract '123456789' 0.9 -> '123456788' Inexact Rounded
subx564 subtract '123456789' 0.99999 -> '123456788' Inexact Rounded
subx565 subtract '123456789' 0.999999999 -> '123456788' Inexact Rounded
subx566 subtract '123456789' 1 -> '123456788'
subx567 subtract '123456789' 1.00000001 -> '123456787' Inexact Rounded
subx568 subtract '123456789' 1.00001 -> '123456787' Inexact Rounded
subx569 subtract '123456789' 1.1 -> '123456787' Inexact Rounded
-- symmetry...
rounding: half_up
subx600 subtract 0 '123456789' -> '-123456789'
subx601 subtract 0.000000001 '123456789' -> '-123456789' Inexact Rounded
subx602 subtract 0.000001 '123456789' -> '-123456789' Inexact Rounded
subx603 subtract 0.1 '123456789' -> '-123456789' Inexact Rounded
subx604 subtract 0.4 '123456789' -> '-123456789' Inexact Rounded
subx605 subtract 0.49 '123456789' -> '-123456789' Inexact Rounded
subx606 subtract 0.499999 '123456789' -> '-123456789' Inexact Rounded
subx607 subtract 0.499999999 '123456789' -> '-123456789' Inexact Rounded
subx608 subtract 0.5 '123456789' -> '-123456789' Inexact Rounded
subx609 subtract 0.500000001 '123456789' -> '-123456788' Inexact Rounded
subx610 subtract 0.500001 '123456789' -> '-123456788' Inexact Rounded
subx611 subtract 0.51 '123456789' -> '-123456788' Inexact Rounded
subx612 subtract 0.6 '123456789' -> '-123456788' Inexact Rounded
subx613 subtract 0.9 '123456789' -> '-123456788' Inexact Rounded
subx614 subtract 0.99999 '123456789' -> '-123456788' Inexact Rounded
subx615 subtract 0.999999999 '123456789' -> '-123456788' Inexact Rounded
subx616 subtract 1 '123456789' -> '-123456788'
subx617 subtract 1.000000001 '123456789' -> '-123456788' Inexact Rounded
subx618 subtract 1.00001 '123456789' -> '-123456788' Inexact Rounded
subx619 subtract 1.1 '123456789' -> '-123456788' Inexact Rounded
rounding: half_even
subx620 subtract 0 '123456789' -> '-123456789'
subx621 subtract 0.000000001 '123456789' -> '-123456789' Inexact Rounded
subx622 subtract 0.000001 '123456789' -> '-123456789' Inexact Rounded
subx623 subtract 0.1 '123456789' -> '-123456789' Inexact Rounded
subx624 subtract 0.4 '123456789' -> '-123456789' Inexact Rounded
subx625 subtract 0.49 '123456789' -> '-123456789' Inexact Rounded
subx626 subtract 0.499999 '123456789' -> '-123456789' Inexact Rounded
subx627 subtract 0.499999999 '123456789' -> '-123456789' Inexact Rounded
subx628 subtract 0.5 '123456789' -> '-123456788' Inexact Rounded
subx629 subtract 0.500000001 '123456789' -> '-123456788' Inexact Rounded
subx630 subtract 0.500001 '123456789' -> '-123456788' Inexact Rounded
subx631 subtract 0.51 '123456789' -> '-123456788' Inexact Rounded
subx632 subtract 0.6 '123456789' -> '-123456788' Inexact Rounded
subx633 subtract 0.9 '123456789' -> '-123456788' Inexact Rounded
subx634 subtract 0.99999 '123456789' -> '-123456788' Inexact Rounded
subx635 subtract 0.999999999 '123456789' -> '-123456788' Inexact Rounded
subx636 subtract 1 '123456789' -> '-123456788'
subx637 subtract 1.00000001 '123456789' -> '-123456788' Inexact Rounded
subx638 subtract 1.00001 '123456789' -> '-123456788' Inexact Rounded
subx639 subtract 1.1 '123456789' -> '-123456788' Inexact Rounded
-- critical few with even bottom digit...
subx640 subtract 0.499999999 '123456788' -> '-123456788' Inexact Rounded
subx641 subtract 0.5 '123456788' -> '-123456788' Inexact Rounded
subx642 subtract 0.500000001 '123456788' -> '-123456787' Inexact Rounded
rounding: down
subx650 subtract 0 '123456789' -> '-123456789'
subx651 subtract 0.000000001 '123456789' -> '-123456788' Inexact Rounded
subx652 subtract 0.000001 '123456789' -> '-123456788' Inexact Rounded
subx653 subtract 0.1 '123456789' -> '-123456788' Inexact Rounded
subx654 subtract 0.4 '123456789' -> '-123456788' Inexact Rounded
subx655 subtract 0.49 '123456789' -> '-123456788' Inexact Rounded
subx656 subtract 0.499999 '123456789' -> '-123456788' Inexact Rounded
subx657 subtract 0.499999999 '123456789' -> '-123456788' Inexact Rounded
subx658 subtract 0.5 '123456789' -> '-123456788' Inexact Rounded
subx659 subtract 0.500000001 '123456789' -> '-123456788' Inexact Rounded
subx660 subtract 0.500001 '123456789' -> '-123456788' Inexact Rounded
subx661 subtract 0.51 '123456789' -> '-123456788' Inexact Rounded
subx662 subtract 0.6 '123456789' -> '-123456788' Inexact Rounded
subx663 subtract 0.9 '123456789' -> '-123456788' Inexact Rounded
subx664 subtract 0.99999 '123456789' -> '-123456788' Inexact Rounded
subx665 subtract 0.999999999 '123456789' -> '-123456788' Inexact Rounded
subx666 subtract 1 '123456789' -> '-123456788'
subx667 subtract 1.00000001 '123456789' -> '-123456787' Inexact Rounded
subx668 subtract 1.00001 '123456789' -> '-123456787' Inexact Rounded
subx669 subtract 1.1 '123456789' -> '-123456787' Inexact Rounded
-- lots of leading zeros in intermediate result, and showing effects of
-- input rounding would have affected the following
precision: 9
rounding: half_up
subx670 subtract '123456789' '123456788.1' -> 0.9
subx671 subtract '123456789' '123456788.9' -> 0.1
subx672 subtract '123456789' '123456789.1' -> -0.1
subx673 subtract '123456789' '123456789.5' -> -0.5
subx674 subtract '123456789' '123456789.9' -> -0.9
rounding: half_even
subx680 subtract '123456789' '123456788.1' -> 0.9
subx681 subtract '123456789' '123456788.9' -> 0.1
subx682 subtract '123456789' '123456789.1' -> -0.1
subx683 subtract '123456789' '123456789.5' -> -0.5
subx684 subtract '123456789' '123456789.9' -> -0.9
subx685 subtract '123456788' '123456787.1' -> 0.9
subx686 subtract '123456788' '123456787.9' -> 0.1
subx687 subtract '123456788' '123456788.1' -> -0.1
subx688 subtract '123456788' '123456788.5' -> -0.5
subx689 subtract '123456788' '123456788.9' -> -0.9
rounding: down
subx690 subtract '123456789' '123456788.1' -> 0.9
subx691 subtract '123456789' '123456788.9' -> 0.1
subx692 subtract '123456789' '123456789.1' -> -0.1
subx693 subtract '123456789' '123456789.5' -> -0.5
subx694 subtract '123456789' '123456789.9' -> -0.9
-- input preparation tests
rounding: half_up
precision: 3
subx700 subtract '12345678900000' -9999999999999 -> '2.23E+13' Inexact Rounded
subx701 subtract '9999999999999' -12345678900000 -> '2.23E+13' Inexact Rounded
subx702 subtract '12E+3' '-3456' -> '1.55E+4' Inexact Rounded
subx703 subtract '12E+3' '-3446' -> '1.54E+4' Inexact Rounded
subx704 subtract '12E+3' '-3454' -> '1.55E+4' Inexact Rounded
subx705 subtract '12E+3' '-3444' -> '1.54E+4' Inexact Rounded
subx706 subtract '3456' '-12E+3' -> '1.55E+4' Inexact Rounded
subx707 subtract '3446' '-12E+3' -> '1.54E+4' Inexact Rounded
subx708 subtract '3454' '-12E+3' -> '1.55E+4' Inexact Rounded
subx709 subtract '3444' '-12E+3' -> '1.54E+4' Inexact Rounded
-- overflow and underflow tests [subnormals now possible]
maxexponent: 999999999
minexponent: -999999999
precision: 9
rounding: down
subx710 subtract 1E+999999999 -9E+999999999 -> 9.99999999E+999999999 Overflow Inexact Rounded
subx711 subtract 9E+999999999 -1E+999999999 -> 9.99999999E+999999999 Overflow Inexact Rounded
rounding: half_up
subx712 subtract 1E+999999999 -9E+999999999 -> Infinity Overflow Inexact Rounded
subx713 subtract 9E+999999999 -1E+999999999 -> Infinity Overflow Inexact Rounded
subx714 subtract -1.1E-999999999 -1E-999999999 -> -1E-1000000000 Subnormal
subx715 subtract 1E-999999999 +1.1e-999999999 -> -1E-1000000000 Subnormal
subx716 subtract -1E+999999999 +9E+999999999 -> -Infinity Overflow Inexact Rounded
subx717 subtract -9E+999999999 +1E+999999999 -> -Infinity Overflow Inexact Rounded
subx718 subtract +1.1E-999999999 +1E-999999999 -> 1E-1000000000 Subnormal
subx719 subtract -1E-999999999 -1.1e-999999999 -> 1E-1000000000 Subnormal
precision: 3
subx720 subtract 1 9.999E+999999999 -> -Infinity Inexact Overflow Rounded
subx721 subtract 1 -9.999E+999999999 -> Infinity Inexact Overflow Rounded
subx722 subtract 9.999E+999999999 1 -> Infinity Inexact Overflow Rounded
subx723 subtract -9.999E+999999999 1 -> -Infinity Inexact Overflow Rounded
subx724 subtract 1 9.999E+999999999 -> -Infinity Inexact Overflow Rounded
subx725 subtract 1 -9.999E+999999999 -> Infinity Inexact Overflow Rounded
subx726 subtract 9.999E+999999999 1 -> Infinity Inexact Overflow Rounded
subx727 subtract -9.999E+999999999 1 -> -Infinity Inexact Overflow Rounded
-- [more below]
-- long operand checks
maxexponent: 999
minexponent: -999
precision: 9
sub731 subtract 12345678000 0 -> 1.23456780E+10 Rounded
sub732 subtract 0 12345678000 -> -1.23456780E+10 Rounded
sub733 subtract 1234567800 0 -> 1.23456780E+9 Rounded
sub734 subtract 0 1234567800 -> -1.23456780E+9 Rounded
sub735 subtract 1234567890 0 -> 1.23456789E+9 Rounded
sub736 subtract 0 1234567890 -> -1.23456789E+9 Rounded
sub737 subtract 1234567891 0 -> 1.23456789E+9 Inexact Rounded
sub738 subtract 0 1234567891 -> -1.23456789E+9 Inexact Rounded
sub739 subtract 12345678901 0 -> 1.23456789E+10 Inexact Rounded
sub740 subtract 0 12345678901 -> -1.23456789E+10 Inexact Rounded
sub741 subtract 1234567896 0 -> 1.23456790E+9 Inexact Rounded
sub742 subtract 0 1234567896 -> -1.23456790E+9 Inexact Rounded
precision: 15
sub751 subtract 12345678000 0 -> 12345678000
sub752 subtract 0 12345678000 -> -12345678000
sub753 subtract 1234567800 0 -> 1234567800
sub754 subtract 0 1234567800 -> -1234567800
sub755 subtract 1234567890 0 -> 1234567890
sub756 subtract 0 1234567890 -> -1234567890
sub757 subtract 1234567891 0 -> 1234567891
sub758 subtract 0 1234567891 -> -1234567891
sub759 subtract 12345678901 0 -> 12345678901
sub760 subtract 0 12345678901 -> -12345678901
sub761 subtract 1234567896 0 -> 1234567896
sub762 subtract 0 1234567896 -> -1234567896
-- Specials
subx780 subtract -Inf Inf -> -Infinity
subx781 subtract -Inf 1000 -> -Infinity
subx782 subtract -Inf 1 -> -Infinity
subx783 subtract -Inf -0 -> -Infinity
subx784 subtract -Inf -1 -> -Infinity
subx785 subtract -Inf -1000 -> -Infinity
subx787 subtract -1000 Inf -> -Infinity
subx788 subtract -Inf Inf -> -Infinity
subx789 subtract -1 Inf -> -Infinity
subx790 subtract 0 Inf -> -Infinity
subx791 subtract 1 Inf -> -Infinity
subx792 subtract 1000 Inf -> -Infinity
subx800 subtract Inf Inf -> NaN Invalid_operation
subx801 subtract Inf 1000 -> Infinity
subx802 subtract Inf 1 -> Infinity
subx803 subtract Inf 0 -> Infinity
subx804 subtract Inf -0 -> Infinity
subx805 subtract Inf -1 -> Infinity
subx806 subtract Inf -1000 -> Infinity
subx807 subtract Inf -Inf -> Infinity
subx808 subtract -1000 -Inf -> Infinity
subx809 subtract -Inf -Inf -> NaN Invalid_operation
subx810 subtract -1 -Inf -> Infinity
subx811 subtract -0 -Inf -> Infinity
subx812 subtract 0 -Inf -> Infinity
subx813 subtract 1 -Inf -> Infinity
subx814 subtract 1000 -Inf -> Infinity
subx815 subtract Inf -Inf -> Infinity
subx821 subtract NaN Inf -> NaN
subx822 subtract -NaN 1000 -> -NaN
subx823 subtract NaN 1 -> NaN
subx824 subtract NaN 0 -> NaN
subx825 subtract NaN -0 -> NaN
subx826 subtract NaN -1 -> NaN
subx827 subtract NaN -1000 -> NaN
subx828 subtract NaN -Inf -> NaN
subx829 subtract -NaN NaN -> -NaN
subx830 subtract -Inf NaN -> NaN
subx831 subtract -1000 NaN -> NaN
subx832 subtract -1 NaN -> NaN
subx833 subtract -0 NaN -> NaN
subx834 subtract 0 NaN -> NaN
subx835 subtract 1 NaN -> NaN
subx836 subtract 1000 -NaN -> -NaN
subx837 subtract Inf NaN -> NaN
subx841 subtract sNaN Inf -> NaN Invalid_operation
subx842 subtract -sNaN 1000 -> -NaN Invalid_operation
subx843 subtract sNaN 1 -> NaN Invalid_operation
subx844 subtract sNaN 0 -> NaN Invalid_operation
subx845 subtract sNaN -0 -> NaN Invalid_operation
subx846 subtract sNaN -1 -> NaN Invalid_operation
subx847 subtract sNaN -1000 -> NaN Invalid_operation
subx848 subtract sNaN NaN -> NaN Invalid_operation
subx849 subtract sNaN sNaN -> NaN Invalid_operation
subx850 subtract NaN sNaN -> NaN Invalid_operation
subx851 subtract -Inf -sNaN -> -NaN Invalid_operation
subx852 subtract -1000 sNaN -> NaN Invalid_operation
subx853 subtract -1 sNaN -> NaN Invalid_operation
subx854 subtract -0 sNaN -> NaN Invalid_operation
subx855 subtract 0 sNaN -> NaN Invalid_operation
subx856 subtract 1 sNaN -> NaN Invalid_operation
subx857 subtract 1000 sNaN -> NaN Invalid_operation
subx858 subtract Inf sNaN -> NaN Invalid_operation
subx859 subtract NaN sNaN -> NaN Invalid_operation
-- propagating NaNs
subx861 subtract NaN01 -Inf -> NaN1
subx862 subtract -NaN02 -1000 -> -NaN2
subx863 subtract NaN03 1000 -> NaN3
subx864 subtract NaN04 Inf -> NaN4
subx865 subtract NaN05 NaN61 -> NaN5
subx866 subtract -Inf -NaN71 -> -NaN71
subx867 subtract -1000 NaN81 -> NaN81
subx868 subtract 1000 NaN91 -> NaN91
subx869 subtract Inf NaN101 -> NaN101
subx871 subtract sNaN011 -Inf -> NaN11 Invalid_operation
subx872 subtract sNaN012 -1000 -> NaN12 Invalid_operation
subx873 subtract -sNaN013 1000 -> -NaN13 Invalid_operation
subx874 subtract sNaN014 NaN171 -> NaN14 Invalid_operation
subx875 subtract sNaN015 sNaN181 -> NaN15 Invalid_operation
subx876 subtract NaN016 sNaN191 -> NaN191 Invalid_operation
subx877 subtract -Inf sNaN201 -> NaN201 Invalid_operation
subx878 subtract -1000 sNaN211 -> NaN211 Invalid_operation
subx879 subtract 1000 -sNaN221 -> -NaN221 Invalid_operation
subx880 subtract Inf sNaN231 -> NaN231 Invalid_operation
subx881 subtract NaN025 sNaN241 -> NaN241 Invalid_operation
-- edge case spills
subx901 subtract 2.E-3 1.002 -> -1.000
subx902 subtract 2.0E-3 1.002 -> -1.0000
subx903 subtract 2.00E-3 1.0020 -> -1.00000
subx904 subtract 2.000E-3 1.00200 -> -1.000000
subx905 subtract 2.0000E-3 1.002000 -> -1.0000000
subx906 subtract 2.00000E-3 1.0020000 -> -1.00000000
subx907 subtract 2.000000E-3 1.00200000 -> -1.000000000
subx908 subtract 2.0000000E-3 1.002000000 -> -1.0000000000
-- subnormals and underflows
precision: 3
maxexponent: 999
minexponent: -999
subx1010 subtract 0 1.00E-999 -> -1.00E-999
subx1011 subtract 0 0.1E-999 -> -1E-1000 Subnormal
subx1012 subtract 0 0.10E-999 -> -1.0E-1000 Subnormal
subx1013 subtract 0 0.100E-999 -> -1.0E-1000 Subnormal Rounded
subx1014 subtract 0 0.01E-999 -> -1E-1001 Subnormal
-- next is rounded to Emin
subx1015 subtract 0 0.999E-999 -> -1.00E-999 Inexact Rounded Subnormal Underflow
subx1016 subtract 0 0.099E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow
subx1017 subtract 0 0.009E-999 -> -1E-1001 Inexact Rounded Subnormal Underflow
subx1018 subtract 0 0.001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow
subx1019 subtract 0 0.0009E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow
subx1020 subtract 0 0.0001E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow
subx1030 subtract 0 -1.00E-999 -> 1.00E-999
subx1031 subtract 0 -0.1E-999 -> 1E-1000 Subnormal
subx1032 subtract 0 -0.10E-999 -> 1.0E-1000 Subnormal
subx1033 subtract 0 -0.100E-999 -> 1.0E-1000 Subnormal Rounded
subx1034 subtract 0 -0.01E-999 -> 1E-1001 Subnormal
-- next is rounded to Emin
subx1035 subtract 0 -0.999E-999 -> 1.00E-999 Inexact Rounded Subnormal Underflow
subx1036 subtract 0 -0.099E-999 -> 1.0E-1000 Inexact Rounded Subnormal Underflow
subx1037 subtract 0 -0.009E-999 -> 1E-1001 Inexact Rounded Subnormal Underflow
subx1038 subtract 0 -0.001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
subx1039 subtract 0 -0.0009E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
subx1040 subtract 0 -0.0001E-999 -> 0E-1001 Inexact Rounded Subnormal Underflow
-- some non-zero subnormal subtracts
-- subx1056 is a tricky case
rounding: half_up
subx1050 subtract 1.00E-999 0.1E-999 -> 9.0E-1000 Subnormal
subx1051 subtract 0.1E-999 0.1E-999 -> 0E-1000
subx1052 subtract 0.10E-999 0.1E-999 -> 0E-1001
subx1053 subtract 0.100E-999 0.1E-999 -> 0E-1001 Clamped
subx1054 subtract 0.01E-999 0.1E-999 -> -9E-1001 Subnormal
subx1055 subtract 0.999E-999 0.1E-999 -> 9.0E-1000 Inexact Rounded Subnormal Underflow
subx1056 subtract 0.099E-999 0.1E-999 -> -0E-1001 Inexact Rounded Subnormal Underflow
subx1057 subtract 0.009E-999 0.1E-999 -> -9E-1001 Inexact Rounded Subnormal Underflow
subx1058 subtract 0.001E-999 0.1E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow
subx1059 subtract 0.0009E-999 0.1E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow
subx1060 subtract 0.0001E-999 0.1E-999 -> -1.0E-1000 Inexact Rounded Subnormal Underflow
-- check for double-rounded subnormals
precision: 5
maxexponent: 79
minexponent: -79
subx1101 subtract 0 1.52444E-80 -> -1.524E-80 Inexact Rounded Subnormal Underflow
subx1102 subtract 0 1.52445E-80 -> -1.524E-80 Inexact Rounded Subnormal Underflow
subx1103 subtract 0 1.52446E-80 -> -1.524E-80 Inexact Rounded Subnormal Underflow
subx1104 subtract 1.52444E-80 0 -> 1.524E-80 Inexact Rounded Subnormal Underflow
subx1105 subtract 1.52445E-80 0 -> 1.524E-80 Inexact Rounded Subnormal Underflow
subx1106 subtract 1.52446E-80 0 -> 1.524E-80 Inexact Rounded Subnormal Underflow
subx1111 subtract 1.2345678E-80 1.2345671E-80 -> 0E-83 Inexact Rounded Subnormal Underflow
subx1112 subtract 1.2345678E-80 1.2345618E-80 -> 0E-83 Inexact Rounded Subnormal Underflow
subx1113 subtract 1.2345678E-80 1.2345178E-80 -> 0E-83 Inexact Rounded Subnormal Underflow
subx1114 subtract 1.2345678E-80 1.2341678E-80 -> 0E-83 Inexact Rounded Subnormal Underflow
subx1115 subtract 1.2345678E-80 1.2315678E-80 -> 3E-83 Rounded Subnormal
subx1116 subtract 1.2345678E-80 1.2145678E-80 -> 2.0E-82 Rounded Subnormal
subx1117 subtract 1.2345678E-80 1.1345678E-80 -> 1.00E-81 Rounded Subnormal
subx1118 subtract 1.2345678E-80 0.2345678E-80 -> 1.000E-80 Rounded Subnormal
-- Null tests
subx9990 subtract 10 # -> NaN Invalid_operation
subx9991 subtract # 10 -> NaN Invalid_operation

58
sys/lib/python/test/decimaltestdata/testall.decTest
View file

@ -1,58 +0,0 @@
------------------------------------------------------------------------
-- testall.decTest -- run all general decimal arithmetic testcases --
-- Copyright (c) IBM Corporation, 1981, 2004. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- core tests (using Extended: 1) --------------------------------------
dectest: base
dectest: abs
dectest: add
dectest: clamp
dectest: compare
dectest: divide
dectest: divideint
dectest: inexact
dectest: max
dectest: min
dectest: minus
dectest: multiply
dectest: normalize
dectest: plus
dectest: power
dectest: quantize
dectest: randoms
dectest: remainder
dectest: remaindernear
dectest: rescale -- [obsolete]
dectest: rounding
dectest: samequantum
dectest: squareroot
dectest: subtract
dectest: tointegral
dectest: trim
-- The next are for the Strawman 4d concrete representations
dectest: decimal32
dectest: decimal64
dectest: decimal128
-- General 31->33-digit boundary tests
dectest: randombound32

176
sys/lib/python/test/decimaltestdata/tointegral.decTest
View file

@ -1,176 +0,0 @@
------------------------------------------------------------------------
-- tointegral.decTest -- round decimal to integral value --
-- Copyright (c) IBM Corporation, 2001, 2003. All rights reserved. --
------------------------------------------------------------------------
-- Please see the document "General Decimal Arithmetic Testcases" --
-- at http://www2.hursley.ibm.com/decimal for the description of --
-- these testcases. --
-- --
-- These testcases are experimental ('beta' versions), and they --
-- may contain errors. They are offered on an as-is basis. In --
-- particular, achieving the same results as the tests here is not --
-- a guarantee that an implementation complies with any Standard --
-- or specification. The tests are not exhaustive. --
-- --
-- Please send comments, suggestions, and corrections to the author: --
-- Mike Cowlishaw, IBM Fellow --
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
version: 2.39
-- This set of tests tests the extended specification 'round-to-integral
-- value' operation (from IEEE 854, later modified in 754r).
-- All non-zero results are defined as being those from either copy or
-- quantize, so those are assumed to have been tested.
-- Note that 754r requires that Inexact not be set, and we similarly
-- assume Rounded is not set.
extended: 1
precision: 9
rounding: half_up
maxExponent: 999
minExponent: -999
intx001 tointegral 0 -> 0
intx002 tointegral 0.0 -> 0
intx003 tointegral 0.1 -> 0
intx004 tointegral 0.2 -> 0
intx005 tointegral 0.3 -> 0
intx006 tointegral 0.4 -> 0
intx007 tointegral 0.5 -> 1
intx008 tointegral 0.6 -> 1
intx009 tointegral 0.7 -> 1
intx010 tointegral 0.8 -> 1
intx011 tointegral 0.9 -> 1
intx012 tointegral 1 -> 1
intx013 tointegral 1.0 -> 1
intx014 tointegral 1.1 -> 1
intx015 tointegral 1.2 -> 1
intx016 tointegral 1.3 -> 1
intx017 tointegral 1.4 -> 1
intx018 tointegral 1.5 -> 2
intx019 tointegral 1.6 -> 2
intx020 tointegral 1.7 -> 2
intx021 tointegral 1.8 -> 2
intx022 tointegral 1.9 -> 2
-- negatives
intx031 tointegral -0 -> -0
intx032 tointegral -0.0 -> -0
intx033 tointegral -0.1 -> -0
intx034 tointegral -0.2 -> -0
intx035 tointegral -0.3 -> -0
intx036 tointegral -0.4 -> -0
intx037 tointegral -0.5 -> -1
intx038 tointegral -0.6 -> -1
intx039 tointegral -0.7 -> -1
intx040 tointegral -0.8 -> -1
intx041 tointegral -0.9 -> -1
intx042 tointegral -1 -> -1
intx043 tointegral -1.0 -> -1
intx044 tointegral -1.1 -> -1
intx045 tointegral -1.2 -> -1
intx046 tointegral -1.3 -> -1
intx047 tointegral -1.4 -> -1
intx048 tointegral -1.5 -> -2
intx049 tointegral -1.6 -> -2
intx050 tointegral -1.7 -> -2
intx051 tointegral -1.8 -> -2
intx052 tointegral -1.9 -> -2
-- next two would be NaN using quantize(x, 0)
intx053 tointegral 10E+30 -> 1.0E+31
intx054 tointegral -10E+30 -> -1.0E+31
-- numbers around precision
precision: 9
intx060 tointegral '56267E-10' -> '0'
intx061 tointegral '56267E-5' -> '1'
intx062 tointegral '56267E-2' -> '563'
intx063 tointegral '56267E-1' -> '5627'
intx065 tointegral '56267E-0' -> '56267'
intx066 tointegral '56267E+0' -> '56267'
intx067 tointegral '56267E+1' -> '5.6267E+5'
intx068 tointegral '56267E+2' -> '5.6267E+6'
intx069 tointegral '56267E+3' -> '5.6267E+7'
intx070 tointegral '56267E+4' -> '5.6267E+8'
intx071 tointegral '56267E+5' -> '5.6267E+9'
intx072 tointegral '56267E+6' -> '5.6267E+10'
intx073 tointegral '1.23E+96' -> '1.23E+96'
intx074 tointegral '1.23E+384' -> '1.23E+384'
intx075 tointegral '1.23E+999' -> '1.23E+999'
intx080 tointegral '-56267E-10' -> '-0'
intx081 tointegral '-56267E-5' -> '-1'
intx082 tointegral '-56267E-2' -> '-563'
intx083 tointegral '-56267E-1' -> '-5627'
intx085 tointegral '-56267E-0' -> '-56267'
intx086 tointegral '-56267E+0' -> '-56267'
intx087 tointegral '-56267E+1' -> '-5.6267E+5'
intx088 tointegral '-56267E+2' -> '-5.6267E+6'
intx089 tointegral '-56267E+3' -> '-5.6267E+7'
intx090 tointegral '-56267E+4' -> '-5.6267E+8'
intx091 tointegral '-56267E+5' -> '-5.6267E+9'
intx092 tointegral '-56267E+6' -> '-5.6267E+10'
intx093 tointegral '-1.23E+96' -> '-1.23E+96'
intx094 tointegral '-1.23E+384' -> '-1.23E+384'
intx095 tointegral '-1.23E+999' -> '-1.23E+999'
-- subnormal inputs
intx100 tointegral 1E-999 -> 0
intx101 tointegral 0.1E-999 -> 0
intx102 tointegral 0.01E-999 -> 0
intx103 tointegral 0E-999 -> 0
-- specials and zeros
intx120 tointegral 'Inf' -> Infinity
intx121 tointegral '-Inf' -> -Infinity
intx122 tointegral NaN -> NaN
intx123 tointegral sNaN -> NaN Invalid_operation
intx124 tointegral 0 -> 0
intx125 tointegral -0 -> -0
intx126 tointegral 0.000 -> 0
intx127 tointegral 0.00 -> 0
intx128 tointegral 0.0 -> 0
intx129 tointegral 0 -> 0
intx130 tointegral 0E-3 -> 0
intx131 tointegral 0E-2 -> 0
intx132 tointegral 0E-1 -> 0
intx133 tointegral 0E-0 -> 0
intx134 tointegral 0E+1 -> 0E+1
intx135 tointegral 0E+2 -> 0E+2
intx136 tointegral 0E+3 -> 0E+3
intx137 tointegral 0E+4 -> 0E+4
intx138 tointegral 0E+5 -> 0E+5
intx139 tointegral -0.000 -> -0
intx140 tointegral -0.00 -> -0
intx141 tointegral -0.0 -> -0
intx142 tointegral -0 -> -0
intx143 tointegral -0E-3 -> -0
intx144 tointegral -0E-2 -> -0
intx145 tointegral -0E-1 -> -0
intx146 tointegral -0E-0 -> -0
intx147 tointegral -0E+1 -> -0E+1
intx148 tointegral -0E+2 -> -0E+2
intx149 tointegral -0E+3 -> -0E+3
intx150 tointegral -0E+4 -> -0E+4
intx151 tointegral -0E+5 -> -0E+5
-- propagating NaNs
intx152 tointegral NaN808 -> NaN808
intx153 tointegral sNaN080 -> NaN80 Invalid_operation
intx154 tointegral -NaN808 -> -NaN808
intx155 tointegral -sNaN080 -> -NaN80 Invalid_operation
intx156 tointegral -NaN -> -NaN
intx157 tointegral -sNaN -> -NaN Invalid_operation
-- examples
rounding: half_up
precision: 9
intx200 tointegral 2.1 -> 2
intx201 tointegral 100 -> 100
intx202 tointegral 100.0 -> 100
intx203 tointegral 101.5 -> 102
intx204 tointegral -101.5 -> -102
intx205 tointegral 10E+5 -> 1.0E+6
intx206 tointegral 7.89E+77 -> 7.89E+77
intx207 tointegral -Inf -> -Infinity

13
sys/lib/python/test/doctest_aliases.py
View file

@ -1,13 +0,0 @@
# Used by test_doctest.py.
class TwoNames:
'''f() and g() are two names for the same method'''
def f(self):
'''
>>> print TwoNames().f()
f
'''
return 'f'
g = f # define an alias for f

30
sys/lib/python/test/double_const.py
View file

@ -1,30 +0,0 @@
from test.test_support import TestFailed
# A test for SF bug 422177: manifest float constants varied way too much in
# precision depending on whether Python was loading a module for the first
# time, or reloading it from a precompiled .pyc. The "expected" failure
# mode is that when test_import imports this after all .pyc files have been
# erased, it passes, but when test_import imports this from
# double_const.pyc, it fails. This indicates a woeful loss of precision in
# the marshal format for doubles. It's also possible that repr() doesn't
# produce enough digits to get reasonable precision for this box.
PI = 3.14159265358979324
TWOPI = 6.28318530717958648
PI_str = "3.14159265358979324"
TWOPI_str = "6.28318530717958648"
# Verify that the double x is within a few bits of eval(x_str).
def check_ok(x, x_str):
assert x > 0.0
x2 = eval(x_str)
assert x2 > 0.0
diff = abs(x - x2)
# If diff is no larger than 3 ULP (wrt x2), then diff/8 is no larger
# than 0.375 ULP, so adding diff/8 to x2 should have no effect.
if x2 + (diff / 8.) != x2:
raise TestFailed("Manifest const %s lost too much precision " % x_str)
check_ok(PI, PI_str)
check_ok(TWOPI, TWOPI_str)

1
sys/lib/python/test/empty.vbs
View file

@ -1 +0,0 @@
'Empty VBS file, does nothing. Helper for Lib\test\test_startfile.py.

48
sys/lib/python/test/exception_hierarchy.txt
View file

@ -1,48 +0,0 @@
BaseException
+-- SystemExit
+-- KeyboardInterrupt
+-- Exception
+-- GeneratorExit
+-- StopIteration
+-- StandardError
| +-- ArithmeticError
| | +-- FloatingPointError
| | +-- OverflowError
| | +-- ZeroDivisionError
| +-- AssertionError
| +-- AttributeError
| +-- EnvironmentError
| | +-- IOError
| | +-- OSError
| | +-- WindowsError (Windows)
| | +-- VMSError (VMS)
| +-- EOFError
| +-- ImportError
| +-- LookupError
| | +-- IndexError
| | +-- KeyError
| +-- MemoryError
| +-- NameError
| | +-- UnboundLocalError
| +-- ReferenceError
| +-- RuntimeError
| | +-- NotImplementedError
| +-- SyntaxError
| | +-- IndentationError
| | +-- TabError
| +-- SystemError
| +-- TypeError
| +-- ValueError
| | +-- UnicodeError
| | +-- UnicodeDecodeError
| | +-- UnicodeEncodeError
| | +-- UnicodeTranslateError
+-- Warning
+-- DeprecationWarning
+-- PendingDeprecationWarning
+-- RuntimeWarning
+-- SyntaxWarning
+-- UserWarning
+-- FutureWarning
+-- ImportWarning
+-- UnicodeWarning

78
sys/lib/python/test/fork_wait.py
View file

@ -1,78 +0,0 @@
"""This test case provides support for checking forking and wait behavior.
To test different wait behavior, overrise the wait_impl method.
We want fork1() semantics -- only the forking thread survives in the
child after a fork().
On some systems (e.g. Solaris without posix threads) we find that all
active threads survive in the child after a fork(); this is an error.
While BeOS doesn't officially support fork and native threading in
the same application, the present example should work just fine. DC
"""
import os, sys, time, thread, unittest
from test.test_support import TestSkipped
LONGSLEEP = 2
SHORTSLEEP = 0.5
NUM_THREADS = 4
class ForkWait(unittest.TestCase):
def setUp(self):
self.alive = {}
self.stop = 0
def f(self, id):
while not self.stop:
self.alive[id] = os.getpid()
try:
time.sleep(SHORTSLEEP)
except IOError:
pass
def wait_impl(self, cpid):
for i in range(10):
# waitpid() shouldn't hang, but some of the buildbots seem to hang
# in the forking tests. This is an attempt to fix the problem.
spid, status = os.waitpid(cpid, os.WNOHANG)
if spid == cpid:
break
time.sleep(2 * SHORTSLEEP)
self.assertEquals(spid, cpid)
self.assertEquals(status, 0, "cause = %d, exit = %d" % (status&0xff, status>>8))
def test_wait(self):
for i in range(NUM_THREADS):
thread.start_new(self.f, (i,))
time.sleep(LONGSLEEP)
a = self.alive.keys()
a.sort()
self.assertEquals(a, range(NUM_THREADS))
prefork_lives = self.alive.copy()
if sys.platform in ['unixware7']:
cpid = os.fork1()
else:
cpid = os.fork()
if cpid == 0:
# Child
time.sleep(LONGSLEEP)
n = 0
for key in self.alive:
if self.alive[key] != prefork_lives[key]:
n += 1
os._exit(n)
else:
# Parent
self.wait_impl(cpid)
# Tell threads to die
self.stop = 1
time.sleep(2*SHORTSLEEP) # Wait for threads to die

1547
sys/lib/python/test/greyrgb.uue
View file

File diff suppressed because it is too large Load diff

7
sys/lib/python/test/infinite_reload.py
View file

@ -1,7 +0,0 @@
# For testing http://python.org/sf/742342, which reports that Python
# segfaults (infinite recursion in C) in the presence of infinite
# reload()ing. This module is imported by test_import.py:test_infinite_reload
# to make sure this doesn't happen any more.
import infinite_reload
reload(infinite_reload)

56
sys/lib/python/test/inspect_fodder.py
View file

@ -1,56 +0,0 @@
# line 1
'A module docstring.'
import sys, inspect
# line 5
# line 7
def spam(a, b, c, d=3, (e, (f,))=(4, (5,)), *g, **h):
eggs(b + d, c + f)
# line 11
def eggs(x, y):
"A docstring."
global fr, st
fr = inspect.currentframe()
st = inspect.stack()
p = x
q = y / 0
# line 20
class StupidGit:
"""A longer,
indented
docstring."""
# line 27
def abuse(self, a, b, c):
"""Another
\tdocstring
containing
\ttabs
\t
"""
self.argue(a, b, c)
# line 40
def argue(self, a, b, c):
try:
spam(a, b, c)
except:
self.ex = sys.exc_info()
self.tr = inspect.trace()
# line 48
class MalodorousPervert(StupidGit):
pass
class ParrotDroppings:
pass
class FesteringGob(MalodorousPervert, ParrotDroppings):
pass

99
sys/lib/python/test/inspect_fodder2.py
View file

@ -1,99 +0,0 @@
# line 1
def wrap(foo=None):
def wrapper(func):
return func
return wrapper
# line 7
def replace(func):
def insteadfunc():
print 'hello'
return insteadfunc
# line 13
@wrap()
@wrap(wrap)
def wrapped():
pass
# line 19
@replace
def gone():
pass
# line 24
oll = lambda m: m
# line 27
tll = lambda g: g and \
g and \
g
# line 32
tlli = lambda d: d and \
d
# line 36
def onelinefunc(): pass
# line 39
def manyargs(arg1, arg2,
arg3, arg4): pass
# line 43
def twolinefunc(m): return m and \
m
# line 47
a = [None,
lambda x: x,
None]
# line 52
def setfunc(func):
globals()["anonymous"] = func
setfunc(lambda x, y: x*y)
# line 57
def with_comment(): # hello
world
# line 61
multiline_sig = [
lambda (x,
y): x+y,
None,
]
# line 68
def func69():
class cls70:
def func71():
pass
return cls70
extra74 = 74
# line 76
def func77(): pass
(extra78, stuff78) = 'xy'
extra79 = 'stop'
# line 81
class cls82:
def func83(): pass
(extra84, stuff84) = 'xy'
extra85 = 'stop'
# line 87
def func88():
# comment
return 90
# line 92
def f():
class X:
def g():
"doc"
return 42
return X
method_in_dynamic_class = f().g.im_func

32
sys/lib/python/test/leakers/README.txt
View file

@ -1,32 +0,0 @@
This directory contains test cases that are known to leak references.
The idea is that you can import these modules while in the interpreter
and call the leak function repeatedly. This will only be helpful if
the interpreter was built in debug mode. If the total ref count
doesn't increase, the bug has been fixed and the file should be removed
from the repository.
Note: be careful to check for cyclic garbage. Sometimes it may be helpful
to define the leak function like:
def leak():
def inner_leak():
# this is the function that leaks, but also creates cycles
inner_leak()
gc.collect() ; gc.collect() ; gc.collect()
Here's an example interpreter session for test_gestalt which still leaks:
>>> from test.leakers.test_gestalt import leak
[24275 refs]
>>> leak()
[28936 refs]
>>> leak()
[28938 refs]
>>> leak()
[28940 refs]
>>>
Once the leak is fixed, the test case should be moved into an appropriate
test (even if it was originally from the test suite). This ensures the
regression doesn't happen again. And if it does, it should be easier
to track down.

0
sys/lib/python/test/leakers/__init__.py
View file

16
sys/lib/python/test/leakers/test_ctypes.py
View file

@ -1,16 +0,0 @@
# Taken from Lib/ctypes/test/test_keeprefs.py, PointerToStructure.test().
# When this leak is fixed, remember to remove from Misc/build.sh LEAKY_TESTS.
from ctypes import Structure, c_int, POINTER
import gc
def leak_inner():
class POINT(Structure):
_fields_ = [("x", c_int)]
class RECT(Structure):
_fields_ = [("a", POINTER(POINT))]
def leak():
leak_inner()
gc.collect()

14
sys/lib/python/test/leakers/test_gestalt.py
View file

@ -1,14 +0,0 @@
import sys
if sys.platform != 'darwin':
raise ValueError, "This test only leaks on Mac OS X"
def leak():
# taken from platform._mac_ver_lookup()
from gestalt import gestalt
import MacOS
try:
gestalt('sysu')
except MacOS.Error:
pass

13
sys/lib/python/test/leakers/test_selftype.py
View file

@ -1,13 +0,0 @@
# Reference cycles involving only the ob_type field are rather uncommon
# but possible. Inspired by SF bug 1469629.
import gc
def leak():
class T(type):
pass
class U(type):
__metaclass__ = T
U.__class__ = U
del U
gc.collect(); gc.collect(); gc.collect()

522
sys/lib/python/test/list_tests.py
View file

@ -1,522 +0,0 @@
"""
Tests common to list and UserList.UserList
"""
import sys
import os
import unittest
from test import test_support, seq_tests
class CommonTest(seq_tests.CommonTest):
def test_init(self):
# Iterable arg is optional
self.assertEqual(self.type2test([]), self.type2test())
# Init clears previous values
a = self.type2test([1, 2, 3])
a.__init__()
self.assertEqual(a, self.type2test([]))
# Init overwrites previous values
a = self.type2test([1, 2, 3])
a.__init__([4, 5, 6])
self.assertEqual(a, self.type2test([4, 5, 6]))
# Mutables always return a new object
b = self.type2test(a)
self.assertNotEqual(id(a), id(b))
self.assertEqual(a, b)
def test_repr(self):
l0 = []
l2 = [0, 1, 2]
a0 = self.type2test(l0)
a2 = self.type2test(l2)
self.assertEqual(str(a0), str(l0))
self.assertEqual(repr(a0), repr(l0))
self.assertEqual(`a2`, `l2`)
self.assertEqual(str(a2), "[0, 1, 2]")
self.assertEqual(repr(a2), "[0, 1, 2]")
a2.append(a2)
a2.append(3)
self.assertEqual(str(a2), "[0, 1, 2, [...], 3]")
self.assertEqual(repr(a2), "[0, 1, 2, [...], 3]")
def test_print(self):
d = self.type2test(xrange(200))
d.append(d)
d.extend(xrange(200,400))
d.append(d)
d.append(400)
try:
fo = open(test_support.TESTFN, "wb")
print >> fo, d,
fo.close()
fo = open(test_support.TESTFN, "rb")
self.assertEqual(fo.read(), repr(d))
finally:
fo.close()
os.remove(test_support.TESTFN)
def test_set_subscript(self):
a = self.type2test(range(20))
self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 0), [1,2,3])
self.assertRaises(TypeError, a.__setitem__, slice(0, 10), 1)
self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 2), [1,2])
self.assertRaises(TypeError, a.__getitem__, 'x', 1)
a[slice(2,10,3)] = [1,2,3]
self.assertEqual(a, self.type2test([0, 1, 1, 3, 4, 2, 6, 7, 3,
9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19]))
def test_reversed(self):
a = self.type2test(range(20))
r = reversed(a)
self.assertEqual(list(r), self.type2test(range(19, -1, -1)))
self.assertRaises(StopIteration, r.next)
self.assertEqual(list(reversed(self.type2test())),
self.type2test())
def test_setitem(self):
a = self.type2test([0, 1])
a[0] = 0
a[1] = 100
self.assertEqual(a, self.type2test([0, 100]))
a[-1] = 200
self.assertEqual(a, self.type2test([0, 200]))
a[-2] = 100
self.assertEqual(a, self.type2test([100, 200]))
self.assertRaises(IndexError, a.__setitem__, -3, 200)
self.assertRaises(IndexError, a.__setitem__, 2, 200)
a = self.type2test([])
self.assertRaises(IndexError, a.__setitem__, 0, 200)
self.assertRaises(IndexError, a.__setitem__, -1, 200)
self.assertRaises(TypeError, a.__setitem__)
a = self.type2test([0,1,2,3,4])
a[0L] = 1
a[1L] = 2
a[2L] = 3
self.assertEqual(a, self.type2test([1,2,3,3,4]))
a[0] = 5
a[1] = 6
a[2] = 7
self.assertEqual(a, self.type2test([5,6,7,3,4]))
a[-2L] = 88
a[-1L] = 99
self.assertEqual(a, self.type2test([5,6,7,88,99]))
a[-2] = 8
a[-1] = 9
self.assertEqual(a, self.type2test([5,6,7,8,9]))
def test_delitem(self):
a = self.type2test([0, 1])
del a[1]
self.assertEqual(a, [0])
del a[0]
self.assertEqual(a, [])
a = self.type2test([0, 1])
del a[-2]
self.assertEqual(a, [1])
del a[-1]
self.assertEqual(a, [])
a = self.type2test([0, 1])
self.assertRaises(IndexError, a.__delitem__, -3)
self.assertRaises(IndexError, a.__delitem__, 2)
a = self.type2test([])
self.assertRaises(IndexError, a.__delitem__, 0)
self.assertRaises(TypeError, a.__delitem__)
def test_setslice(self):
l = [0, 1]
a = self.type2test(l)
for i in range(-3, 4):
a[:i] = l[:i]
self.assertEqual(a, l)
a2 = a[:]
a2[:i] = a[:i]
self.assertEqual(a2, a)
a[i:] = l[i:]
self.assertEqual(a, l)
a2 = a[:]
a2[i:] = a[i:]
self.assertEqual(a2, a)
for j in range(-3, 4):
a[i:j] = l[i:j]
self.assertEqual(a, l)
a2 = a[:]
a2[i:j] = a[i:j]
self.assertEqual(a2, a)
aa2 = a2[:]
aa2[:0] = [-2, -1]
self.assertEqual(aa2, [-2, -1, 0, 1])
aa2[0:] = []
self.assertEqual(aa2, [])
a = self.type2test([1, 2, 3, 4, 5])
a[:-1] = a
self.assertEqual(a, self.type2test([1, 2, 3, 4, 5, 5]))
a = self.type2test([1, 2, 3, 4, 5])
a[1:] = a
self.assertEqual(a, self.type2test([1, 1, 2, 3, 4, 5]))
a = self.type2test([1, 2, 3, 4, 5])
a[1:-1] = a
self.assertEqual(a, self.type2test([1, 1, 2, 3, 4, 5, 5]))
a = self.type2test([])
a[:] = tuple(range(10))
self.assertEqual(a, self.type2test(range(10)))
self.assertRaises(TypeError, a.__setslice__, 0, 1, 5)
self.assertRaises(TypeError, a.__setslice__)
def test_delslice(self):
a = self.type2test([0, 1])
del a[1:2]
del a[0:1]
self.assertEqual(a, self.type2test([]))
a = self.type2test([0, 1])
del a[1L:2L]
del a[0L:1L]
self.assertEqual(a, self.type2test([]))
a = self.type2test([0, 1])
del a[-2:-1]
self.assertEqual(a, self.type2test([1]))
a = self.type2test([0, 1])
del a[-2L:-1L]
self.assertEqual(a, self.type2test([1]))
a = self.type2test([0, 1])
del a[1:]
del a[:1]
self.assertEqual(a, self.type2test([]))
a = self.type2test([0, 1])
del a[1L:]
del a[:1L]
self.assertEqual(a, self.type2test([]))
a = self.type2test([0, 1])
del a[-1:]
self.assertEqual(a, self.type2test([0]))
a = self.type2test([0, 1])
del a[-1L:]
self.assertEqual(a, self.type2test([0]))
a = self.type2test([0, 1])
del a[:]
self.assertEqual(a, self.type2test([]))
def test_append(self):
a = self.type2test([])
a.append(0)
a.append(1)
a.append(2)
self.assertEqual(a, self.type2test([0, 1, 2]))
self.assertRaises(TypeError, a.append)
def test_extend(self):
a1 = self.type2test([0])
a2 = self.type2test((0, 1))
a = a1[:]
a.extend(a2)
self.assertEqual(a, a1 + a2)
a.extend(self.type2test([]))
self.assertEqual(a, a1 + a2)
a.extend(a)
self.assertEqual(a, self.type2test([0, 0, 1, 0, 0, 1]))
a = self.type2test("spam")
a.extend("eggs")
self.assertEqual(a, list("spameggs"))
self.assertRaises(TypeError, a.extend, None)
self.assertRaises(TypeError, a.extend)
def test_insert(self):
a = self.type2test([0, 1, 2])
a.insert(0, -2)
a.insert(1, -1)
a.insert(2, 0)
self.assertEqual(a, [-2, -1, 0, 0, 1, 2])
b = a[:]
b.insert(-2, "foo")
b.insert(-200, "left")
b.insert(200, "right")
self.assertEqual(b, self.type2test(["left",-2,-1,0,0,"foo",1,2,"right"]))
self.assertRaises(TypeError, a.insert)
def test_pop(self):
a = self.type2test([-1, 0, 1])
a.pop()
self.assertEqual(a, [-1, 0])
a.pop(0)
self.assertEqual(a, [0])
self.assertRaises(IndexError, a.pop, 5)
a.pop(0)
self.assertEqual(a, [])
self.assertRaises(IndexError, a.pop)
self.assertRaises(TypeError, a.pop, 42, 42)
a = self.type2test([0, 10, 20, 30, 40])
def test_remove(self):
a = self.type2test([0, 0, 1])
a.remove(1)
self.assertEqual(a, [0, 0])
a.remove(0)
self.assertEqual(a, [0])
a.remove(0)
self.assertEqual(a, [])
self.assertRaises(ValueError, a.remove, 0)
self.assertRaises(TypeError, a.remove)
class BadExc(Exception):
pass
class BadCmp:
def __eq__(self, other):
if other == 2:
raise BadExc()
return False
a = self.type2test([0, 1, 2, 3])
self.assertRaises(BadExc, a.remove, BadCmp())
class BadCmp2:
def __eq__(self, other):
raise BadExc()
d = self.type2test('abcdefghcij')
d.remove('c')
self.assertEqual(d, self.type2test('abdefghcij'))
d.remove('c')
self.assertEqual(d, self.type2test('abdefghij'))
self.assertRaises(ValueError, d.remove, 'c')
self.assertEqual(d, self.type2test('abdefghij'))
# Handle comparison errors
d = self.type2test(['a', 'b', BadCmp2(), 'c'])
e = self.type2test(d)
self.assertRaises(BadExc, d.remove, 'c')
for x, y in zip(d, e):
# verify that original order and values are retained.
self.assert_(x is y)
def test_count(self):
a = self.type2test([0, 1, 2])*3
self.assertEqual(a.count(0), 3)
self.assertEqual(a.count(1), 3)
self.assertEqual(a.count(3), 0)
self.assertRaises(TypeError, a.count)
class BadExc(Exception):
pass
class BadCmp:
def __eq__(self, other):
if other == 2:
raise BadExc()
return False
self.assertRaises(BadExc, a.count, BadCmp())
def test_index(self):
u = self.type2test([0, 1])
self.assertEqual(u.index(0), 0)
self.assertEqual(u.index(1), 1)
self.assertRaises(ValueError, u.index, 2)
u = self.type2test([-2, -1, 0, 0, 1, 2])
self.assertEqual(u.count(0), 2)
self.assertEqual(u.index(0), 2)
self.assertEqual(u.index(0, 2), 2)
self.assertEqual(u.index(-2, -10), 0)
self.assertEqual(u.index(0, 3), 3)
self.assertEqual(u.index(0, 3, 4), 3)
self.assertRaises(ValueError, u.index, 2, 0, -10)
self.assertRaises(TypeError, u.index)
class BadExc(Exception):
pass
class BadCmp:
def __eq__(self, other):
if other == 2:
raise BadExc()
return False
a = self.type2test([0, 1, 2, 3])
self.assertRaises(BadExc, a.index, BadCmp())
a = self.type2test([-2, -1, 0, 0, 1, 2])
self.assertEqual(a.index(0), 2)
self.assertEqual(a.index(0, 2), 2)
self.assertEqual(a.index(0, -4), 2)
self.assertEqual(a.index(-2, -10), 0)
self.assertEqual(a.index(0, 3), 3)
self.assertEqual(a.index(0, -3), 3)
self.assertEqual(a.index(0, 3, 4), 3)
self.assertEqual(a.index(0, -3, -2), 3)
self.assertEqual(a.index(0, -4*sys.maxint, 4*sys.maxint), 2)
self.assertRaises(ValueError, a.index, 0, 4*sys.maxint,-4*sys.maxint)
self.assertRaises(ValueError, a.index, 2, 0, -10)
a.remove(0)
self.assertRaises(ValueError, a.index, 2, 0, 4)
self.assertEqual(a, self.type2test([-2, -1, 0, 1, 2]))
# Test modifying the list during index's iteration
class EvilCmp:
def __init__(self, victim):
self.victim = victim
def __eq__(self, other):
del self.victim[:]
return False
a = self.type2test()
a[:] = [EvilCmp(a) for _ in xrange(100)]
# This used to seg fault before patch #1005778
self.assertRaises(ValueError, a.index, None)
def test_reverse(self):
u = self.type2test([-2, -1, 0, 1, 2])
u2 = u[:]
u.reverse()
self.assertEqual(u, [2, 1, 0, -1, -2])
u.reverse()
self.assertEqual(u, u2)
self.assertRaises(TypeError, u.reverse, 42)
def test_sort(self):
u = self.type2test([1, 0])
u.sort()
self.assertEqual(u, [0, 1])
u = self.type2test([2,1,0,-1,-2])
u.sort()
self.assertEqual(u, self.type2test([-2,-1,0,1,2]))
self.assertRaises(TypeError, u.sort, 42, 42)
def revcmp(a, b):
return cmp(b, a)
u.sort(revcmp)
self.assertEqual(u, self.type2test([2,1,0,-1,-2]))
# The following dumps core in unpatched Python 1.5:
def myComparison(x,y):
return cmp(x%3, y%7)
z = self.type2test(range(12))
z.sort(myComparison)
self.assertRaises(TypeError, z.sort, 2)
def selfmodifyingComparison(x,y):
z.append(1)
return cmp(x, y)
self.assertRaises(ValueError, z.sort, selfmodifyingComparison)
self.assertRaises(TypeError, z.sort, lambda x, y: 's')
self.assertRaises(TypeError, z.sort, 42, 42, 42, 42)
def test_slice(self):
u = self.type2test("spam")
u[:2] = "h"
self.assertEqual(u, list("ham"))
def test_iadd(self):
super(CommonTest, self).test_iadd()
u = self.type2test([0, 1])
u2 = u
u += [2, 3]
self.assert_(u is u2)
u = self.type2test("spam")
u += "eggs"
self.assertEqual(u, self.type2test("spameggs"))
self.assertRaises(TypeError, u.__iadd__, None)
def test_imul(self):
u = self.type2test([0, 1])
u *= 3
self.assertEqual(u, self.type2test([0, 1, 0, 1, 0, 1]))
u *= 0
self.assertEqual(u, self.type2test([]))
s = self.type2test([])
oldid = id(s)
s *= 10
self.assertEqual(id(s), oldid)
def test_extendedslicing(self):
# subscript
a = self.type2test([0,1,2,3,4])
# deletion
del a[::2]
self.assertEqual(a, self.type2test([1,3]))
a = self.type2test(range(5))
del a[1::2]
self.assertEqual(a, self.type2test([0,2,4]))
a = self.type2test(range(5))
del a[1::-2]
self.assertEqual(a, self.type2test([0,2,3,4]))
a = self.type2test(range(10))
del a[::1000]
self.assertEqual(a, self.type2test([1, 2, 3, 4, 5, 6, 7, 8, 9]))
# assignment
a = self.type2test(range(10))
a[::2] = [-1]*5
self.assertEqual(a, self.type2test([-1, 1, -1, 3, -1, 5, -1, 7, -1, 9]))
a = self.type2test(range(10))
a[::-4] = [10]*3
self.assertEqual(a, self.type2test([0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
a = self.type2test(range(4))
a[::-1] = a
self.assertEqual(a, self.type2test([3, 2, 1, 0]))
a = self.type2test(range(10))
b = a[:]
c = a[:]
a[2:3] = self.type2test(["two", "elements"])
b[slice(2,3)] = self.type2test(["two", "elements"])
c[2:3:] = self.type2test(["two", "elements"])
self.assertEqual(a, b)
self.assertEqual(a, c)
a = self.type2test(range(10))
a[::2] = tuple(range(5))
self.assertEqual(a, self.type2test([0, 1, 1, 3, 2, 5, 3, 7, 4, 9]))
def test_constructor_exception_handling(self):
# Bug #1242657
class F(object):
def __iter__(self):
yield 23
def __len__(self):
raise KeyboardInterrupt
self.assertRaises(KeyboardInterrupt, list, F())

672
sys/lib/python/test/mapping_tests.py
View file

@ -1,672 +0,0 @@
# tests common to dict and UserDict
import unittest
import UserDict
class BasicTestMappingProtocol(unittest.TestCase):
# This base class can be used to check that an object conforms to the
# mapping protocol
# Functions that can be useful to override to adapt to dictionary
# semantics
type2test = None # which class is being tested (overwrite in subclasses)
def _reference(self):
"""Return a dictionary of values which are invariant by storage
in the object under test."""
return {1:2, "key1":"value1", "key2":(1,2,3)}
def _empty_mapping(self):
"""Return an empty mapping object"""
return self.type2test()
def _full_mapping(self, data):
"""Return a mapping object with the value contained in data
dictionary"""
x = self._empty_mapping()
for key, value in data.items():
x[key] = value
return x
def __init__(self, *args, **kw):
unittest.TestCase.__init__(self, *args, **kw)
self.reference = self._reference().copy()
# A (key, value) pair not in the mapping
key, value = self.reference.popitem()
self.other = {key:value}
# A (key, value) pair in the mapping
key, value = self.reference.popitem()
self.inmapping = {key:value}
self.reference[key] = value
def test_read(self):
# Test for read only operations on mapping
p = self._empty_mapping()
p1 = dict(p) #workaround for singleton objects
d = self._full_mapping(self.reference)
if d is p:
p = p1
#Indexing
for key, value in self.reference.items():
self.assertEqual(d[key], value)
knownkey = self.other.keys()[0]
self.failUnlessRaises(KeyError, lambda:d[knownkey])
#len
self.assertEqual(len(p), 0)
self.assertEqual(len(d), len(self.reference))
#has_key
for k in self.reference:
self.assert_(d.has_key(k))
self.assert_(k in d)
for k in self.other:
self.failIf(d.has_key(k))
self.failIf(k in d)
#cmp
self.assertEqual(cmp(p,p), 0)
self.assertEqual(cmp(d,d), 0)
self.assertEqual(cmp(p,d), -1)
self.assertEqual(cmp(d,p), 1)
#__non__zero__
if p: self.fail("Empty mapping must compare to False")
if not d: self.fail("Full mapping must compare to True")
# keys(), items(), iterkeys() ...
def check_iterandlist(iter, lst, ref):
self.assert_(hasattr(iter, 'next'))
self.assert_(hasattr(iter, '__iter__'))
x = list(iter)
self.assert_(set(x)==set(lst)==set(ref))
check_iterandlist(d.iterkeys(), d.keys(), self.reference.keys())
check_iterandlist(iter(d), d.keys(), self.reference.keys())
check_iterandlist(d.itervalues(), d.values(), self.reference.values())
check_iterandlist(d.iteritems(), d.items(), self.reference.items())
#get
key, value = d.iteritems().next()
knownkey, knownvalue = self.other.iteritems().next()
self.assertEqual(d.get(key, knownvalue), value)
self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
self.failIf(knownkey in d)
def test_write(self):
# Test for write operations on mapping
p = self._empty_mapping()
#Indexing
for key, value in self.reference.items():
p[key] = value
self.assertEqual(p[key], value)
for key in self.reference.keys():
del p[key]
self.failUnlessRaises(KeyError, lambda:p[key])
p = self._empty_mapping()
#update
p.update(self.reference)
self.assertEqual(dict(p), self.reference)
items = p.items()
p = self._empty_mapping()
p.update(items)
self.assertEqual(dict(p), self.reference)
d = self._full_mapping(self.reference)
#setdefault
key, value = d.iteritems().next()
knownkey, knownvalue = self.other.iteritems().next()
self.assertEqual(d.setdefault(key, knownvalue), value)
self.assertEqual(d[key], value)
self.assertEqual(d.setdefault(knownkey, knownvalue), knownvalue)
self.assertEqual(d[knownkey], knownvalue)
#pop
self.assertEqual(d.pop(knownkey), knownvalue)
self.failIf(knownkey in d)
self.assertRaises(KeyError, d.pop, knownkey)
default = 909
d[knownkey] = knownvalue
self.assertEqual(d.pop(knownkey, default), knownvalue)
self.failIf(knownkey in d)
self.assertEqual(d.pop(knownkey, default), default)
#popitem
key, value = d.popitem()
self.failIf(key in d)
self.assertEqual(value, self.reference[key])
p=self._empty_mapping()
self.assertRaises(KeyError, p.popitem)
def test_constructor(self):
self.assertEqual(self._empty_mapping(), self._empty_mapping())
def test_bool(self):
self.assert_(not self._empty_mapping())
self.assert_(self.reference)
self.assert_(bool(self._empty_mapping()) is False)
self.assert_(bool(self.reference) is True)
def test_keys(self):
d = self._empty_mapping()
self.assertEqual(d.keys(), [])
d = self.reference
self.assert_(self.inmapping.keys()[0] in d.keys())
self.assert_(self.other.keys()[0] not in d.keys())
self.assertRaises(TypeError, d.keys, None)
def test_values(self):
d = self._empty_mapping()
self.assertEqual(d.values(), [])
self.assertRaises(TypeError, d.values, None)
def test_items(self):
d = self._empty_mapping()
self.assertEqual(d.items(), [])
self.assertRaises(TypeError, d.items, None)
def test_len(self):
d = self._empty_mapping()
self.assertEqual(len(d), 0)
def test_getitem(self):
d = self.reference
self.assertEqual(d[self.inmapping.keys()[0]], self.inmapping.values()[0])
self.assertRaises(TypeError, d.__getitem__)
def test_update(self):
# mapping argument
d = self._empty_mapping()
d.update(self.other)
self.assertEqual(d.items(), self.other.items())
# No argument
d = self._empty_mapping()
d.update()
self.assertEqual(d, self._empty_mapping())
# item sequence
d = self._empty_mapping()
d.update(self.other.items())
self.assertEqual(d.items(), self.other.items())
# Iterator
d = self._empty_mapping()
d.update(self.other.iteritems())
self.assertEqual(d.items(), self.other.items())
# FIXME: Doesn't work with UserDict
# self.assertRaises((TypeError, AttributeError), d.update, None)
self.assertRaises((TypeError, AttributeError), d.update, 42)
outerself = self
class SimpleUserDict:
def __init__(self):
self.d = outerself.reference
def keys(self):
return self.d.keys()
def __getitem__(self, i):
return self.d[i]
d.clear()
d.update(SimpleUserDict())
i1 = d.items()
i2 = self.reference.items()
i1.sort()
i2.sort()
self.assertEqual(i1, i2)
class Exc(Exception): pass
d = self._empty_mapping()
class FailingUserDict:
def keys(self):
raise Exc
self.assertRaises(Exc, d.update, FailingUserDict())
d.clear()
class FailingUserDict:
def keys(self):
class BogonIter:
def __init__(self):
self.i = 1
def __iter__(self):
return self
def next(self):
if self.i:
self.i = 0
return 'a'
raise Exc
return BogonIter()
def __getitem__(self, key):
return key
self.assertRaises(Exc, d.update, FailingUserDict())
class FailingUserDict:
def keys(self):
class BogonIter:
def __init__(self):
self.i = ord('a')
def __iter__(self):
return self
def next(self):
if self.i <= ord('z'):
rtn = chr(self.i)
self.i += 1
return rtn
raise StopIteration
return BogonIter()
def __getitem__(self, key):
raise Exc
self.assertRaises(Exc, d.update, FailingUserDict())
d = self._empty_mapping()
class badseq(object):
def __iter__(self):
return self
def next(self):
raise Exc()
self.assertRaises(Exc, d.update, badseq())
self.assertRaises(ValueError, d.update, [(1, 2, 3)])
# no test_fromkeys or test_copy as both os.environ and selves don't support it
def test_get(self):
d = self._empty_mapping()
self.assert_(d.get(self.other.keys()[0]) is None)
self.assertEqual(d.get(self.other.keys()[0], 3), 3)
d = self.reference
self.assert_(d.get(self.other.keys()[0]) is None)
self.assertEqual(d.get(self.other.keys()[0], 3), 3)
self.assertEqual(d.get(self.inmapping.keys()[0]), self.inmapping.values()[0])
self.assertEqual(d.get(self.inmapping.keys()[0], 3), self.inmapping.values()[0])
self.assertRaises(TypeError, d.get)
self.assertRaises(TypeError, d.get, None, None, None)
def test_setdefault(self):
d = self._empty_mapping()
self.assertRaises(TypeError, d.setdefault)
def test_popitem(self):
d = self._empty_mapping()
self.assertRaises(KeyError, d.popitem)
self.assertRaises(TypeError, d.popitem, 42)
def test_pop(self):
d = self._empty_mapping()
k, v = self.inmapping.items()[0]
d[k] = v
self.assertRaises(KeyError, d.pop, self.other.keys()[0])
self.assertEqual(d.pop(k), v)
self.assertEqual(len(d), 0)
self.assertRaises(KeyError, d.pop, k)
class TestMappingProtocol(BasicTestMappingProtocol):
def test_constructor(self):
BasicTestMappingProtocol.test_constructor(self)
self.assert_(self._empty_mapping() is not self._empty_mapping())
self.assertEqual(self.type2test(x=1, y=2), {"x": 1, "y": 2})
def test_bool(self):
BasicTestMappingProtocol.test_bool(self)
self.assert_(not self._empty_mapping())
self.assert_(self._full_mapping({"x": "y"}))
self.assert_(bool(self._empty_mapping()) is False)
self.assert_(bool(self._full_mapping({"x": "y"})) is True)
def test_keys(self):
BasicTestMappingProtocol.test_keys(self)
d = self._empty_mapping()
self.assertEqual(d.keys(), [])
d = self._full_mapping({'a': 1, 'b': 2})
k = d.keys()
self.assert_('a' in k)
self.assert_('b' in k)
self.assert_('c' not in k)
def test_values(self):
BasicTestMappingProtocol.test_values(self)
d = self._full_mapping({1:2})
self.assertEqual(d.values(), [2])
def test_items(self):
BasicTestMappingProtocol.test_items(self)
d = self._full_mapping({1:2})
self.assertEqual(d.items(), [(1, 2)])
def test_has_key(self):
d = self._empty_mapping()
self.assert_(not d.has_key('a'))
d = self._full_mapping({'a': 1, 'b': 2})
k = d.keys()
k.sort()
self.assertEqual(k, ['a', 'b'])
self.assertRaises(TypeError, d.has_key)
def test_contains(self):
d = self._empty_mapping()
self.assert_(not ('a' in d))
self.assert_('a' not in d)
d = self._full_mapping({'a': 1, 'b': 2})
self.assert_('a' in d)
self.assert_('b' in d)
self.assert_('c' not in d)
self.assertRaises(TypeError, d.__contains__)
def test_len(self):
BasicTestMappingProtocol.test_len(self)
d = self._full_mapping({'a': 1, 'b': 2})
self.assertEqual(len(d), 2)
def test_getitem(self):
BasicTestMappingProtocol.test_getitem(self)
d = self._full_mapping({'a': 1, 'b': 2})
self.assertEqual(d['a'], 1)
self.assertEqual(d['b'], 2)
d['c'] = 3
d['a'] = 4
self.assertEqual(d['c'], 3)
self.assertEqual(d['a'], 4)
del d['b']
self.assertEqual(d, {'a': 4, 'c': 3})
self.assertRaises(TypeError, d.__getitem__)
def test_clear(self):
d = self._full_mapping({1:1, 2:2, 3:3})
d.clear()
self.assertEqual(d, {})
self.assertRaises(TypeError, d.clear, None)
def test_update(self):
BasicTestMappingProtocol.test_update(self)
# mapping argument
d = self._empty_mapping()
d.update({1:100})
d.update({2:20})
d.update({1:1, 2:2, 3:3})
self.assertEqual(d, {1:1, 2:2, 3:3})
# no argument
d.update()
self.assertEqual(d, {1:1, 2:2, 3:3})
# keyword arguments
d = self._empty_mapping()
d.update(x=100)
d.update(y=20)
d.update(x=1, y=2, z=3)
self.assertEqual(d, {"x":1, "y":2, "z":3})
# item sequence
d = self._empty_mapping()
d.update([("x", 100), ("y", 20)])
self.assertEqual(d, {"x":100, "y":20})
# Both item sequence and keyword arguments
d = self._empty_mapping()
d.update([("x", 100), ("y", 20)], x=1, y=2)
self.assertEqual(d, {"x":1, "y":2})
# iterator
d = self._full_mapping({1:3, 2:4})
d.update(self._full_mapping({1:2, 3:4, 5:6}).iteritems())
self.assertEqual(d, {1:2, 2:4, 3:4, 5:6})
class SimpleUserDict:
def __init__(self):
self.d = {1:1, 2:2, 3:3}
def keys(self):
return self.d.keys()
def __getitem__(self, i):
return self.d[i]
d.clear()
d.update(SimpleUserDict())
self.assertEqual(d, {1:1, 2:2, 3:3})
def test_fromkeys(self):
self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
d = self._empty_mapping()
self.assert_(not(d.fromkeys('abc') is d))
self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0})
self.assertEqual(d.fromkeys([]), {})
def g():
yield 1
self.assertEqual(d.fromkeys(g()), {1:None})
self.assertRaises(TypeError, {}.fromkeys, 3)
class dictlike(self.type2test): pass
self.assertEqual(dictlike.fromkeys('a'), {'a':None})
self.assertEqual(dictlike().fromkeys('a'), {'a':None})
self.assert_(dictlike.fromkeys('a').__class__ is dictlike)
self.assert_(dictlike().fromkeys('a').__class__ is dictlike)
# FIXME: the following won't work with UserDict, because it's an old style class
# self.assert_(type(dictlike.fromkeys('a')) is dictlike)
class mydict(self.type2test):
def __new__(cls):
return UserDict.UserDict()
ud = mydict.fromkeys('ab')
self.assertEqual(ud, {'a':None, 'b':None})
# FIXME: the following won't work with UserDict, because it's an old style class
# self.assert_(isinstance(ud, UserDict.UserDict))
self.assertRaises(TypeError, dict.fromkeys)
class Exc(Exception): pass
class baddict1(self.type2test):
def __init__(self):
raise Exc()
self.assertRaises(Exc, baddict1.fromkeys, [1])
class BadSeq(object):
def __iter__(self):
return self
def next(self):
raise Exc()
self.assertRaises(Exc, self.type2test.fromkeys, BadSeq())
class baddict2(self.type2test):
def __setitem__(self, key, value):
raise Exc()
self.assertRaises(Exc, baddict2.fromkeys, [1])
def test_copy(self):
d = self._full_mapping({1:1, 2:2, 3:3})
self.assertEqual(d.copy(), {1:1, 2:2, 3:3})
d = self._empty_mapping()
self.assertEqual(d.copy(), d)
self.assert_(isinstance(d.copy(), d.__class__))
self.assertRaises(TypeError, d.copy, None)
def test_get(self):
BasicTestMappingProtocol.test_get(self)
d = self._empty_mapping()
self.assert_(d.get('c') is None)
self.assertEqual(d.get('c', 3), 3)
d = self._full_mapping({'a' : 1, 'b' : 2})
self.assert_(d.get('c') is None)
self.assertEqual(d.get('c', 3), 3)
self.assertEqual(d.get('a'), 1)
self.assertEqual(d.get('a', 3), 1)
def test_setdefault(self):
BasicTestMappingProtocol.test_setdefault(self)
d = self._empty_mapping()
self.assert_(d.setdefault('key0') is None)
d.setdefault('key0', [])
self.assert_(d.setdefault('key0') is None)
d.setdefault('key', []).append(3)
self.assertEqual(d['key'][0], 3)
d.setdefault('key', []).append(4)
self.assertEqual(len(d['key']), 2)
def test_popitem(self):
BasicTestMappingProtocol.test_popitem(self)
for copymode in -1, +1:
# -1: b has same structure as a
# +1: b is a.copy()
for log2size in range(12):
size = 2**log2size
a = self._empty_mapping()
b = self._empty_mapping()
for i in range(size):
a[repr(i)] = i
if copymode < 0:
b[repr(i)] = i
if copymode > 0:
b = a.copy()
for i in range(size):
ka, va = ta = a.popitem()
self.assertEqual(va, int(ka))
kb, vb = tb = b.popitem()
self.assertEqual(vb, int(kb))
self.assert_(not(copymode < 0 and ta != tb))
self.assert_(not a)
self.assert_(not b)
def test_pop(self):
BasicTestMappingProtocol.test_pop(self)
# Tests for pop with specified key
d = self._empty_mapping()
k, v = 'abc', 'def'
# verify longs/ints get same value when key > 32 bits (for 64-bit archs)
# see SF bug #689659
x = 4503599627370496L
y = 4503599627370496
h = self._full_mapping({x: 'anything', y: 'something else'})
self.assertEqual(h[x], h[y])
self.assertEqual(d.pop(k, v), v)
d[k] = v
self.assertEqual(d.pop(k, 1), v)
class TestHashMappingProtocol(TestMappingProtocol):
def test_getitem(self):
TestMappingProtocol.test_getitem(self)
class Exc(Exception): pass
class BadEq(object):
def __eq__(self, other):
raise Exc()
d = self._empty_mapping()
d[BadEq()] = 42
self.assertRaises(KeyError, d.__getitem__, 23)
class BadHash(object):
fail = False
def __hash__(self):
if self.fail:
raise Exc()
else:
return 42
d = self._empty_mapping()
x = BadHash()
d[x] = 42
x.fail = True
self.assertRaises(Exc, d.__getitem__, x)
def test_fromkeys(self):
TestMappingProtocol.test_fromkeys(self)
class mydict(self.type2test):
def __new__(cls):
return UserDict.UserDict()
ud = mydict.fromkeys('ab')
self.assertEqual(ud, {'a':None, 'b':None})
self.assert_(isinstance(ud, UserDict.UserDict))
def test_pop(self):
TestMappingProtocol.test_pop(self)
class Exc(Exception): pass
class BadHash(object):
fail = False
def __hash__(self):
if self.fail:
raise Exc()
else:
return 42
d = self._empty_mapping()
x = BadHash()
d[x] = 42
x.fail = True
self.assertRaises(Exc, d.pop, x)
def test_mutatingiteration(self):
d = self._empty_mapping()
d[1] = 1
try:
for i in d:
d[i+1] = 1
except RuntimeError:
pass
else:
self.fail("changing dict size during iteration doesn't raise Error")
def test_repr(self):
d = self._empty_mapping()
self.assertEqual(repr(d), '{}')
d[1] = 2
self.assertEqual(repr(d), '{1: 2}')
d = self._empty_mapping()
d[1] = d
self.assertEqual(repr(d), '{1: {...}}')
class Exc(Exception): pass
class BadRepr(object):
def __repr__(self):
raise Exc()
d = self._full_mapping({1: BadRepr()})
self.assertRaises(Exc, repr, d)
def test_le(self):
self.assert_(not (self._empty_mapping() < self._empty_mapping()))
self.assert_(not (self._full_mapping({1: 2}) < self._full_mapping({1L: 2L})))
class Exc(Exception): pass
class BadCmp(object):
def __eq__(self, other):
raise Exc()
d1 = self._full_mapping({BadCmp(): 1})
d2 = self._full_mapping({1: 1})
try:
d1 < d2
except Exc:
pass
else:
self.fail("< didn't raise Exc")
def test_setdefault(self):
TestMappingProtocol.test_setdefault(self)
class Exc(Exception): pass
class BadHash(object):
fail = False
def __hash__(self):
if self.fail:
raise Exc()
else:
return 42
d = self._empty_mapping()
x = BadHash()
d[x] = 42
x.fail = True
self.assertRaises(Exc, d.setdefault, x, [])

110
sys/lib/python/test/output/test_MimeWriter
View file

@ -1,110 +0,0 @@
test_MimeWriter
From: bwarsaw@cnri.reston.va.us
Date: Mon Feb 12 17:21:48 EST 1996
To: kss-submit@cnri.reston.va.us
MIME-Version: 1.0
Content-Type: multipart/knowbot;
boundary="801spam999";
version="0.1"
This is a multi-part message in MIME format.
--801spam999
Content-Type: multipart/knowbot-metadata;
boundary="802spam999"
--802spam999
Content-Type: message/rfc822
KP-Metadata-Type: simple
KP-Access: read-only
KPMD-Interpreter: python
KPMD-Interpreter-Version: 1.3
KPMD-Owner-Name: Barry Warsaw
KPMD-Owner-Rendezvous: bwarsaw@cnri.reston.va.us
KPMD-Home-KSS: kss.cnri.reston.va.us
KPMD-Identifier: hdl://cnri.kss/my_first_knowbot
KPMD-Launch-Date: Mon Feb 12 16:39:03 EST 1996
--802spam999
Content-Type: text/isl
KP-Metadata-Type: complex
KP-Metadata-Key: connection
KP-Access: read-only
KP-Connection-Description: Barry's Big Bass Business
KP-Connection-Id: B4
KP-Connection-Direction: client
INTERFACE Seller-1;
TYPE Seller = OBJECT
DOCUMENTATION "A simple Seller interface to test ILU"
METHODS
price():INTEGER,
END;
--802spam999
Content-Type: message/external-body;
access-type="URL";
URL="hdl://cnri.kss/generic-knowbot"
Content-Type: text/isl
KP-Metadata-Type: complex
KP-Metadata-Key: generic-interface
KP-Access: read-only
KP-Connection-Description: Generic Interface for All Knowbots
KP-Connection-Id: generic-kp
KP-Connection-Direction: client
--802spam999--
--801spam999
Content-Type: multipart/knowbot-code;
boundary="803spam999"
--803spam999
Content-Type: text/plain
KP-Module-Name: BuyerKP
class Buyer:
def __setup__(self, maxprice):
self._maxprice = maxprice
def __main__(self, kos):
"""Entry point upon arrival at a new KOS."""
broker = kos.broker()
# B4 == Barry's Big Bass Business :-)
seller = broker.lookup('Seller_1.Seller', 'B4')
if seller:
price = seller.price()
print 'Seller wants $', price, '... '
if price > self._maxprice:
print 'too much!'
else:
print "I'll take it!"
else:
print 'no seller found here'
--803spam999--
--801spam999
Content-Type: multipart/knowbot-state;
boundary="804spam999"
KP-Main-Module: main
--804spam999
Content-Type: text/plain
KP-Module-Name: main
# instantiate a buyer instance and put it in a magic place for the KOS
# to find.
__kp__ = Buyer()
__kp__.__setup__(500)
--804spam999--
--801spam999--

79
sys/lib/python/test/output/test_cProfile
View file

@ -1,79 +0,0 @@
test_cProfile
126 function calls (106 primitive calls) in 1.000 CPU seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 1.000 1.000 <string>:1(<module>)
8 0.064 0.008 0.080 0.010 test_cProfile.py:103(subhelper)
28 0.028 0.001 0.028 0.001 test_cProfile.py:115(__getattr__)
1 0.270 0.270 1.000 1.000 test_cProfile.py:30(testfunc)
23/3 0.150 0.007 0.170 0.057 test_cProfile.py:40(factorial)
20 0.020 0.001 0.020 0.001 test_cProfile.py:53(mul)
2 0.040 0.020 0.600 0.300 test_cProfile.py:60(helper)
4 0.116 0.029 0.120 0.030 test_cProfile.py:78(helper1)
2 0.000 0.000 0.140 0.070 test_cProfile.py:89(helper2_indirect)
8 0.312 0.039 0.400 0.050 test_cProfile.py:93(helper2)
12 0.000 0.000 0.012 0.001 {hasattr}
4 0.000 0.000 0.000 0.000 {method 'append' of 'list' objects}
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
8 0.000 0.000 0.000 0.000 {range}
4 0.000 0.000 0.000 0.000 {sys.exc_info}
Ordered by: standard name
Function called...
ncalls tottime cumtime
<string>:1(<module>) -> 1 0.270 1.000 test_cProfile.py:30(testfunc)
test_cProfile.py:103(subhelper) -> 16 0.016 0.016 test_cProfile.py:115(__getattr__)
8 0.000 0.000 {range}
test_cProfile.py:115(__getattr__) ->
test_cProfile.py:30(testfunc) -> 1 0.014 0.130 test_cProfile.py:40(factorial)
2 0.040 0.600 test_cProfile.py:60(helper)
test_cProfile.py:40(factorial) -> 20/3 0.130 0.147 test_cProfile.py:40(factorial)
20 0.020 0.020 test_cProfile.py:53(mul)
test_cProfile.py:53(mul) ->
test_cProfile.py:60(helper) -> 4 0.116 0.120 test_cProfile.py:78(helper1)
2 0.000 0.140 test_cProfile.py:89(helper2_indirect)
6 0.234 0.300 test_cProfile.py:93(helper2)
test_cProfile.py:78(helper1) -> 4 0.000 0.004 {hasattr}
4 0.000 0.000 {method 'append' of 'list' objects}
4 0.000 0.000 {sys.exc_info}
test_cProfile.py:89(helper2_indirect) -> 2 0.006 0.040 test_cProfile.py:40(factorial)
2 0.078 0.100 test_cProfile.py:93(helper2)
test_cProfile.py:93(helper2) -> 8 0.064 0.080 test_cProfile.py:103(subhelper)
8 0.000 0.008 {hasattr}
{hasattr} -> 12 0.012 0.012 test_cProfile.py:115(__getattr__)
{method 'append' of 'list' objects} ->
{method 'disable' of '_lsprof.Profiler' objects} ->
{range} ->
{sys.exc_info} ->
Ordered by: standard name
Function was called by...
ncalls tottime cumtime
<string>:1(<module>) <-
test_cProfile.py:103(subhelper) <- 8 0.064 0.080 test_cProfile.py:93(helper2)
test_cProfile.py:115(__getattr__) <- 16 0.016 0.016 test_cProfile.py:103(subhelper)
12 0.012 0.012 {hasattr}
test_cProfile.py:30(testfunc) <- 1 0.270 1.000 <string>:1(<module>)
test_cProfile.py:40(factorial) <- 1 0.014 0.130 test_cProfile.py:30(testfunc)
20/3 0.130 0.147 test_cProfile.py:40(factorial)
2 0.006 0.040 test_cProfile.py:89(helper2_indirect)
test_cProfile.py:53(mul) <- 20 0.020 0.020 test_cProfile.py:40(factorial)
test_cProfile.py:60(helper) <- 2 0.040 0.600 test_cProfile.py:30(testfunc)
test_cProfile.py:78(helper1) <- 4 0.116 0.120 test_cProfile.py:60(helper)
test_cProfile.py:89(helper2_indirect) <- 2 0.000 0.140 test_cProfile.py:60(helper)
test_cProfile.py:93(helper2) <- 6 0.234 0.300 test_cProfile.py:60(helper)
2 0.078 0.100 test_cProfile.py:89(helper2_indirect)
{hasattr} <- 4 0.000 0.004 test_cProfile.py:78(helper1)
8 0.000 0.008 test_cProfile.py:93(helper2)
{method 'append' of 'list' objects} <- 4 0.000 0.000 test_cProfile.py:78(helper1)
{method 'disable' of '_lsprof.Profiler' objects} <-
{range} <- 8 0.000 0.000 test_cProfile.py:103(subhelper)
{sys.exc_info} <- 4 0.000 0.000 test_cProfile.py:78(helper1)

42
sys/lib/python/test/output/test_cgi
View file

@ -1,42 +0,0 @@
test_cgi
'' => []
'&' => []
'&&' => []
'=' => [('', '')]
'=a' => [('', 'a')]
'a' => [('a', '')]
'a=' => [('a', '')]
'a=' => [('a', '')]
'&a=b' => [('a', 'b')]
'a=a+b&b=b+c' => [('a', 'a b'), ('b', 'b c')]
'a=1&a=2' => [('a', '1'), ('a', '2')]
''
'&'
'&&'
';'
';&;'
'='
'=&='
'=;='
'=a'
'&=a'
'=a&'
'=&a'
'b=a'
'b+=a'
'a=b=a'
'a=+b=a'
'&b=a'
'b&=a'
'a=a+b&b=b+c'
'a=a+b&a=b+a'
'x=1&y=2.0&z=2-3.%2b0'
'x=1;y=2.0&z=2-3.%2b0'
'x=1;y=2.0;z=2-3.%2b0'
'Hbc5161168c542333633315dee1182227:key_store_seqid=400006&cuyer=r&view=bustomer&order_id=0bb2e248638833d48cb7fed300000f1b&expire=964546263&lobale=en-US&kid=130003.300038&ss=env'
'group_id=5470&set=custom&_assigned_to=31392&_status=1&_category=100&SUBMIT=Browse'
Testing log
Testing initlog 1
Testing log 2
Test FieldStorage methods that use readline
Test basic FieldStorage multipart parsing

101
sys/lib/python/test/output/test_class
View file

@ -1,101 +0,0 @@
test_class
__init__: ()
__coerce__: (1,)
__add__: (1,)
__coerce__: (1,)
__radd__: (1,)
__coerce__: (1,)
__sub__: (1,)
__coerce__: (1,)
__rsub__: (1,)
__coerce__: (1,)
__mul__: (1,)
__coerce__: (1,)
__rmul__: (1,)
__coerce__: (1,)
__div__: (1,)
__coerce__: (1,)
__rdiv__: (1,)
__coerce__: (1,)
__mod__: (1,)
__coerce__: (1,)
__rmod__: (1,)
__coerce__: (1,)
__divmod__: (1,)
__coerce__: (1,)
__rdivmod__: (1,)
__coerce__: (1,)
__pow__: (1,)
__coerce__: (1,)
__rpow__: (1,)
__coerce__: (1,)
__rshift__: (1,)
__coerce__: (1,)
__rrshift__: (1,)
__coerce__: (1,)
__lshift__: (1,)
__coerce__: (1,)
__rlshift__: (1,)
__coerce__: (1,)
__and__: (1,)
__coerce__: (1,)
__rand__: (1,)
__coerce__: (1,)
__or__: (1,)
__coerce__: (1,)
__ror__: (1,)
__coerce__: (1,)
__xor__: (1,)
__coerce__: (1,)
__rxor__: (1,)
__contains__: (1,)
__getitem__: (1,)
__setitem__: (1, 1)
__delitem__: (1,)
__getslice__: (0, 42)
__setslice__: (0, 42, 'The Answer')
__delslice__: (0, 42)
__getitem__: (slice(2, 1024, 10),)
__setitem__: (slice(2, 1024, 10), 'A lot')
__delitem__: (slice(2, 1024, 10),)
__getitem__: ((slice(None, 42, None), Ellipsis, slice(None, 24, None), 24, 100),)
__setitem__: ((slice(None, 42, None), Ellipsis, slice(None, 24, None), 24, 100), 'Strange')
__delitem__: ((slice(None, 42, None), Ellipsis, slice(None, 24, None), 24, 100),)
__getitem__: (slice(0, 42, None),)
__setitem__: (slice(0, 42, None), 'The Answer')
__delitem__: (slice(0, 42, None),)
__neg__: ()
__pos__: ()
__abs__: ()
__int__: ()
__long__: ()
__float__: ()
__oct__: ()
__hex__: ()
__hash__: ()
__repr__: ()
__str__: ()
__coerce__: (1,)
__cmp__: (1,)
__coerce__: (1,)
__cmp__: (1,)
__coerce__: (1,)
__cmp__: (1,)
__coerce__: (1,)
__cmp__: (1,)
__coerce__: (1,)
__cmp__: (1,)
__coerce__: (1,)
__cmp__: (1,)
__coerce__: (1,)
__cmp__: (1,)
__coerce__: (1,)
__cmp__: (1,)
__coerce__: (1,)
__cmp__: (1,)
__coerce__: (1,)
__cmp__: (1,)
__del__: ()
__getattr__: ('spam',)
__setattr__: ('eggs', 'spam, spam, spam and ham')
__delattr__: ('cardinal',)

32
sys/lib/python/test/output/test_cookie
View file

@ -1,32 +0,0 @@
test_cookie
<SimpleCookie: chips='ahoy' vienna='finger'>
Set-Cookie: chips=ahoy
Set-Cookie: vienna=finger
chips 'ahoy' 'ahoy'
Set-Cookie: chips=ahoy
vienna 'finger' 'finger'
Set-Cookie: vienna=finger
<SimpleCookie: keebler='E=mc2; L="Loves"; fudge=\n;'>
Set-Cookie: keebler="E=mc2; L=\"Loves\"; fudge=\012;"
keebler 'E=mc2; L="Loves"; fudge=\n;' 'E=mc2; L="Loves"; fudge=\n;'
Set-Cookie: keebler="E=mc2; L=\"Loves\"; fudge=\012;"
<SimpleCookie: keebler='E=mc2'>
Set-Cookie: keebler=E=mc2
keebler 'E=mc2' 'E=mc2'
Set-Cookie: keebler=E=mc2
Set-Cookie: Customer="WILE_E_COYOTE"; Path=/acme
<script type="text/javascript">
<!-- begin hiding
document.cookie = "Customer="WILE_E_COYOTE"; Path=/acme; Version=1";
// end hiding -->
</script>
<script type="text/javascript">
<!-- begin hiding
document.cookie = "Customer="WILE_E_COYOTE"; Path=/acme";
// end hiding -->
</script>
If anything blows up after this line, it's from Cookie's doctest.

112
sys/lib/python/test/output/test_extcall
View file

@ -1,112 +0,0 @@
test_extcall
() {}
(1,) {}
(1, 2) {}
(1, 2, 3) {}
(1, 2, 3, 4, 5) {}
(1, 2, 3, 4, 5) {}
(1, 2, 3, 4, 5) {}
(1, 2, 3) {'a': 4, 'b': 5}
(1, 2, 3, 4, 5) {'a': 6, 'b': 7}
(1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}
TypeError: g() takes at least 1 argument (0 given)
TypeError: g() takes at least 1 argument (0 given)
TypeError: g() takes at least 1 argument (0 given)
1 () {}
1 (2,) {}
1 (2, 3) {}
1 (2, 3, 4, 5) {}
0 (1, 2) {}
0 (1, 2, 3) {}
1 () {'a': 1, 'b': 2, 'c': 3, 'd': 4}
{'a': 1, 'b': 2, 'c': 3}
{'a': 1, 'b': 2, 'c': 3}
g() got multiple values for keyword argument 'x'
g() got multiple values for keyword argument 'b'
f() keywords must be strings
h() got an unexpected keyword argument 'e'
h() argument after * must be a sequence
dir() argument after * must be a sequence
NoneType object argument after * must be a sequence
h() argument after ** must be a dictionary
dir() argument after ** must be a dictionary
NoneType object argument after ** must be a dictionary
dir() got multiple values for keyword argument 'b'
3 512 True
3
3
za () {} -> za() takes exactly 1 argument (0 given)
za () {'a': 'aa'} -> ok za aa B D E V a
za () {'d': 'dd'} -> za() got an unexpected keyword argument 'd'
za () {'a': 'aa', 'd': 'dd'} -> za() got an unexpected keyword argument 'd'
za () {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> za() got an unexpected keyword argument 'b'
za (1, 2) {} -> za() takes exactly 1 argument (2 given)
za (1, 2) {'a': 'aa'} -> za() takes exactly 1 non-keyword argument (2 given)
za (1, 2) {'d': 'dd'} -> za() takes exactly 1 non-keyword argument (2 given)
za (1, 2) {'a': 'aa', 'd': 'dd'} -> za() takes exactly 1 non-keyword argument (2 given)
za (1, 2) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> za() takes exactly 1 non-keyword argument (2 given)
za (1, 2, 3, 4, 5) {} -> za() takes exactly 1 argument (5 given)
za (1, 2, 3, 4, 5) {'a': 'aa'} -> za() takes exactly 1 non-keyword argument (5 given)
za (1, 2, 3, 4, 5) {'d': 'dd'} -> za() takes exactly 1 non-keyword argument (5 given)
za (1, 2, 3, 4, 5) {'a': 'aa', 'd': 'dd'} -> za() takes exactly 1 non-keyword argument (5 given)
za (1, 2, 3, 4, 5) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> za() takes exactly 1 non-keyword argument (5 given)
zade () {} -> zade() takes at least 1 argument (0 given)
zade () {'a': 'aa'} -> ok zade aa B d e V a
zade () {'d': 'dd'} -> zade() takes at least 1 non-keyword argument (0 given)
zade () {'a': 'aa', 'd': 'dd'} -> ok zade aa B dd e V d
zade () {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zade() got an unexpected keyword argument 'b'
zade (1, 2) {} -> ok zade 1 B 2 e V e
zade (1, 2) {'a': 'aa'} -> zade() got multiple values for keyword argument 'a'
zade (1, 2) {'d': 'dd'} -> zade() got multiple values for keyword argument 'd'
zade (1, 2) {'a': 'aa', 'd': 'dd'} -> zade() got multiple values for keyword argument 'a'
zade (1, 2) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zade() got multiple values for keyword argument 'a'
zade (1, 2, 3, 4, 5) {} -> zade() takes at most 3 arguments (5 given)
zade (1, 2, 3, 4, 5) {'a': 'aa'} -> zade() takes at most 3 non-keyword arguments (5 given)
zade (1, 2, 3, 4, 5) {'d': 'dd'} -> zade() takes at most 3 non-keyword arguments (5 given)
zade (1, 2, 3, 4, 5) {'a': 'aa', 'd': 'dd'} -> zade() takes at most 3 non-keyword arguments (5 given)
zade (1, 2, 3, 4, 5) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zade() takes at most 3 non-keyword arguments (5 given)
zabk () {} -> zabk() takes exactly 2 arguments (0 given)
zabk () {'a': 'aa'} -> zabk() takes exactly 2 non-keyword arguments (1 given)
zabk () {'d': 'dd'} -> zabk() takes exactly 2 non-keyword arguments (0 given)
zabk () {'a': 'aa', 'd': 'dd'} -> zabk() takes exactly 2 non-keyword arguments (1 given)
zabk () {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> ok zabk aa bb D E V {'d': 'dd', 'e': 'ee'}
zabk (1, 2) {} -> ok zabk 1 2 D E V {}
zabk (1, 2) {'a': 'aa'} -> zabk() got multiple values for keyword argument 'a'
zabk (1, 2) {'d': 'dd'} -> ok zabk 1 2 D E V {'d': 'dd'}
zabk (1, 2) {'a': 'aa', 'd': 'dd'} -> zabk() got multiple values for keyword argument 'a'
zabk (1, 2) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabk() got multiple values for keyword argument 'a'
zabk (1, 2, 3, 4, 5) {} -> zabk() takes exactly 2 arguments (5 given)
zabk (1, 2, 3, 4, 5) {'a': 'aa'} -> zabk() takes exactly 2 non-keyword arguments (5 given)
zabk (1, 2, 3, 4, 5) {'d': 'dd'} -> zabk() takes exactly 2 non-keyword arguments (5 given)
zabk (1, 2, 3, 4, 5) {'a': 'aa', 'd': 'dd'} -> zabk() takes exactly 2 non-keyword arguments (5 given)
zabk (1, 2, 3, 4, 5) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabk() takes exactly 2 non-keyword arguments (5 given)
zabdv () {} -> zabdv() takes at least 2 arguments (0 given)
zabdv () {'a': 'aa'} -> zabdv() takes at least 2 non-keyword arguments (1 given)
zabdv () {'d': 'dd'} -> zabdv() takes at least 2 non-keyword arguments (0 given)
zabdv () {'a': 'aa', 'd': 'dd'} -> zabdv() takes at least 2 non-keyword arguments (1 given)
zabdv () {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabdv() got an unexpected keyword argument 'e'
zabdv (1, 2) {} -> ok zabdv 1 2 d E () e
zabdv (1, 2) {'a': 'aa'} -> zabdv() got multiple values for keyword argument 'a'
zabdv (1, 2) {'d': 'dd'} -> ok zabdv 1 2 dd E () d
zabdv (1, 2) {'a': 'aa', 'd': 'dd'} -> zabdv() got multiple values for keyword argument 'a'
zabdv (1, 2) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabdv() got multiple values for keyword argument 'a'
zabdv (1, 2, 3, 4, 5) {} -> ok zabdv 1 2 3 E (4, 5) e
zabdv (1, 2, 3, 4, 5) {'a': 'aa'} -> zabdv() got multiple values for keyword argument 'a'
zabdv (1, 2, 3, 4, 5) {'d': 'dd'} -> zabdv() got multiple values for keyword argument 'd'
zabdv (1, 2, 3, 4, 5) {'a': 'aa', 'd': 'dd'} -> zabdv() got multiple values for keyword argument 'a'
zabdv (1, 2, 3, 4, 5) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabdv() got multiple values for keyword argument 'a'
zabdevk () {} -> zabdevk() takes at least 2 arguments (0 given)
zabdevk () {'a': 'aa'} -> zabdevk() takes at least 2 non-keyword arguments (1 given)
zabdevk () {'d': 'dd'} -> zabdevk() takes at least 2 non-keyword arguments (0 given)
zabdevk () {'a': 'aa', 'd': 'dd'} -> zabdevk() takes at least 2 non-keyword arguments (1 given)
zabdevk () {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> ok zabdevk aa bb dd ee () {}
zabdevk (1, 2) {} -> ok zabdevk 1 2 d e () {}
zabdevk (1, 2) {'a': 'aa'} -> zabdevk() got multiple values for keyword argument 'a'
zabdevk (1, 2) {'d': 'dd'} -> ok zabdevk 1 2 dd e () {}
zabdevk (1, 2) {'a': 'aa', 'd': 'dd'} -> zabdevk() got multiple values for keyword argument 'a'
zabdevk (1, 2) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabdevk() got multiple values for keyword argument 'a'
zabdevk (1, 2, 3, 4, 5) {} -> ok zabdevk 1 2 3 4 (5,) {}
zabdevk (1, 2, 3, 4, 5) {'a': 'aa'} -> zabdevk() got multiple values for keyword argument 'a'
zabdevk (1, 2, 3, 4, 5) {'d': 'dd'} -> zabdevk() got multiple values for keyword argument 'd'
zabdevk (1, 2, 3, 4, 5) {'a': 'aa', 'd': 'dd'} -> zabdevk() got multiple values for keyword argument 'a'
zabdevk (1, 2, 3, 4, 5) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabdevk() got multiple values for keyword argument 'a'

4
sys/lib/python/test/output/test_frozen
View file

@ -1,4 +0,0 @@
test_frozen
Hello world...
Hello world...
Hello world...

5
sys/lib/python/test/output/test_global
View file

@ -1,5 +0,0 @@
test_global
got SyntaxError as expected
got SyntaxError as expected
got SyntaxError as expected
as expected, no SyntaxError

69
sys/lib/python/test/output/test_grammar
View file

@ -1,69 +0,0 @@
test_grammar
1. Parser
1.1 Tokens
1.1.1 Backslashes
1.1.2 Numeric literals
1.1.2.1 Plain integers
1.1.2.2 Long integers
1.1.2.3 Floating point
1.1.3 String literals
1.2 Grammar
single_input
file_input
expr_input
eval_input
funcdef
lambdef
simple_stmt
expr_stmt
print_stmt
1 2 3
1 2 3
1 1 1
extended print_stmt
1 2 3
1 2 3
1 1 1
hello world
del_stmt
pass_stmt
flow_stmt
break_stmt
continue_stmt
continue + try/except ok
continue + try/finally ok
testing continue and break in try/except in loop
return_stmt
yield_stmt
raise_stmt
import_name
import_from
global_stmt
exec_stmt
assert_stmt
if_stmt
while_stmt
for_stmt
try_stmt
suite
test
comparison
binary mask ops
shift ops
additive ops
multiplicative ops
unary ops
selectors
[1, (1,), (1, 2), (1, 2, 3)]
atoms
classdef
['Apple', 'Banana', 'Coco nut']
[3, 6, 9, 12, 15]
[3, 4, 5]
[(1, 'Apple'), (1, 'Banana'), (1, 'Coconut'), (2, 'Apple'), (2, 'Banana'), (2, 'Coconut'), (3, 'Apple'), (3, 'Banana'), (3, 'Coconut'), (4, 'Apple'), (4, 'Banana'), (4, 'Coconut'), (5, 'Apple'), (5, 'Banana'), (5, 'Coconut')]
[(1, 'Banana'), (1, 'Coconut'), (2, 'Banana'), (2, 'Coconut'), (3, 'Banana'), (3, 'Coconut'), (4, 'Banana'), (4, 'Coconut'), (5, 'Banana'), (5, 'Coconut')]
[[1], [1, 1], [1, 2, 4], [1, 3, 9, 27], [1, 4, 16, 64, 256]]
[False, False, False]
[[1, 2], [3, 4], [5, 6]]
[('Boeing', 'Airliner'), ('Boeing', 'Engine'), ('Ford', 'Engine'), ('Macdonalds', 'Cheeseburger')]

13
sys/lib/python/test/output/test_httplib
View file

@ -1,13 +0,0 @@
test_httplib
reply: 'HTTP/1.1 200 Ok\r\n'
Text
reply: 'HTTP/1.1 400.100 Not Ok\r\n'
BadStatusLine raised as expected
InvalidURL raised as expected
InvalidURL raised as expected
reply: 'HTTP/1.1 200 OK\r\n'
header: Set-Cookie: Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"
header: Set-Cookie: Part_Number="Rocket_Launcher_0001"; Version="1"; Path="/acme"
reply: 'HTTP/1.1 200 OK\r\n'
header: Content-Length: 14432

7
sys/lib/python/test/output/test_linuxaudiodev
View file

@ -1,7 +0,0 @@
test_linuxaudiodev
expected rate >= 0, not -1
expected sample size >= 0, not -2
nchannels must be 1 or 2, not 3
unknown audio encoding: 177
for linear unsigned 16-bit little-endian audio, expected sample size 16, not 8
for linear unsigned 8-bit audio, expected sample size 8, not 16

525
sys/lib/python/test/output/test_logging
View file

@ -1,525 +0,0 @@
test_logging
-- log_test0 begin ---------------------------------------------------
CRITICAL:ERR:Message 0
ERROR:ERR:Message 1
CRITICAL:INF:Message 2
ERROR:INF:Message 3
WARNING:INF:Message 4
INFO:INF:Message 5
CRITICAL:INF.UNDEF:Message 6
ERROR:INF.UNDEF:Message 7
WARNING:INF.UNDEF:Message 8
INFO:INF.UNDEF:Message 9
CRITICAL:INF.ERR:Message 10
ERROR:INF.ERR:Message 11
CRITICAL:INF.ERR.UNDEF:Message 12
ERROR:INF.ERR.UNDEF:Message 13
CRITICAL:DEB:Message 14
ERROR:DEB:Message 15
WARNING:DEB:Message 16
INFO:DEB:Message 17
DEBUG:DEB:Message 18
CRITICAL:UNDEF:Message 19
ERROR:UNDEF:Message 20
WARNING:UNDEF:Message 21
INFO:UNDEF:Message 22
CRITICAL:INF.BADPARENT.UNDEF:Message 23
CRITICAL:INF.BADPARENT:Message 24
INFO:INF:Finish up, it's closing time. Messages should bear numbers 0 through 24.
-- log_test0 end ---------------------------------------------------
-- log_test1 begin ---------------------------------------------------
-- setting logging level to 'Boring' -----
Boring:root:This should only be seen at the 'Boring' logging level (or lower)
Chatterbox:root:This should only be seen at the 'Chatterbox' logging level (or lower)
Garrulous:root:This should only be seen at the 'Garrulous' logging level (or lower)
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Chatterbox' -----
Chatterbox:root:This should only be seen at the 'Chatterbox' logging level (or lower)
Garrulous:root:This should only be seen at the 'Garrulous' logging level (or lower)
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Garrulous' -----
Garrulous:root:This should only be seen at the 'Garrulous' logging level (or lower)
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Talkative' -----
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Verbose' -----
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Sociable' -----
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Effusive' -----
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Terse' -----
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Taciturn' -----
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Silent' -----
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- Filtering at handler level to SOCIABLE --
-- setting logging level to 'Boring' -----
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Chatterbox' -----
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Garrulous' -----
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Talkative' -----
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Verbose' -----
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Sociable' -----
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Effusive' -----
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Terse' -----
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Taciturn' -----
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Silent' -----
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- Filtering using GARRULOUS filter --
-- setting logging level to 'Boring' -----
Boring:root:This should only be seen at the 'Boring' logging level (or lower)
Chatterbox:root:This should only be seen at the 'Chatterbox' logging level (or lower)
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Chatterbox' -----
Chatterbox:root:This should only be seen at the 'Chatterbox' logging level (or lower)
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Garrulous' -----
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Talkative' -----
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Verbose' -----
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Sociable' -----
Sociable:root:This should only be seen at the 'Sociable' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Effusive' -----
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Terse' -----
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Taciturn' -----
Taciturn:root:This should only be seen at the 'Taciturn' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Silent' -----
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- Filtering using specific filter for SOCIABLE, TACITURN --
-- setting logging level to 'Boring' -----
Boring:root:This should only be seen at the 'Boring' logging level (or lower)
Chatterbox:root:This should only be seen at the 'Chatterbox' logging level (or lower)
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Chatterbox' -----
Chatterbox:root:This should only be seen at the 'Chatterbox' logging level (or lower)
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Garrulous' -----
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Talkative' -----
Talkative:root:This should only be seen at the 'Talkative' logging level (or lower)
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Verbose' -----
Verbose:root:This should only be seen at the 'Verbose' logging level (or lower)
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Sociable' -----
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Effusive' -----
Effusive:root:This should only be seen at the 'Effusive' logging level (or lower)
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Terse' -----
Terse:root:This should only be seen at the 'Terse' logging level (or lower)
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Taciturn' -----
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- setting logging level to 'Silent' -----
Silent:root:This should only be seen at the 'Silent' logging level (or lower)
-- log_test1 end ---------------------------------------------------
-- log_test2 begin ---------------------------------------------------
-- logging at DEBUG, nothing should be seen yet --
-- logging at INFO, nothing should be seen yet --
-- logging at WARNING, 3 messages should be seen --
DEBUG:root:Debug message
INFO:root:Info message
WARNING:root:Warn message
-- logging 0 at INFO, messages should be seen every 10 events --
-- logging 1 at INFO, messages should be seen every 10 events --
-- logging 2 at INFO, messages should be seen every 10 events --
-- logging 3 at INFO, messages should be seen every 10 events --
-- logging 4 at INFO, messages should be seen every 10 events --
-- logging 5 at INFO, messages should be seen every 10 events --
-- logging 6 at INFO, messages should be seen every 10 events --
-- logging 7 at INFO, messages should be seen every 10 events --
-- logging 8 at INFO, messages should be seen every 10 events --
-- logging 9 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 0
INFO:root:Info index = 1
INFO:root:Info index = 2
INFO:root:Info index = 3
INFO:root:Info index = 4
INFO:root:Info index = 5
INFO:root:Info index = 6
INFO:root:Info index = 7
INFO:root:Info index = 8
INFO:root:Info index = 9
-- logging 10 at INFO, messages should be seen every 10 events --
-- logging 11 at INFO, messages should be seen every 10 events --
-- logging 12 at INFO, messages should be seen every 10 events --
-- logging 13 at INFO, messages should be seen every 10 events --
-- logging 14 at INFO, messages should be seen every 10 events --
-- logging 15 at INFO, messages should be seen every 10 events --
-- logging 16 at INFO, messages should be seen every 10 events --
-- logging 17 at INFO, messages should be seen every 10 events --
-- logging 18 at INFO, messages should be seen every 10 events --
-- logging 19 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 10
INFO:root:Info index = 11
INFO:root:Info index = 12
INFO:root:Info index = 13
INFO:root:Info index = 14
INFO:root:Info index = 15
INFO:root:Info index = 16
INFO:root:Info index = 17
INFO:root:Info index = 18
INFO:root:Info index = 19
-- logging 20 at INFO, messages should be seen every 10 events --
-- logging 21 at INFO, messages should be seen every 10 events --
-- logging 22 at INFO, messages should be seen every 10 events --
-- logging 23 at INFO, messages should be seen every 10 events --
-- logging 24 at INFO, messages should be seen every 10 events --
-- logging 25 at INFO, messages should be seen every 10 events --
-- logging 26 at INFO, messages should be seen every 10 events --
-- logging 27 at INFO, messages should be seen every 10 events --
-- logging 28 at INFO, messages should be seen every 10 events --
-- logging 29 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 20
INFO:root:Info index = 21
INFO:root:Info index = 22
INFO:root:Info index = 23
INFO:root:Info index = 24
INFO:root:Info index = 25
INFO:root:Info index = 26
INFO:root:Info index = 27
INFO:root:Info index = 28
INFO:root:Info index = 29
-- logging 30 at INFO, messages should be seen every 10 events --
-- logging 31 at INFO, messages should be seen every 10 events --
-- logging 32 at INFO, messages should be seen every 10 events --
-- logging 33 at INFO, messages should be seen every 10 events --
-- logging 34 at INFO, messages should be seen every 10 events --
-- logging 35 at INFO, messages should be seen every 10 events --
-- logging 36 at INFO, messages should be seen every 10 events --
-- logging 37 at INFO, messages should be seen every 10 events --
-- logging 38 at INFO, messages should be seen every 10 events --
-- logging 39 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 30
INFO:root:Info index = 31
INFO:root:Info index = 32
INFO:root:Info index = 33
INFO:root:Info index = 34
INFO:root:Info index = 35
INFO:root:Info index = 36
INFO:root:Info index = 37
INFO:root:Info index = 38
INFO:root:Info index = 39
-- logging 40 at INFO, messages should be seen every 10 events --
-- logging 41 at INFO, messages should be seen every 10 events --
-- logging 42 at INFO, messages should be seen every 10 events --
-- logging 43 at INFO, messages should be seen every 10 events --
-- logging 44 at INFO, messages should be seen every 10 events --
-- logging 45 at INFO, messages should be seen every 10 events --
-- logging 46 at INFO, messages should be seen every 10 events --
-- logging 47 at INFO, messages should be seen every 10 events --
-- logging 48 at INFO, messages should be seen every 10 events --
-- logging 49 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 40
INFO:root:Info index = 41
INFO:root:Info index = 42
INFO:root:Info index = 43
INFO:root:Info index = 44
INFO:root:Info index = 45
INFO:root:Info index = 46
INFO:root:Info index = 47
INFO:root:Info index = 48
INFO:root:Info index = 49
-- logging 50 at INFO, messages should be seen every 10 events --
-- logging 51 at INFO, messages should be seen every 10 events --
-- logging 52 at INFO, messages should be seen every 10 events --
-- logging 53 at INFO, messages should be seen every 10 events --
-- logging 54 at INFO, messages should be seen every 10 events --
-- logging 55 at INFO, messages should be seen every 10 events --
-- logging 56 at INFO, messages should be seen every 10 events --
-- logging 57 at INFO, messages should be seen every 10 events --
-- logging 58 at INFO, messages should be seen every 10 events --
-- logging 59 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 50
INFO:root:Info index = 51
INFO:root:Info index = 52
INFO:root:Info index = 53
INFO:root:Info index = 54
INFO:root:Info index = 55
INFO:root:Info index = 56
INFO:root:Info index = 57
INFO:root:Info index = 58
INFO:root:Info index = 59
-- logging 60 at INFO, messages should be seen every 10 events --
-- logging 61 at INFO, messages should be seen every 10 events --
-- logging 62 at INFO, messages should be seen every 10 events --
-- logging 63 at INFO, messages should be seen every 10 events --
-- logging 64 at INFO, messages should be seen every 10 events --
-- logging 65 at INFO, messages should be seen every 10 events --
-- logging 66 at INFO, messages should be seen every 10 events --
-- logging 67 at INFO, messages should be seen every 10 events --
-- logging 68 at INFO, messages should be seen every 10 events --
-- logging 69 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 60
INFO:root:Info index = 61
INFO:root:Info index = 62
INFO:root:Info index = 63
INFO:root:Info index = 64
INFO:root:Info index = 65
INFO:root:Info index = 66
INFO:root:Info index = 67
INFO:root:Info index = 68
INFO:root:Info index = 69
-- logging 70 at INFO, messages should be seen every 10 events --
-- logging 71 at INFO, messages should be seen every 10 events --
-- logging 72 at INFO, messages should be seen every 10 events --
-- logging 73 at INFO, messages should be seen every 10 events --
-- logging 74 at INFO, messages should be seen every 10 events --
-- logging 75 at INFO, messages should be seen every 10 events --
-- logging 76 at INFO, messages should be seen every 10 events --
-- logging 77 at INFO, messages should be seen every 10 events --
-- logging 78 at INFO, messages should be seen every 10 events --
-- logging 79 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 70
INFO:root:Info index = 71
INFO:root:Info index = 72
INFO:root:Info index = 73
INFO:root:Info index = 74
INFO:root:Info index = 75
INFO:root:Info index = 76
INFO:root:Info index = 77
INFO:root:Info index = 78
INFO:root:Info index = 79
-- logging 80 at INFO, messages should be seen every 10 events --
-- logging 81 at INFO, messages should be seen every 10 events --
-- logging 82 at INFO, messages should be seen every 10 events --
-- logging 83 at INFO, messages should be seen every 10 events --
-- logging 84 at INFO, messages should be seen every 10 events --
-- logging 85 at INFO, messages should be seen every 10 events --
-- logging 86 at INFO, messages should be seen every 10 events --
-- logging 87 at INFO, messages should be seen every 10 events --
-- logging 88 at INFO, messages should be seen every 10 events --
-- logging 89 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 80
INFO:root:Info index = 81
INFO:root:Info index = 82
INFO:root:Info index = 83
INFO:root:Info index = 84
INFO:root:Info index = 85
INFO:root:Info index = 86
INFO:root:Info index = 87
INFO:root:Info index = 88
INFO:root:Info index = 89
-- logging 90 at INFO, messages should be seen every 10 events --
-- logging 91 at INFO, messages should be seen every 10 events --
-- logging 92 at INFO, messages should be seen every 10 events --
-- logging 93 at INFO, messages should be seen every 10 events --
-- logging 94 at INFO, messages should be seen every 10 events --
-- logging 95 at INFO, messages should be seen every 10 events --
-- logging 96 at INFO, messages should be seen every 10 events --
-- logging 97 at INFO, messages should be seen every 10 events --
-- logging 98 at INFO, messages should be seen every 10 events --
-- logging 99 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 90
INFO:root:Info index = 91
INFO:root:Info index = 92
INFO:root:Info index = 93
INFO:root:Info index = 94
INFO:root:Info index = 95
INFO:root:Info index = 96
INFO:root:Info index = 97
INFO:root:Info index = 98
INFO:root:Info index = 99
-- logging 100 at INFO, messages should be seen every 10 events --
-- logging 101 at INFO, messages should be seen every 10 events --
INFO:root:Info index = 100
INFO:root:Info index = 101
-- log_test2 end ---------------------------------------------------
-- log_test3 begin ---------------------------------------------------
Unfiltered...
INFO:a:Info 1
INFO:a.b:Info 2
INFO:a.c:Info 3
INFO:a.b.c:Info 4
INFO:a.b.c.d:Info 5
INFO:a.bb.c:Info 6
INFO:b:Info 7
INFO:b.a:Info 8
INFO:c.a.b:Info 9
INFO:a.bb:Info 10
Filtered with 'a.b'...
INFO:a.b:Info 2
INFO:a.b.c:Info 4
INFO:a.b.c.d:Info 5
-- log_test3 end ---------------------------------------------------
-- log_test4 begin ---------------------------------------------------
config0: ok.
config1: ok.
config2: <type 'exceptions.AttributeError'>
config3: <type 'exceptions.KeyError'>
-- log_test4 end ---------------------------------------------------
-- log_test5 begin ---------------------------------------------------
ERROR:root:just testing
<type 'exceptions.KeyError'>... Don't panic!
-- log_test5 end ---------------------------------------------------
-- logrecv output begin ---------------------------------------------------
ERR -> CRITICAL: Message 0 (via logrecv.tcp.ERR)
ERR -> ERROR: Message 1 (via logrecv.tcp.ERR)
INF -> CRITICAL: Message 2 (via logrecv.tcp.INF)
INF -> ERROR: Message 3 (via logrecv.tcp.INF)
INF -> WARNING: Message 4 (via logrecv.tcp.INF)
INF -> INFO: Message 5 (via logrecv.tcp.INF)
INF.UNDEF -> CRITICAL: Message 6 (via logrecv.tcp.INF.UNDEF)
INF.UNDEF -> ERROR: Message 7 (via logrecv.tcp.INF.UNDEF)
INF.UNDEF -> WARNING: Message 8 (via logrecv.tcp.INF.UNDEF)
INF.UNDEF -> INFO: Message 9 (via logrecv.tcp.INF.UNDEF)
INF.ERR -> CRITICAL: Message 10 (via logrecv.tcp.INF.ERR)
INF.ERR -> ERROR: Message 11 (via logrecv.tcp.INF.ERR)
INF.ERR.UNDEF -> CRITICAL: Message 12 (via logrecv.tcp.INF.ERR.UNDEF)
INF.ERR.UNDEF -> ERROR: Message 13 (via logrecv.tcp.INF.ERR.UNDEF)
DEB -> CRITICAL: Message 14 (via logrecv.tcp.DEB)
DEB -> ERROR: Message 15 (via logrecv.tcp.DEB)
DEB -> WARNING: Message 16 (via logrecv.tcp.DEB)
DEB -> INFO: Message 17 (via logrecv.tcp.DEB)
DEB -> DEBUG: Message 18 (via logrecv.tcp.DEB)
UNDEF -> CRITICAL: Message 19 (via logrecv.tcp.UNDEF)
UNDEF -> ERROR: Message 20 (via logrecv.tcp.UNDEF)
UNDEF -> WARNING: Message 21 (via logrecv.tcp.UNDEF)
UNDEF -> INFO: Message 22 (via logrecv.tcp.UNDEF)
INF.BADPARENT.UNDEF -> CRITICAL: Message 23 (via logrecv.tcp.INF.BADPARENT.UNDEF)
INF.BADPARENT -> CRITICAL: Message 24 (via logrecv.tcp.INF.BADPARENT)
INF -> INFO: Finish up, it's closing time. Messages should bear numbers 0 through 24. (via logrecv.tcp.INF)
-- logrecv output end ---------------------------------------------------

28
sys/lib/python/test/output/test_math
View file

@ -1,28 +0,0 @@
test_math
math module, testing with eps 1e-05
constants
acos
asin
atan
atan2
ceil
cos
cosh
degrees
exp
fabs
floor
fmod
frexp
hypot
ldexp
log
log10
modf
pow
radians
sin
sinh
sqrt
tan
tanh

38
sys/lib/python/test/output/test_mmap
View file

@ -1,38 +0,0 @@
test_mmap
<type 'mmap.mmap'>
Position of foo: 1.0 pages
Length of file: 2.0 pages
Contents of byte 0: '\x00'
Contents of first 3 bytes: '\x00\x00\x00'
Modifying file's content...
Contents of byte 0: '3'
Contents of first 3 bytes: '3\x00\x00'
Contents of second page: '\x00foobar\x00'
Regex match on mmap (page start, length of match): 1.0 6
Seek to zeroth byte
Seek to 42nd byte
Seek to last byte
Try to seek to negative position...
Try to seek beyond end of mmap...
Try to seek to negative position...
Attempting resize()
Creating 10 byte test data file.
Opening mmap with access=ACCESS_READ
Ensuring that readonly mmap can't be slice assigned.
Ensuring that readonly mmap can't be item assigned.
Ensuring that readonly mmap can't be write() to.
Ensuring that readonly mmap can't be write_byte() to.
Ensuring that readonly mmap can't be resized.
Opening mmap with size too big
Opening mmap with access=ACCESS_WRITE
Modifying write-through memory map.
Opening mmap with access=ACCESS_COPY
Modifying copy-on-write memory map.
Ensuring copy-on-write maps cannot be resized.
Ensuring invalid access parameter raises exception.
Try opening a bad file descriptor...
Ensuring that passing 0 as map length sets map size to current file size.
Ensuring that passing 0 as map length sets map size to current file size.
anonymous mmap.mmap(-1, PAGESIZE)...
Test passed

7
sys/lib/python/test/output/test_new
View file

@ -1,7 +0,0 @@
test_new
new.module()
new.classobj()
new.instance()
new.instancemethod()
new.function()
new.code()

2
sys/lib/python/test/output/test_nis
View file

@ -1,2 +0,0 @@
test_nis
nis.maps()

6
sys/lib/python/test/output/test_opcodes
View file

@ -1,6 +0,0 @@
test_opcodes
2. Opcodes
XXX Not yet fully implemented
2.1 try inside for loop
2.2 raise class exceptions
2.3 comparing function objects

2
sys/lib/python/test/output/test_openpty
View file

@ -1,2 +0,0 @@
test_openpty
Ping!

21
sys/lib/python/test/output/test_operations
View file

@ -1,21 +0,0 @@
test_operations
3. Operations
XXX Mostly not yet implemented
3.1 Dictionary lookups fail if __cmp__() raises an exception
raising error
d[x2] = 2: caught the RuntimeError outside
raising error
z = d[x2]: caught the RuntimeError outside
raising error
x2 in d: caught the RuntimeError outside
raising error
d.has_key(x2): caught the RuntimeError outside
raising error
d.get(x2): caught the RuntimeError outside
raising error
d.setdefault(x2, 42): caught the RuntimeError outside
raising error
d.pop(x2): caught the RuntimeError outside
raising error
d.update({x2: 2}): caught the RuntimeError outside
resize bugs not triggered.

2
sys/lib/python/test/output/test_ossaudiodev
View file

@ -1,2 +0,0 @@
test_ossaudiodev
playing test sound file (expected running time: 2.93 sec)

3
sys/lib/python/test/output/test_pep277
View file

@ -1,3 +0,0 @@
test_pep277
u'\xdf-\u66e8\u66e9\u66eb'
[u'Gr\xfc\xdf-Gott', u'abc', u'ascii', u'\u0393\u03b5\u03b9\u03ac-\u03c3\u03b1\u03c2', u'\u0417\u0434\u0440\u0430\u0432\u0441\u0442\u0432\u0443\u0439\u0442\u0435', u'\u05d4\u05e9\u05e7\u05e6\u05e5\u05e1', u'\u306b\u307d\u3093', u'\u66e8\u05e9\u3093\u0434\u0393\xdf', u'\u66e8\u66e9\u66eb']

Some files were not shown because too many files have changed in this diff Show more