[Python-checkins] r76950 - in python/branches/py3k: Lib/test/test_cmath.py
mark.dickinson
python-checkins at python.org
Sun Dec 20 21:37:57 CET 2009
Author: mark.dickinson
Date: Sun Dec 20 21:37:56 2009
New Revision: 76950
Log:
Merged revisions 76948 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r76948 | mark.dickinson | 2009-12-20 20:34:44 +0000 (Sun, 20 Dec 2009) | 3 lines
Issue #7554: Various fixups in test_cmath.py: remove code duplication,
use new-style formatting. Thanks Florent Xicluna for the patch.
........
Modified:
python/branches/py3k/ (props changed)
python/branches/py3k/Lib/test/test_cmath.py
Modified: python/branches/py3k/Lib/test/test_cmath.py
==============================================================================
--- python/branches/py3k/Lib/test/test_cmath.py (original)
+++ python/branches/py3k/Lib/test/test_cmath.py Sun Dec 20 21:37:56 2009
@@ -46,37 +46,6 @@
(INF, NAN)
]]
-def almostEqualF(a, b, rel_err=2e-15, abs_err = 5e-323):
- """Determine whether floating-point values a and b are equal to within
- a (small) rounding error. The default values for rel_err and
- abs_err are chosen to be suitable for platforms where a float is
- represented by an IEEE 754 double. They allow an error of between
- 9 and 19 ulps."""
-
- # special values testing
- if math.isnan(a):
- return math.isnan(b)
- if math.isinf(a):
- return a == b
-
- # if both a and b are zero, check whether they have the same sign
- # (in theory there are examples where it would be legitimate for a
- # and b to have opposite signs; in practice these hardly ever
- # occur).
- if not a and not b:
- return math.copysign(1., a) == math.copysign(1., b)
-
- # if a-b overflows, or b is infinite, return False. Again, in
- # theory there are examples where a is within a few ulps of the
- # max representable float, and then b could legitimately be
- # infinite. In practice these examples are rare.
- try:
- absolute_error = abs(b-a)
- except OverflowError:
- return False
- else:
- return absolute_error <= max(abs_err, rel_err * abs(a))
-
class CMathTests(unittest.TestCase):
# list of all functions in cmath
test_functions = [getattr(cmath, fname) for fname in [
@@ -93,47 +62,63 @@
def tearDown(self):
self.test_values.close()
- def rAssertAlmostEqual(self, a, b, rel_err = 2e-15, abs_err = 5e-323):
- """Check that two floating-point numbers are almost equal."""
+ def rAssertAlmostEqual(self, a, b, rel_err = 2e-15, abs_err = 5e-323,
+ msg=None):
+ """Fail if the two floating-point numbers are not almost equal.
+
+ Determine whether floating-point values a and b are equal to within
+ a (small) rounding error. The default values for rel_err and
+ abs_err are chosen to be suitable for platforms where a float is
+ represented by an IEEE 754 double. They allow an error of between
+ 9 and 19 ulps.
+ """
# special values testing
if math.isnan(a):
if math.isnan(b):
return
- self.fail("%s should be nan" % repr(b))
+ self.fail(msg or '{!r} should be nan'.format(b))
if math.isinf(a):
if a == b:
return
- self.fail("finite result where infinity excpected: "
- "expected %s, got %s" % (repr(a), repr(b)))
+ self.fail(msg or 'finite result where infinity expected: '
+ 'expected {!r}, got {!r}'.format(a, b))
+ # if both a and b are zero, check whether they have the same sign
+ # (in theory there are examples where it would be legitimate for a
+ # and b to have opposite signs; in practice these hardly ever
+ # occur).
if not a and not b:
- if math.atan2(a, -1.) != math.atan2(b, -1.):
- self.fail("zero has wrong sign: expected %s, got %s" %
- (repr(a), repr(b)))
-
- # test passes if either the absolute error or the relative
- # error is sufficiently small. The defaults amount to an
- # error of between 9 ulps and 19 ulps on an IEEE-754 compliant
- # machine.
-
+ if math.copysign(1., a) != math.copysign(1., b):
+ self.fail(msg or 'zero has wrong sign: expected {!r}, '
+ 'got {!r}'.format(a, b))
+
+ # if a-b overflows, or b is infinite, return False. Again, in
+ # theory there are examples where a is within a few ulps of the
+ # max representable float, and then b could legitimately be
+ # infinite. In practice these examples are rare.
try:
absolute_error = abs(b-a)
except OverflowError:
pass
else:
+ # test passes if either the absolute error or the relative
+ # error is sufficiently small. The defaults amount to an
+ # error of between 9 ulps and 19 ulps on an IEEE-754 compliant
+ # machine.
if absolute_error <= max(abs_err, rel_err * abs(a)):
return
- self.fail("%s and %s are not sufficiently close" % (repr(a), repr(b)))
+ self.fail(msg or
+ '{!r} and {!r} are not sufficiently close'.format(a, b))
def test_constants(self):
e_expected = 2.71828182845904523536
pi_expected = 3.14159265358979323846
self.assertAlmostEqual(cmath.pi, pi_expected, places=9,
- msg="cmath.pi is %s; should be %s" % (cmath.pi, pi_expected))
+ msg="cmath.pi is {}; should be {}".format(cmath.pi, pi_expected))
self.assertAlmostEqual(cmath.e, e_expected, places=9,
- msg="cmath.e is %s; should be %s" % (cmath.e, e_expected))
+ msg="cmath.e is {}; should be {}".format(cmath.e, e_expected))
def test_user_object(self):
# Test automatic calling of __complex__ and __float__ by cmath
@@ -323,8 +308,8 @@
except ValueError:
continue
else:
- test_str = "%s: %s(complex(%r, %r))" % (id, fn, ar, ai)
- self.fail('ValueError not raised in test %s' % test_str)
+ self.fail('ValueError not raised in test '
+ '{}: {}(complex({!r}, {!r}))'.format(id, fn, ar, ai))
if 'overflow' in flags:
try:
@@ -332,8 +317,8 @@
except OverflowError:
continue
else:
- test_str = "%s: %s(complex(%r, %r))" % (id, fn, ar, ai)
- self.fail('OverflowError not raised in test %s' % test_str)
+ self.fail('OverflowError not raised in test '
+ '{}: {}(complex({!r}, {!r}))'.format(id, fn, ar, ai))
actual = function(arg)
@@ -351,17 +336,19 @@
else:
real_abs_err = 5e-323
- if not (almostEqualF(expected.real, actual.real,
- abs_err = real_abs_err) and
- almostEqualF(expected.imag, actual.imag)):
- error_message = (
- "%s: %s(complex(%r, %r))\n" % (id, fn, ar, ai) +
- "Expected: complex(%r, %r)\n" %
- (expected.real, expected.imag) +
- "Received: complex(%r, %r)\n" %
- (actual.real, actual.imag) +
- "Received value insufficiently close to expected value.")
- self.fail(error_message)
+ error_message = (
+ '{}: {}(complex({!r}, {!r}))\n'
+ 'Expected: complex({!r}, {!r})\n'
+ 'Received: complex({!r}, {!r})\n'
+ 'Received value insufficiently close to expected value.'
+ ).format(id, fn, ar, ai,
+ expected.real, expected.imag,
+ actual.real, actual.imag)
+ self.rAssertAlmostEqual(expected.real, actual.real,
+ abs_err=real_abs_err,
+ msg=error_message)
+ self.rAssertAlmostEqual(expected.imag, actual.imag,
+ msg=error_message)
def assertCISEqual(self, a, b):
eps = 1E-7
More information about the Python-checkins
mailing list