[pypy-svn] pypy default: Remove a good bit of nonsense from the complex tests.
alex_gaynor
commits-noreply at bitbucket.org
Sun Feb 13 06:04:46 CET 2011
Author: Alex Gaynor <alex.gaynor at gmail.com>
Branch:
Changeset: r41866:ada2e37a9123
Date: 2011-02-13 00:04 -0500
http://bitbucket.org/pypy/pypy/changeset/ada2e37a9123/
Log: Remove a good bit of nonsense from the complex tests.
diff --git a/pypy/objspace/std/test/test_complexobject.py b/pypy/objspace/std/test/test_complexobject.py
--- a/pypy/objspace/std/test/test_complexobject.py
+++ b/pypy/objspace/std/test/test_complexobject.py
@@ -84,19 +84,53 @@
class AppTestAppComplexTest:
- def setup_class(cls):
- # XXX these tests probably copied directly from CPython
- # please port them to pypy style :-/
- cls.w_helper = cls.space.appexec([], """
- ():
- import sys
- sys.path.append(%r)
- import helper
- return helper
- """ % (str(py.path.local(__file__).dirpath())))
+ def w_check_div(self, x, y):
+ """Compute complex z=x*y, and check that z/x==y and z/y==x."""
+ z = x * y
+ if x != 0:
+ q = z / x
+ assert self.close(q, y)
+ q = z.__div__(x)
+ assert self.close(q, y)
+ q = z.__truediv__(x)
+ assert self.close(q, y)
+ if y != 0:
+ q = z / y
+ assert self.close(q, x)
+ q = z.__div__(y)
+ assert self.close(q, x)
+ q = z.__truediv__(y)
+ assert self.close(q, x)
+
+ def w_close(self, x, y):
+ """Return true iff complexes x and y "are close\""""
+ return self.close_abs(x.real, y.real) and self.close_abs(x.imag, y.imag)
+
+ def w_close_abs(self, x, y, eps=1e-9):
+ """Return true iff floats x and y "are close\""""
+ # put the one with larger magnitude second
+ if abs(x) > abs(y):
+ x, y = y, x
+ if y == 0:
+ return abs(x) < eps
+ if x == 0:
+ return abs(y) < eps
+ # check that relative difference < eps
+ return abs((x - y) / y) < eps
+
+ def w_almost_equal(self, a, b, eps=1e-9):
+ if isinstance(a, complex):
+ if isinstance(b, complex):
+ return a.real - b.real < eps and a.imag - b.imag < eps
+ else:
+ return a.real - b < eps and a.imag < eps
+ else:
+ if isinstance(b, complex):
+ return a - b.real < eps and b.imag < eps
+ else:
+ return a - b < eps
def test_div(self):
- h = self.helper
from random import random
# XXX this test passed but took waaaaay to long
# look at dist/lib-python/modified-2.5.2/test/test_complex.py
@@ -105,47 +139,43 @@
simple_complex = [complex(x, y) for x in simple_real for y in simple_real]
for x in simple_complex:
for y in simple_complex:
- h.check_div(x, y)
+ self.check_div(x, y)
# A naive complex division algorithm (such as in 2.0) is very prone to
# nonsense errors for these (overflows and underflows).
- h.check_div(complex(1e200, 1e200), 1+0j)
- h.check_div(complex(1e-200, 1e-200), 1+0j)
+ self.check_div(complex(1e200, 1e200), 1+0j)
+ self.check_div(complex(1e-200, 1e-200), 1+0j)
# Just for fun.
for i in xrange(100):
- h.check_div(complex(random(), random()),
+ self.check_div(complex(random(), random()),
complex(random(), random()))
- h.raises(ZeroDivisionError, complex.__div__, 1+1j, 0+0j)
+ raises(ZeroDivisionError, complex.__div__, 1+1j, 0+0j)
# FIXME: The following currently crashes on Alpha
# raises(OverflowError, pow, 1e200+1j, 1e200+1j)
def test_truediv(self):
- h = self.helper
- h.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
+ assert self.almost_equal(complex.__truediv__(2+0j, 1+1j), 1-1j)
raises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)
def test_floordiv(self):
- h = self.helper
- h.assertAlmostEqual(complex.__floordiv__(3+0j, 1.5+0j), 2)
+ assert self.almost_equal(complex.__floordiv__(3+0j, 1.5+0j), 2)
raises(ZeroDivisionError, complex.__floordiv__, 3+0j, 0+0j)
def test_coerce(self):
- h = self.helper
- h.raises(OverflowError, complex.__coerce__, 1+1j, 1L<<10000)
+ raises(OverflowError, complex.__coerce__, 1+1j, 1L<<10000)
def test_richcompare(self):
- h = self.helper
- h.assertEqual(complex.__lt__(1+1j, None), NotImplemented)
- h.assertIs(complex.__eq__(1+1j, 1+1j), True)
- h.assertIs(complex.__eq__(1+1j, 2+2j), False)
- h.assertIs(complex.__ne__(1+1j, 1+1j), False)
- h.assertIs(complex.__ne__(1+1j, 2+2j), True)
- h.raises(TypeError, complex.__lt__, 1+1j, 2+2j)
- h.raises(TypeError, complex.__le__, 1+1j, 2+2j)
- h.raises(TypeError, complex.__gt__, 1+1j, 2+2j)
- h.raises(TypeError, complex.__ge__, 1+1j, 2+2j)
+ assert complex.__lt__(1+1j, None) is NotImplemented
+ assert complex.__eq__(1+1j, 2+2j) is False
+ assert complex.__eq__(1+1j, 1+1j) is True
+ assert complex.__ne__(1+1j, 1+1j) is False
+ assert complex.__ne__(1+1j, 2+2j) is True
+ raises(TypeError, complex.__lt__, 1+1j, 2+2j)
+ raises(TypeError, complex.__le__, 1+1j, 2+2j)
+ raises(TypeError, complex.__gt__, 1+1j, 2+2j)
+ raises(TypeError, complex.__ge__, 1+1j, 2+2j)
large = 1 << 10000
assert not (5+0j) == large
assert not large == (5+0j)
@@ -153,173 +183,156 @@
assert large != (5+0j)
def test_mod(self):
- h = self.helper
raises(ZeroDivisionError, (1+1j).__mod__, 0+0j)
a = 3.33+4.43j
- try:
- a % 0
- except ZeroDivisionError:
- pass
- else:
- self.fail("modulo parama can't be 0")
+ raises(ZeroDivisionError, "a % 0")
def test_divmod(self):
- h = self.helper
raises(ZeroDivisionError, divmod, 1+1j, 0+0j)
def test_pow(self):
- h = self.helper
- h.assertAlmostEqual(pow(1+1j, 0+0j), 1.0)
- h.assertAlmostEqual(pow(0+0j, 2+0j), 0.0)
+ assert self.almost_equal(pow(1+1j, 0+0j), 1.0)
+ assert self.almost_equal(pow(0+0j, 2+0j), 0.0)
raises(ZeroDivisionError, pow, 0+0j, 1j)
- h.assertAlmostEqual(pow(1j, -1), 1/1j)
- h.assertAlmostEqual(pow(1j, 200), 1)
+ assert self.almost_equal(pow(1j, -1), 1/1j)
+ assert self.almost_equal(pow(1j, 200), 1)
raises(ValueError, pow, 1+1j, 1+1j, 1+1j)
a = 3.33+4.43j
- h.assertEqual(a ** 0j, 1)
- h.assertEqual(a ** 0.+0.j, 1)
+ assert a ** 0j == 1
+ assert a ** 0.+0.j == 1
- h.assertEqual(3j ** 0j, 1)
- h.assertEqual(3j ** 0, 1)
+ assert 3j ** 0j == 1
+ assert 3j ** 0 == 1
- try:
- 0j ** a
- except ZeroDivisionError:
- pass
- else:
- self.fail("should fail 0.0 to negative or complex power")
-
- try:
- 0j ** (3-2j)
- except ZeroDivisionError:
- pass
- else:
- self.fail("should fail 0.0 to negative or complex power")
+ raises(ZeroDivisionError, "0j ** a")
+ raises(ZeroDivisionError, "0j ** (3-2j)")
# The following is used to exercise certain code paths
- h.assertEqual(a ** 105, a ** 105)
- h.assertEqual(a ** -105, a ** -105)
- h.assertEqual(a ** -30, a ** -30)
+ assert a ** 105 == a ** 105
+ assert a ** -105 == a ** -105
+ assert a ** -30 == a ** -30
- h.assertEqual(0.0j ** 0, 1)
+ assert 0.0j ** 0 == 1
b = 5.1+2.3j
- h.raises(ValueError, pow, a, b, 0)
+ raises(ValueError, pow, a, b, 0)
def test_boolcontext(self):
from random import random
- h = self.helper
for i in xrange(100):
assert complex(random() + 1e-6, random() + 1e-6)
assert not complex(0.0, 0.0)
def test_conjugate(self):
- h = self.helper
- h.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
+ assert self.close(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
def test_constructor(self):
- h = self.helper
class OS:
- def __init__(self, value): self.value = value
- def __complex__(self): return self.value
+ def __init__(self, value):
+ self.value = value
+ def __complex__(self):
+ return self.value
class NS(object):
- def __init__(self, value): self.value = value
- def __complex__(self): return self.value
- h.assertEqual(complex(OS(1+10j)), 1+10j)
- h.assertEqual(complex(NS(1+10j)), 1+10j)
- h.assertEqual(complex(OS(1+10j), 5), 1+15j)
- h.assertEqual(complex(NS(1+10j), 5), 1+15j)
- h.assertEqual(complex(OS(1+10j), 5j), -4+10j)
- h.assertEqual(complex(NS(1+10j), 5j), -4+10j)
- h.raises(TypeError, complex, OS(None))
- h.raises(TypeError, complex, NS(None))
- h.raises(TypeError, complex, OS(2.0)) # __complex__ must really
- h.raises(TypeError, complex, NS(2.0)) # return a complex, not a float
+ def __init__(self, value):
+ self.value = value
+ def __complex__(self):
+ return self.value
+ assert complex(OS(1+10j)) == 1+10j
+ assert complex(NS(1+10j)) == 1+10j
+ assert complex(OS(1+10j), 5) == 1+15j
+ assert complex(NS(1+10j), 5) == 1+15j
+ assert complex(OS(1+10j), 5j) == -4+10j
+ assert complex(NS(1+10j), 5j) == -4+10j
+ raises(TypeError, complex, OS(None))
+ raises(TypeError, complex, NS(None))
+ raises(TypeError, complex, OS(2.0)) # __complex__ must really
+ raises(TypeError, complex, NS(2.0)) # return a complex, not a float
# -- The following cases are not supported by CPython, but they
# -- are supported by PyPy, which is most probably ok
- #h.raises((TypeError, AttributeError), complex, OS(1+10j), OS(1+10j))
- #h.raises((TypeError, AttributeError), complex, NS(1+10j), OS(1+10j))
- #h.raises((TypeError, AttributeError), complex, OS(1+10j), NS(1+10j))
- #h.raises((TypeError, AttributeError), complex, NS(1+10j), NS(1+10j))
+ #raises((TypeError, AttributeError), complex, OS(1+10j), OS(1+10j))
+ #raises((TypeError, AttributeError), complex, NS(1+10j), OS(1+10j))
+ #raises((TypeError, AttributeError), complex, OS(1+10j), NS(1+10j))
+ #raises((TypeError, AttributeError), complex, NS(1+10j), NS(1+10j))
class F(object):
def __float__(self):
return 2.0
- h.assertEqual(complex(OS(1+10j), F()), 1+12j)
- h.assertEqual(complex(NS(1+10j), F()), 1+12j)
+ assert complex(OS(1+10j), F()) == 1+12j
+ assert complex(NS(1+10j), F()) == 1+12j
- h.assertAlmostEqual(complex("1+10j"), 1+10j)
- h.assertAlmostEqual(complex(10), 10+0j)
- h.assertAlmostEqual(complex(10.0), 10+0j)
- h.assertAlmostEqual(complex(10L), 10+0j)
- h.assertAlmostEqual(complex(10+0j), 10+0j)
- h.assertAlmostEqual(complex(1,10), 1+10j)
- h.assertAlmostEqual(complex(1,10L), 1+10j)
- h.assertAlmostEqual(complex(1,10.0), 1+10j)
- h.assertAlmostEqual(complex(1L,10), 1+10j)
- h.assertAlmostEqual(complex(1L,10L), 1+10j)
- h.assertAlmostEqual(complex(1L,10.0), 1+10j)
- h.assertAlmostEqual(complex(1.0,10), 1+10j)
- h.assertAlmostEqual(complex(1.0,10L), 1+10j)
- h.assertAlmostEqual(complex(1.0,10.0), 1+10j)
- h.assertAlmostEqual(complex(3.14+0j), 3.14+0j)
- h.assertAlmostEqual(complex(3.14), 3.14+0j)
- h.assertAlmostEqual(complex(314), 314.0+0j)
- h.assertAlmostEqual(complex(314L), 314.0+0j)
- h.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j)
- h.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j)
- h.assertAlmostEqual(complex(314, 0), 314.0+0j)
- h.assertAlmostEqual(complex(314L, 0L), 314.0+0j)
- h.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j)
- h.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j)
- h.assertAlmostEqual(complex(0j, 3.14), 3.14j)
- h.assertAlmostEqual(complex(0.0, 3.14), 3.14j)
- h.assertAlmostEqual(complex("1"), 1+0j)
- h.assertAlmostEqual(complex("1j"), 1j)
- h.assertAlmostEqual(complex(), 0)
- h.assertAlmostEqual(complex("-1"), -1)
- h.assertAlmostEqual(complex("+1"), +1)
- h.assertAlmostEqual(complex(" ( +3.14-6J )"), 3.14-6j)
+ assert self.almost_equal(complex("1+10j"), 1+10j)
+ assert self.almost_equal(complex(10), 10+0j)
+ assert self.almost_equal(complex(10.0), 10+0j)
+ assert self.almost_equal(complex(10L), 10+0j)
+ assert self.almost_equal(complex(10+0j), 10+0j)
+ assert self.almost_equal(complex(1,10), 1+10j)
+ assert self.almost_equal(complex(1,10L), 1+10j)
+ assert self.almost_equal(complex(1,10.0), 1+10j)
+ assert self.almost_equal(complex(1L,10), 1+10j)
+ assert self.almost_equal(complex(1L,10L), 1+10j)
+ assert self.almost_equal(complex(1L,10.0), 1+10j)
+ assert self.almost_equal(complex(1.0,10), 1+10j)
+ assert self.almost_equal(complex(1.0,10L), 1+10j)
+ assert self.almost_equal(complex(1.0,10.0), 1+10j)
+ assert self.almost_equal(complex(3.14+0j), 3.14+0j)
+ assert self.almost_equal(complex(3.14), 3.14+0j)
+ assert self.almost_equal(complex(314), 314.0+0j)
+ assert self.almost_equal(complex(314L), 314.0+0j)
+ assert self.almost_equal(complex(3.14+0j, 0j), 3.14+0j)
+ assert self.almost_equal(complex(3.14, 0.0), 3.14+0j)
+ assert self.almost_equal(complex(314, 0), 314.0+0j)
+ assert self.almost_equal(complex(314L, 0L), 314.0+0j)
+ assert self.almost_equal(complex(0j, 3.14j), -3.14+0j)
+ assert self.almost_equal(complex(0.0, 3.14j), -3.14+0j)
+ assert self.almost_equal(complex(0j, 3.14), 3.14j)
+ assert self.almost_equal(complex(0.0, 3.14), 3.14j)
+ assert self.almost_equal(complex("1"), 1+0j)
+ assert self.almost_equal(complex("1j"), 1j)
+ assert self.almost_equal(complex(), 0)
+ assert self.almost_equal(complex("-1"), -1)
+ assert self.almost_equal(complex("+1"), +1)
+ assert self.almost_equal(complex(" ( +3.14-6J )"), 3.14-6j)
- class complex2(complex): pass
- h.assertAlmostEqual(complex(complex2(1+1j)), 1+1j)
- h.assertAlmostEqual(complex(real=17, imag=23), 17+23j)
- h.assertAlmostEqual(complex(real=17+23j), 17+23j)
- h.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j)
- h.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j)
+ class complex2(complex):
+ pass
+ assert self.almost_equal(complex(complex2(1+1j)), 1+1j)
+ assert self.almost_equal(complex(real=17, imag=23), 17+23j)
+ assert self.almost_equal(complex(real=17+23j), 17+23j)
+ assert self.almost_equal(complex(real=17+23j, imag=23), 17+46j)
+ assert self.almost_equal(complex(real=1+2j, imag=3+4j), -3+5j)
c = 3.14 + 1j
assert complex(c) is c
del c
- h.raises(TypeError, complex, "1", "1")
- h.raises(TypeError, complex, 1, "1")
+ raises(TypeError, complex, "1", "1")
+ raises(TypeError, complex, 1, "1")
- h.assertEqual(complex(" 3.14+J "), 3.14+1j)
+ assert complex(" 3.14+J ") == 3.14+1j
#h.assertEqual(complex(unicode(" 3.14+J ")), 3.14+1j)
# SF bug 543840: complex(string) accepts strings with \0
# Fixed in 2.3.
- h.raises(ValueError, complex, '1+1j\0j')
+ raises(ValueError, complex, '1+1j\0j')
- h.raises(TypeError, int, 5+3j)
- h.raises(TypeError, long, 5+3j)
- h.raises(TypeError, float, 5+3j)
- h.raises(ValueError, complex, "")
- h.raises(TypeError, complex, None)
- h.raises(ValueError, complex, "\0")
- h.raises(TypeError, complex, "1", "2")
- h.raises(TypeError, complex, "1", 42)
- h.raises(TypeError, complex, 1, "2")
- h.raises(ValueError, complex, "1+")
- h.raises(ValueError, complex, "1+1j+1j")
- h.raises(ValueError, complex, "--")
+ raises(TypeError, int, 5+3j)
+ raises(TypeError, long, 5+3j)
+ raises(TypeError, float, 5+3j)
+ raises(ValueError, complex, "")
+ raises(TypeError, complex, None)
+ raises(ValueError, complex, "\0")
+ raises(TypeError, complex, "1", "2")
+ raises(TypeError, complex, "1", 42)
+ raises(TypeError, complex, 1, "2")
+ raises(ValueError, complex, "1+")
+ raises(ValueError, complex, "1+1j+1j")
+ raises(ValueError, complex, "--")
# if x_test_support.have_unicode:
-# h.raises(ValueError, complex, unicode("1"*500))
-# h.raises(ValueError, complex, unicode("x"))
+# raises(ValueError, complex, unicode("1"*500))
+# raises(ValueError, complex, unicode("x"))
#
class EvilExc(Exception):
pass
@@ -328,7 +341,7 @@
def __complex__(self):
raise EvilExc
- h.raises(EvilExc, complex, evilcomplex())
+ raises(EvilExc, complex, evilcomplex())
class float2:
def __init__(self, value):
@@ -336,29 +349,27 @@
def __float__(self):
return self.value
- h.assertAlmostEqual(complex(float2(42.)), 42)
- h.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j)
- h.raises(TypeError, complex, float2(None))
+ assert self.almost_equal(complex(float2(42.)), 42)
+ assert self.almost_equal(complex(real=float2(17.), imag=float2(23.)), 17+23j)
+ raises(TypeError, complex, float2(None))
def test_hash(self):
- h = self.helper
for x in xrange(-30, 30):
- h.assertEqual(hash(x), hash(complex(x, 0)))
+ assert hash(x) == hash(complex(x, 0))
x /= 3.0 # now check against floating point
- h.assertEqual(hash(x), hash(complex(x, 0.)))
+ assert hash(x) == hash(complex(x, 0.))
def test_abs(self):
- h = self.helper
nums = [complex(x/3., y/7.) for x in xrange(-9,9) for y in xrange(-9,9)]
for num in nums:
- h.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num))
+ assert self.almost_equal((num.real**2 + num.imag**2) ** 0.5, abs(num))
def test_complex_subclass_ctr(self):
import sys
class j(complex):
pass
assert j(100 + 0j) == 100 + 0j
- assert isinstance(j(100),j)
+ assert isinstance(j(100), j)
assert j(100L + 0j) == 100 + 0j
assert j("100 + 0j") == 100 + 0j
x = j(1+0j)
@@ -385,13 +396,12 @@
assert repr(complex(1,-float("nan"))) == '(1+nanj)'
def test_neg(self):
- h = self.helper
- h.assertEqual(-(1+6j), -1-6j)
+ assert -(1+6j) == -1-6j
def test_file(self):
- h = self.helper
import os
import tempfile
+
a = 3.33+4.43j
b = 5.1+2.3j
@@ -402,7 +412,8 @@
print >>fo, a, b
fo.close()
fo = open(pth, "rb")
- h.assertEqual(fo.read(), "%s %s\n" % (a, b))
+ res = fo.read()
+ assert res == "%s %s\n" % (a, b)
finally:
if (fo is not None) and (not fo.closed):
fo.close()
More information about the Pypy-commit
mailing list