traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Issue #10624: Use support.requires_IEEE_754 in all appropriate tests.

This commit is contained in:
Eric Smith 2010-12-04 15:17:38 +00:00
parent 932e49e394
commit 3ab08cadae
7 changed files with 30 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Lib/test/datetimetester.py
View File

@ -38,11 +38,6 @@ OTHERSTUFF = (10, 34.5, "abc", {}, [], ())
INF = float("inf") INF = float("inf")
NAN = float("nan") NAN = float("nan")
# decorator for skipping tests on non-IEEE 754 platforms
requires_IEEE_754 = unittest.skipUnless(
float.__getformat__("double").startswith("IEEE"),
"test requires IEEE 754 doubles")
############################################################################# #############################################################################
# module tests # module tests
@ -407,7 +402,7 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):
self.assertRaises(ZeroDivisionError, lambda: a / 0.0) self.assertRaises(ZeroDivisionError, lambda: a / 0.0)
self.assertRaises(TypeError, lambda: a / '') self.assertRaises(TypeError, lambda: a / '')
@requires_IEEE_754 @support.requires_IEEE_754
def test_disallowed_special(self): def test_disallowed_special(self):
a = timedelta(42) a = timedelta(42)
self.assertRaises(ValueError, a.__mul__, NAN) self.assertRaises(ValueError, a.__mul__, NAN)
@ -589,7 +584,7 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):
self.assertRaises(OverflowError, day.__truediv__, 1e-10) self.assertRaises(OverflowError, day.__truediv__, 1e-10)
self.assertRaises(OverflowError, day.__truediv__, 9e-10) self.assertRaises(OverflowError, day.__truediv__, 9e-10)
@requires_IEEE_754 @support.requires_IEEE_754
def _test_overflow_special(self): def _test_overflow_special(self):
day = timedelta(1) day = timedelta(1)
self.assertRaises(OverflowError, day.__mul__, INF) self.assertRaises(OverflowError, day.__mul__, INF)

14
Lib/test/test_cmath.py
View File

@ -1,5 +1,5 @@
from test.support import run_unittest from test.support import run_unittest, requires_IEEE_754
from test.test_math import parse_testfile, test_file, requires_IEEE_754 from test.test_math import parse_testfile, test_file
import unittest import unittest
import cmath, math import cmath, math
from cmath import phase, polar, rect, pi from cmath import phase, polar, rect, pi
@ -312,10 +312,8 @@ class CMathTests(unittest.TestCase):
self.rAssertAlmostEqual(math.log(v, base), z.real) self.rAssertAlmostEqual(math.log(v, base), z.real)
self.assertEqual(0., z.imag) self.assertEqual(0., z.imag)
@requires_IEEE_754
def test_specific_values(self): def test_specific_values(self):
if not float.__getformat__("double").startswith("IEEE"):
return
def rect_complex(z): def rect_complex(z):
"""Wrapped version of rect that accepts a complex number instead of """Wrapped version of rect that accepts a complex number instead of
two float arguments.""" two float arguments."""
@ -460,9 +458,11 @@ class CMathTests(unittest.TestCase):
self.assertEqual(abs(complex(INF, NAN)), INF) self.assertEqual(abs(complex(INF, NAN)), INF)
self.assertTrue(math.isnan(abs(complex(NAN, NAN)))) self.assertTrue(math.isnan(abs(complex(NAN, NAN))))
@requires_IEEE_754
def test_abs_overflows(self):
# result overflows # result overflows
if float.__getformat__("double").startswith("IEEE"): self.assertRaises(OverflowError, abs, complex(1.4e308, 1.4e308))
self.assertRaises(OverflowError, abs, complex(1.4e308, 1.4e308))
def assertCEqual(self, a, b): def assertCEqual(self, a, b):
eps = 1E-7 eps = 1E-7

21
Lib/test/test_complex.py
View File

