[Python-checkins] python/dist/src/Lib/test test_builtin.py,1.20,1.21 test_complex.py,1.9,1.10
doerwalter@users.sourceforge.net
doerwalter@users.sourceforge.net
Wed, 18 Jun 2003 07:26:21 -0700
Update of /cvsroot/python/python/dist/src/Lib/test
In directory sc8-pr-cvs1:/tmp/cvs-serv1935/Lib/test
Modified Files:
test_builtin.py test_complex.py
Log Message:
Port test_complex.py to unittest.
Move the constructor tests from test_builtin to test_complex.
Add a bunch of tests (code coverage is a 94%).
>From SF patch #736962.
Index: test_builtin.py
===================================================================
RCS file: /cvsroot/python/python/dist/src/Lib/test/test_builtin.py,v
retrieving revision 1.20
retrieving revision 1.21
diff -C2 -d -r1.20 -r1.21
*** test_builtin.py 2 May 2003 09:06:25 -0000 1.20
--- test_builtin.py 18 Jun 2003 14:26:18 -0000 1.21
***************
*** 202,261 ****
compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec')
- def test_complex(self):
- class OS:
- def __complex__(self): return 1+10j
- class NS(object):
- def __complex__(self): return 1+10j
- self.assertEqual(complex(OS()), 1+10j)
- self.assertEqual(complex(NS()), 1+10j)
- self.assertEqual(complex("1+10j"), 1+10j)
- self.assertEqual(complex(10), 10+0j)
- self.assertEqual(complex(10.0), 10+0j)
- self.assertEqual(complex(10L), 10+0j)
- self.assertEqual(complex(10+0j), 10+0j)
- self.assertEqual(complex(1,10), 1+10j)
- self.assertEqual(complex(1,10L), 1+10j)
- self.assertEqual(complex(1,10.0), 1+10j)
- self.assertEqual(complex(1L,10), 1+10j)
- self.assertEqual(complex(1L,10L), 1+10j)
- self.assertEqual(complex(1L,10.0), 1+10j)
- self.assertEqual(complex(1.0,10), 1+10j)
- self.assertEqual(complex(1.0,10L), 1+10j)
- self.assertEqual(complex(1.0,10.0), 1+10j)
- self.assertEqual(complex(3.14+0j), 3.14+0j)
- self.assertEqual(complex(3.14), 3.14+0j)
- self.assertEqual(complex(314), 314.0+0j)
- self.assertEqual(complex(314L), 314.0+0j)
- self.assertEqual(complex(3.14+0j, 0j), 3.14+0j)
- self.assertEqual(complex(3.14, 0.0), 3.14+0j)
- self.assertEqual(complex(314, 0), 314.0+0j)
- self.assertEqual(complex(314L, 0L), 314.0+0j)
- self.assertEqual(complex(0j, 3.14j), -3.14+0j)
- self.assertEqual(complex(0.0, 3.14j), -3.14+0j)
- self.assertEqual(complex(0j, 3.14), 3.14j)
- self.assertEqual(complex(0.0, 3.14), 3.14j)
- self.assertEqual(complex("1"), 1+0j)
- self.assertEqual(complex("1j"), 1j)
-
- c = 3.14 + 1j
- self.assert_(complex(c) is c)
- del c
-
- self.assertRaises(TypeError, complex, "1", "1")
- self.assertRaises(TypeError, complex, 1, "1")
-
- self.assertEqual(complex(" 3.14+J "), 3.14+1j)
- if have_unicode:
- self.assertEqual(complex(unicode(" 3.14+J ")), 3.14+1j)
-
- # SF bug 543840: complex(string) accepts strings with \0
- # Fixed in 2.3.
- self.assertRaises(ValueError, complex, '1+1j\0j')
-
- class Z:
- def __complex__(self): return 3.14j
- z = Z()
- self.assertEqual(complex(z), 3.14j)
-
def test_delattr(self):
import sys
--- 202,205 ----
Index: test_complex.py
===================================================================
RCS file: /cvsroot/python/python/dist/src/Lib/test/test_complex.py,v
retrieving revision 1.9
retrieving revision 1.10
diff -C2 -d -r1.9 -r1.10
*** test_complex.py 30 Jul 2002 23:26:01 -0000 1.9
--- test_complex.py 18 Jun 2003 14:26:18 -0000 1.10
***************
*** 1,91 ****
! from test.test_support import TestFailed, vereq
from random import random
! # These tests ensure that complex math does the right thing; tests of
! # the complex() function/constructor are in test_b1.py.
! # XXX need many, many more tests here.
! nerrors = 0
! def check_close_real(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 check_close(x, y, eps=1e-9):
! """Return true iff complexes x and y "are close\""""
! return check_close_real(x.real, y.real, eps) and \
! check_close_real(x.imag, y.imag, eps)
! def test_div(x, y):
! """Compute complex z=x*y, and check that z/x==y and z/y==x."""
! global nerrors
! z = x * y
! if x != 0:
! q = z / x
! if not check_close(q, y):
! nerrors += 1
! print "%r / %r == %r but expected %r" % (z, x, q, y)
! if y != 0:
! q = z / y
! if not check_close(q, x):
! nerrors += 1
! print "%r / %r == %r but expected %r" % (z, y, q, x)
! simple_real = [float(i) for i in range(-5, 6)]
! 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:
! test_div(x, y)
! # A naive complex division algorithm (such as in 2.0) is very prone to
! # nonsense errors for these (overflows and underflows).
! test_div(complex(1e200, 1e200), 1+0j)
! test_div(complex(1e-200, 1e-200), 1+0j)
! # Just for fun.
! for i in range(100):
! test_div(complex(random(), random()),
! complex(random(), random()))
! for i in range(100):
! if not complex(random() + 1e-6, random() + 1e-6):
! raise TestFailed("complex(random(), random()) should be true")
! if complex(0.0, 0.0):
! raise TestFailed("complex(0.0, 0.0) should be false")
! vereq(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
! try:
! print int(5+3j)
! except TypeError:
! pass
! else:
! raise TestFailed("int(complex()) didn't raise TypeError")
! try:
! print float(5+3j)
! except TypeError:
! pass
! else:
! raise TestFailed("float(complex()) didn't raise TypeError")
! try:
! z = 1.0 / (0+0j)
! except ZeroDivisionError:
! pass
! else:
! nerrors += 1
! raise TestFailed("Division by complex 0 didn't raise ZeroDivisionError")
! if nerrors:
! raise TestFailed("%d tests failed" % nerrors)
--- 1,251 ----
! import unittest
! from test import test_support
!
! import warnings
! warnings.filterwarnings(
! "ignore",
! category=DeprecationWarning,
! message=".*complex divmod.*are deprecated"
! )
!
from random import random
! # These tests ensure that complex math does the right thing
! class ComplexTest(unittest.TestCase):
! def assertAlmostEqual(self, a, b):
! if isinstance(a, complex):
! if isinstance(b, complex):
! unittest.TestCase.assertAlmostEqual(self, a.real, b.real)
! unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag)
! else:
! unittest.TestCase.assertAlmostEqual(self, a.real, b)
! unittest.TestCase.assertAlmostEqual(self, a.imag, 0.)
! else:
! if isinstance(b, complex):
! unittest.TestCase.assertAlmostEqual(self, a, b.real)
! unittest.TestCase.assertAlmostEqual(self, 0., b.imag)
! else:
! unittest.TestCase.assertAlmostEqual(self, a, b)
! def assertCloseAbs(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
! self.assert_(abs((x-y)/y) < eps)
! def assertClose(self, x, y, eps=1e-9):
! """Return true iff complexes x and y "are close\""""
! self.assertCloseAbs(x.real, y.real, eps)
! self.assertCloseAbs(x.imag, y.imag, eps)
! def assertIs(self, a, b):
! self.assert_(a is b)
! def 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
! self.assertClose(q, y)
! if y != 0:
! q = z / y
! self.assertClose(q, x)
! def test_div(self):
! simple_real = [float(i) for i in xrange(-5, 6)]
! 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:
! 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).
! 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):
! self.check_div(complex(random(), random()),
! complex(random(), random()))
! self.assertRaises(ZeroDivisionError, complex.__div__, 1+1j, 0+0j)
! # FIXME: The following currently crashes on Alpha
! # self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
! def test_truediv(self):
! self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
! self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)
! def test_floordiv(self):
! self.assertAlmostEqual(complex.__floordiv__(3+0j, 1.5+0j), 2)
! self.assertRaises(ZeroDivisionError, complex.__floordiv__, 3+0j, 0+0j)
! def test_coerce(self):
! self.assertRaises(OverflowError, complex.__coerce__, 1+1j, 1L<<10000)
! def test_richcompare(self):
! self.assertRaises(OverflowError, complex.__eq__, 1+1j, 1L<<10000)
! self.assertEqual(complex.__lt__(1+1j, None), NotImplemented)
! self.assertIs(complex.__eq__(1+1j, 1+1j), True)
! self.assertIs(complex.__eq__(1+1j, 2+2j), False)
! self.assertIs(complex.__ne__(1+1j, 1+1j), False)
! self.assertIs(complex.__ne__(1+1j, 2+2j), True)
! self.assertRaises(TypeError, complex.__lt__, 1+1j, 2+2j)
! self.assertRaises(TypeError, complex.__le__, 1+1j, 2+2j)
! self.assertRaises(TypeError, complex.__gt__, 1+1j, 2+2j)
! self.assertRaises(TypeError, complex.__ge__, 1+1j, 2+2j)
! def test_mod(self):
! self.assertRaises(ZeroDivisionError, (1+1j).__mod__, 0+0j)
!
! def test_divmod(self):
! self.assertRaises(ZeroDivisionError, divmod, 1+1j, 0+0j)
!
! def test_pow(self):
! self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0)
! self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0)
! self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j)
! self.assertAlmostEqual(pow(1j, -1), 1/1j)
! self.assertAlmostEqual(pow(1j, 200), 1)
! self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j)
!
! def test_boolcontext(self):
! for i in xrange(100):
! self.assert_(complex(random() + 1e-6, random() + 1e-6))
! self.assert_(not complex(0.0, 0.0))
!
! def test_conjugate(self):
! self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
!
! def test_constructor(self):
! class OS:
! 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
! self.assertEqual(complex(OS(1+10j)), 1+10j)
! self.assertEqual(complex(NS(1+10j)), 1+10j)
! self.assertRaises(TypeError, complex, OS(None))
! self.assertRaises(TypeError, complex, NS(None))
!
! self.assertAlmostEqual(complex("1+10j"), 1+10j)
! self.assertAlmostEqual(complex(10), 10+0j)
! self.assertAlmostEqual(complex(10.0), 10+0j)
! self.assertAlmostEqual(complex(10L), 10+0j)
! self.assertAlmostEqual(complex(10+0j), 10+0j)
! self.assertAlmostEqual(complex(1,10), 1+10j)
! self.assertAlmostEqual(complex(1,10L), 1+10j)
! self.assertAlmostEqual(complex(1,10.0), 1+10j)
! self.assertAlmostEqual(complex(1L,10), 1+10j)
! self.assertAlmostEqual(complex(1L,10L), 1+10j)
! self.assertAlmostEqual(complex(1L,10.0), 1+10j)
! self.assertAlmostEqual(complex(1.0,10), 1+10j)
! self.assertAlmostEqual(complex(1.0,10L), 1+10j)
! self.assertAlmostEqual(complex(1.0,10.0), 1+10j)
! self.assertAlmostEqual(complex(3.14+0j), 3.14+0j)
! self.assertAlmostEqual(complex(3.14), 3.14+0j)
! self.assertAlmostEqual(complex(314), 314.0+0j)
! self.assertAlmostEqual(complex(314L), 314.0+0j)
! self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j)
! self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j)
! self.assertAlmostEqual(complex(314, 0), 314.0+0j)
! self.assertAlmostEqual(complex(314L, 0L), 314.0+0j)
! self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j)
! self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j)
! self.assertAlmostEqual(complex(0j, 3.14), 3.14j)
! self.assertAlmostEqual(complex(0.0, 3.14), 3.14j)
! self.assertAlmostEqual(complex("1"), 1+0j)
! self.assertAlmostEqual(complex("1j"), 1j)
! self.assertAlmostEqual(complex(), 0)
! self.assertAlmostEqual(complex("-1"), -1)
! self.assertAlmostEqual(complex("+1"), +1)
!
! class complex2(complex): pass
! self.assertAlmostEqual(complex(complex2(1+1j)), 1+1j)
! self.assertAlmostEqual(complex(real=17, imag=23), 17+23j)
! self.assertAlmostEqual(complex(real=17+23j), 17+23j)
! self.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j)
! self.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j)
!
! c = 3.14 + 1j
! self.assert_(complex(c) is c)
! del c
!
! self.assertRaises(TypeError, complex, "1", "1")
! self.assertRaises(TypeError, complex, 1, "1")
!
! self.assertEqual(complex(" 3.14+J "), 3.14+1j)
! if test_support.have_unicode:
! self.assertEqual(complex(unicode(" 3.14+J ")), 3.14+1j)
!
! # SF bug 543840: complex(string) accepts strings with \0
! # Fixed in 2.3.
! self.assertRaises(ValueError, complex, '1+1j\0j')
!
! self.assertRaises(TypeError, int, 5+3j)
! self.assertRaises(TypeError, long, 5+3j)
! self.assertRaises(TypeError, float, 5+3j)
! self.assertRaises(ValueError, complex, "")
! self.assertRaises(TypeError, complex, None)
! self.assertRaises(ValueError, complex, "\0")
! self.assertRaises(TypeError, complex, "1", "2")
! self.assertRaises(TypeError, complex, "1", 42)
! self.assertRaises(TypeError, complex, 1, "2")
! self.assertRaises(ValueError, complex, "1+")
! self.assertRaises(ValueError, complex, "1+1j+1j")
! self.assertRaises(ValueError, complex, "--")
! if test_support.have_unicode:
! self.assertRaises(ValueError, complex, unicode("1"*500))
! self.assertRaises(ValueError, complex, unicode("x"))
!
! class EvilExc(Exception):
! pass
!
! class evilcomplex:
! def __complex__(self):
! raise EvilExc
!
! self.assertRaises(EvilExc, complex, evilcomplex())
!
! class float2:
! def __init__(self, value):
! self.value = value
! def __float__(self):
! return self.value
!
! self.assertAlmostEqual(complex(float2(42.)), 42)
! self.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j)
! self.assertRaises(TypeError, complex, float2(None))
!
! def test_hash(self):
! for x in xrange(-30, 30):
! self.assertEqual(hash(x), hash(complex(x, 0)))
! x /= 3.0 # now check against floating point
! self.assertEqual(hash(x), hash(complex(x, 0.)))
!
! def test_abs(self):
! nums = [complex(x/3., y/7.) for x in xrange(-9,9) for y in xrange(-9,9)]
! for num in nums:
! self.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num))
!
! def test_repr(self):
! self.assertEqual(repr(1+6j), '(1+6j)')
!
! def test_neg(self):
! self.assertEqual(-(1+6j), -1-6j)
!
!
! def test_main():
! test_support.run_unittest(ComplexTest)
!
! if __name__ == "__main__":
! test_main()