@ -435,15 +435,14 @@ class ComplexTest(unittest.TestCase):
self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF)) self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF))
self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0)) self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0))
if float.__getformat__("double").startswith("IEEE"): @support.requires_IEEE_754
def test_plus_minus_0j(self): def test_plus_minus_0j(self):
# test that -0j and 0j literals are not identified # test that -0j and 0j literals are not identified
z1, z2 = 0j, -0j z1, z2 = 0j, -0j
self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.)) self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.))
self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.)) self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.))
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), @support.requires_IEEE_754
"test requires IEEE 754 doubles")
def test_negated_imaginary_literal(self): def test_negated_imaginary_literal(self):
z0 = -0j z0 = -0j
z1 = -7j z1 = -7j
@ -459,15 +458,13 @@ class ComplexTest(unittest.TestCase):
self.assertFloatsAreIdentical(z2.real, -0.0) self.assertFloatsAreIdentical(z2.real, -0.0)
self.assertFloatsAreIdentical(z2.imag, -INF) self.assertFloatsAreIdentical(z2.imag, -INF)
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), @support.requires_IEEE_754
"test requires IEEE 754 doubles")
def test_overflow(self): def test_overflow(self):
self.assertEqual(complex("1e500"), complex(INF, 0.0)) self.assertEqual(complex("1e500"), complex(INF, 0.0))
self.assertEqual(complex("-1e500j"), complex(0.0, -INF)) self.assertEqual(complex("-1e500j"), complex(0.0, -INF))
self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF)) self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF))
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), @support.requires_IEEE_754
"test requires IEEE 754 doubles")
def test_repr_roundtrip(self): def test_repr_roundtrip(self):
vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN] vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN]
vals += [-v for v in vals] vals += [-v for v in vals]

8
Lib/test/test_decimal.py
View File

@ -32,7 +32,8 @@ import pickle, copy
import unittest import unittest
from decimal import * from decimal import *
import numbers import numbers
from test.support import run_unittest, run_doctest, is_resource_enabled from test.support import (run_unittest, run_doctest, is_resource_enabled,
requires_IEEE_754)
from test.support import check_warnings from test.support import check_warnings
import random import random
try: try:
@ -61,11 +62,6 @@ def init():
) )
setcontext(DefaultTestContext) setcontext(DefaultTestContext)
# decorator for skipping tests on non-IEEE 754 platforms
requires_IEEE_754 = unittest.skipUnless(
float.__getformat__("double").startswith("IEEE"),
"test requires IEEE 754 doubles")
TESTDATADIR = 'decimaltestdata' TESTDATADIR = 'decimaltestdata'
if __name__ == '__main__': if __name__ == '__main__':
file = sys.argv[0] file = sys.argv[0]

16
Lib/test/test_float.py
View File

@ -16,10 +16,6 @@ requires_getformat = unittest.skipUnless(have_getformat,
"requires __getformat__") "requires __getformat__")
requires_setformat = unittest.skipUnless(hasattr(float, "__setformat__"), requires_setformat = unittest.skipUnless(hasattr(float, "__setformat__"),
"requires __setformat__") "requires __setformat__")
# decorator for skipping tests on non-IEEE 754 platforms
requires_IEEE_754 = unittest.skipUnless(have_getformat and
float.__getformat__("double").startswith("IEEE"),
"test requires IEEE 754 doubles")
#locate file with float format test values #locate file with float format test values
test_dir = os.path.dirname(__file__) or os.curdir test_dir = os.path.dirname(__file__) or os.curdir
@ -196,7 +192,7 @@ class GeneralFloatCases(unittest.TestCase):
# distingishes -0.0 and 0.0. # distingishes -0.0 and 0.0.
self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b))) self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b)))
@requires_IEEE_754 @support.requires_IEEE_754
def test_float_mod(self): def test_float_mod(self):
# Check behaviour of % operator for IEEE 754 special cases. # Check behaviour of % operator for IEEE 754 special cases.
# In particular, check signs of zeros. # In particular, check signs of zeros.
@ -216,7 +212,7 @@ class GeneralFloatCases(unittest.TestCase):
self.assertEqualAndEqualSign(mod(1e-100, -1.0), -1.0) self.assertEqualAndEqualSign(mod(1e-100, -1.0), -1.0)
self.assertEqualAndEqualSign(mod(1.0, -1.0), -0.0) self.assertEqualAndEqualSign(mod(1.0, -1.0), -0.0)
@requires_IEEE_754 @support.requires_IEEE_754
def test_float_pow(self): def test_float_pow(self):
# test builtin pow and ** operator for IEEE 754 special cases. # test builtin pow and ** operator for IEEE 754 special cases.
# Special cases taken from section F.9.4.4 of the C99 specification # Special cases taken from section F.9.4.4 of the C99 specification
@ -503,7 +499,7 @@ class UnknownFormatTestCase(unittest.TestCase):
class IEEEFormatTestCase(unittest.TestCase): class IEEEFormatTestCase(unittest.TestCase):
@requires_IEEE_754 @support.requires_IEEE_754
def test_double_specials_do_unpack(self): def test_double_specials_do_unpack(self):
for fmt, data in [('>d', BE_DOUBLE_INF), for fmt, data in [('>d', BE_DOUBLE_INF),
('>d', BE_DOUBLE_NAN), ('>d', BE_DOUBLE_NAN),
@ -511,7 +507,7 @@ class IEEEFormatTestCase(unittest.TestCase):
('<d', LE_DOUBLE_NAN)]: ('<d', LE_DOUBLE_NAN)]:
struct.unpack(fmt, data) struct.unpack(fmt, data)
@requires_IEEE_754 @support.requires_IEEE_754
def test_float_specials_do_unpack(self): def test_float_specials_do_unpack(self):
for fmt, data in [('>f', BE_FLOAT_INF), for fmt, data in [('>f', BE_FLOAT_INF),
('>f', BE_FLOAT_NAN), ('>f', BE_FLOAT_NAN),
@ -574,7 +570,7 @@ class FormatTestCase(unittest.TestCase):
self.assertEqual(format(INF, 'f'), 'inf') self.assertEqual(format(INF, 'f'), 'inf')
self.assertEqual(format(INF, 'F'), 'INF') self.assertEqual(format(INF, 'F'), 'INF')
@requires_IEEE_754 @support.requires_IEEE_754
def test_format_testfile(self): def test_format_testfile(self):
with open(format_testfile) as testfile: with open(format_testfile) as testfile:
for line in testfile: for line in testfile:
@ -658,7 +654,7 @@ class ReprTestCase(unittest.TestCase):
self.assertEqual(repr(float(s)), str(float(s))) self.assertEqual(repr(float(s)), str(float(s)))
self.assertEqual(repr(float(negs)), str(float(negs))) self.assertEqual(repr(float(negs)), str(float(negs)))
@requires_IEEE_754 @support.requires_IEEE_754
class RoundTestCase(unittest.TestCase): class RoundTestCase(unittest.TestCase):
def test_inf_nan(self): def test_inf_nan(self):

7
Lib/test/test_fractions.py
View File

@ -1,7 +1,7 @@
"""Tests for Lib/fractions.py.""" """Tests for Lib/fractions.py."""
from decimal import Decimal from decimal import Decimal
from test.support import run_unittest from test.support import run_unittest, requires_IEEE_754
import math import math
import numbers import numbers
import operator import operator
@ -12,11 +12,6 @@ from pickle import dumps, loads
F = fractions.Fraction F = fractions.Fraction
gcd = fractions.gcd gcd = fractions.gcd
# decorator for skipping tests on non-IEEE 754 platforms
requires_IEEE_754 = unittest.skipUnless(
float.__getformat__("double").startswith("IEEE"),
"test requires IEEE 754 doubles")
class DummyFloat(object): class DummyFloat(object):
"""Dummy float class for testing comparisons with Fractions""" """Dummy float class for testing comparisons with Fractions"""

11
Lib/test/test_long.py
View File

@ -1,5 +1,6 @@
import unittest import unittest
from test import support from test import support
import sys import sys
import random import random
@ -15,11 +16,6 @@ class Frm(object):
def __str__(self): def __str__(self):
return self.format % self.args return self.format % self.args
# decorator for skipping tests on non-IEEE 754 platforms
requires_IEEE_754 = unittest.skipUnless(
float.__getformat__("double").startswith("IEEE"),
"test requires IEEE 754 doubles")
# SHIFT should match the value in longintrepr.h for best testing. # SHIFT should match the value in longintrepr.h for best testing.
SHIFT = sys.int_info.bits_per_digit SHIFT = sys.int_info.bits_per_digit
BASE = 2 ** SHIFT BASE = 2 ** SHIFT
@ -371,8 +367,7 @@ class LongTest(unittest.TestCase):
return 1729 return 1729
self.assertEqual(int(LongTrunc()), 1729) self.assertEqual(int(LongTrunc()), 1729)
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), @support.requires_IEEE_754
"test requires IEEE 754 doubles")
def test_float_conversion(self): def test_float_conversion(self):
exact_values = [0, 1, 2, exact_values = [0, 1, 2,
@ -703,7 +698,7 @@ class LongTest(unittest.TestCase):
self.assertEqual(expected, got, "Incorrectly rounded division {}/{}: " self.assertEqual(expected, got, "Incorrectly rounded division {}/{}: "
"expected {}, got {}".format(a, b, expected, got)) "expected {}, got {}".format(a, b, expected, got))
@requires_IEEE_754 @support.requires_IEEE_754
def test_correctly_rounded_true_division(self): def test_correctly_rounded_true_division(self):
# more stringent tests than those above, checking that the # more stringent tests than those above, checking that the
# result of true division of ints is always correctly rounded. # result of true division of ints is always correctly rounded.