Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
the complex_pow part), r56649, r56652, r56715, r57296, r57302, r57359, r57361,
r57372, r57738, r57739, r58017, r58039, r58040, and r59390, and new
documentation. The only significant difference is that round(x) returns a float
to preserve backward-compatibility. See http://bugs.python.org/issue1689.
diff --git a/Lib/test/test_abstract_numbers.py b/Lib/test/test_abstract_numbers.py
new file mode 100644
index 0000000..19bfc79
--- /dev/null
+++ b/Lib/test/test_abstract_numbers.py
@@ -0,0 +1,62 @@
+"""Unit tests for numbers.py."""
+
+import unittest
+from test import test_support
+from numbers import Number
+from numbers import Exact, Inexact
+from numbers import Complex, Real, Rational, Integral
+import operator
+
+class TestNumbers(unittest.TestCase):
+ def test_int(self):
+ self.failUnless(issubclass(int, Integral))
+ self.failUnless(issubclass(int, Complex))
+ self.failUnless(issubclass(int, Exact))
+ self.failIf(issubclass(int, Inexact))
+
+ self.assertEqual(7, int(7).real)
+ self.assertEqual(0, int(7).imag)
+ self.assertEqual(7, int(7).conjugate())
+ self.assertEqual(7, int(7).numerator)
+ self.assertEqual(1, int(7).denominator)
+
+ def test_long(self):
+ self.failUnless(issubclass(long, Integral))
+ self.failUnless(issubclass(long, Complex))
+ self.failUnless(issubclass(long, Exact))
+ self.failIf(issubclass(long, Inexact))
+
+ self.assertEqual(7, long(7).real)
+ self.assertEqual(0, long(7).imag)
+ self.assertEqual(7, long(7).conjugate())
+ self.assertEqual(7, long(7).numerator)
+ self.assertEqual(1, long(7).denominator)
+
+ def test_float(self):
+ self.failIf(issubclass(float, Rational))
+ self.failUnless(issubclass(float, Real))
+ self.failIf(issubclass(float, Exact))
+ self.failUnless(issubclass(float, Inexact))
+
+ self.assertEqual(7.3, float(7.3).real)
+ self.assertEqual(0, float(7.3).imag)
+ self.assertEqual(7.3, float(7.3).conjugate())
+
+ def test_complex(self):
+ self.failIf(issubclass(complex, Real))
+ self.failUnless(issubclass(complex, Complex))
+ self.failIf(issubclass(complex, Exact))
+ self.failUnless(issubclass(complex, Inexact))
+
+ c1, c2 = complex(3, 2), complex(4,1)
+ # XXX: This is not ideal, but see the comment in builtin_trunc().
+ self.assertRaises(AttributeError, trunc, c1)
+ self.assertRaises(TypeError, float, c1)
+ self.assertRaises(TypeError, int, c1)
+
+def test_main():
+ test_support.run_unittest(TestNumbers)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 52178c8..c5a1cc3 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -1450,11 +1450,13 @@
else:
self.assertAlmostEqual(pow(x, y, z), 24.0)
+ self.assertAlmostEqual(pow(-1, 0.5), 1j)
+ self.assertAlmostEqual(pow(-1, 1./3), 0.5 + 0.8660254037844386j)
+
self.assertRaises(TypeError, pow, -1, -2, 3)
self.assertRaises(ValueError, pow, 1, 2, 0)
self.assertRaises(TypeError, pow, -1L, -2L, 3L)
self.assertRaises(ValueError, pow, 1L, 2L, 0L)
- self.assertRaises(ValueError, pow, -342.43, 0.234)
self.assertRaises(TypeError, pow)
@@ -1622,6 +1624,7 @@
def test_round(self):
self.assertEqual(round(0.0), 0.0)
+ self.assertEqual(type(round(0.0)), float) # Will be int in 3.0.
self.assertEqual(round(1.0), 1.0)
self.assertEqual(round(10.0), 10.0)
self.assertEqual(round(1000000000.0), 1000000000.0)
@@ -1650,12 +1653,50 @@
self.assertEqual(round(-999999999.9), -1000000000.0)
self.assertEqual(round(-8.0, -1), -10.0)
+ self.assertEqual(type(round(-8.0, -1)), float)
+
+ self.assertEqual(type(round(-8.0, 0)), float)
+ self.assertEqual(type(round(-8.0, 1)), float)
+
+ # Check even / odd rounding behaviour
+ self.assertEqual(round(5.5), 6)
+ self.assertEqual(round(6.5), 6)
+ self.assertEqual(round(-5.5), -6)
+ self.assertEqual(round(-6.5), -6)
+
+ # Check behavior on ints
+ self.assertEqual(round(0), 0)
+ self.assertEqual(round(8), 8)
+ self.assertEqual(round(-8), -8)
+ self.assertEqual(type(round(0)), float) # Will be int in 3.0.
+ self.assertEqual(type(round(-8, -1)), float)
+ self.assertEqual(type(round(-8, 0)), float)
+ self.assertEqual(type(round(-8, 1)), float)
# test new kwargs
self.assertEqual(round(number=-8.0, ndigits=-1), -10.0)
self.assertRaises(TypeError, round)
+ # test generic rounding delegation for reals
+ class TestRound(object):
+ def __round__(self):
+ return 23
+
+ class TestNoRound(object):
+ pass
+
+ self.assertEqual(round(TestRound()), 23)
+
+ self.assertRaises(TypeError, round, 1, 2, 3)
+ # XXX: This is not ideal, but see the comment in builtin_round().
+ self.assertRaises(AttributeError, round, TestNoRound())
+
+ t = TestNoRound()
+ t.__round__ = lambda *args: args
+ self.assertEquals((), round(t))
+ self.assertEquals((0,), round(t, 0))
+
def test_setattr(self):
setattr(sys, 'spam', 1)
self.assertEqual(sys.spam, 1)
@@ -1697,6 +1738,38 @@
raise ValueError
self.assertRaises(ValueError, sum, BadSeq())
+ def test_trunc(self):
+
+ self.assertEqual(trunc(1), 1)
+ self.assertEqual(trunc(-1), -1)
+ self.assertEqual(type(trunc(1)), int)
+ self.assertEqual(type(trunc(1.5)), int)
+ self.assertEqual(trunc(1.5), 1)
+ self.assertEqual(trunc(-1.5), -1)
+ self.assertEqual(trunc(1.999999), 1)
+ self.assertEqual(trunc(-1.999999), -1)
+ self.assertEqual(trunc(-0.999999), -0)
+ self.assertEqual(trunc(-100.999), -100)
+
+ class TestTrunc(object):
+ def __trunc__(self):
+ return 23
+
+ class TestNoTrunc(object):
+ pass
+
+ self.assertEqual(trunc(TestTrunc()), 23)
+
+ self.assertRaises(TypeError, trunc)
+ self.assertRaises(TypeError, trunc, 1, 2)
+ # XXX: This is not ideal, but see the comment in builtin_trunc().
+ self.assertRaises(AttributeError, trunc, TestNoTrunc())
+
+ t = TestNoTrunc()
+ t.__trunc__ = lambda *args: args
+ self.assertEquals((), trunc(t))
+ self.assertRaises(TypeError, trunc, t, 0)
+
def test_tuple(self):
self.assertEqual(tuple(()), ())
t0_3 = (0, 1, 2, 3)
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
index ae132ad..29515c7 100644
--- a/Lib/test/test_long.py
+++ b/Lib/test/test_long.py
@@ -385,7 +385,9 @@
"1. ** huge", "huge ** 1.", "1. ** mhuge", "mhuge ** 1.",
"math.sin(huge)", "math.sin(mhuge)",
"math.sqrt(huge)", "math.sqrt(mhuge)", # should do better
- "math.floor(huge)", "math.floor(mhuge)"]:
+ # math.floor() of an int returns an int now
+ ##"math.floor(huge)", "math.floor(mhuge)",
+ ]:
self.assertRaises(OverflowError, eval, test, namespace)
diff --git a/Lib/test/test_math.py b/Lib/test/test_math.py
index d86298d..98e4623 100644
--- a/Lib/test/test_math.py
+++ b/Lib/test/test_math.py
@@ -58,6 +58,19 @@
self.ftest('ceil(-1.0)', math.ceil(-1.0), -1)
self.ftest('ceil(-1.5)', math.ceil(-1.5), -1)
+ class TestCeil(object):
+ def __ceil__(self):
+ return 42
+ class TestNoCeil(object):
+ pass
+ self.ftest('ceil(TestCeil())', math.ceil(TestCeil()), 42)
+ self.assertRaises(TypeError, math.ceil, TestNoCeil())
+
+ t = TestNoCeil()
+ t.__ceil__ = lambda *args: args
+ self.assertRaises(TypeError, math.ceil, t)
+ self.assertRaises(TypeError, math.ceil, t, 0)
+
def testCos(self):
self.assertRaises(TypeError, math.cos)
self.ftest('cos(-pi/2)', math.cos(-math.pi/2), 0)
@@ -101,6 +114,19 @@
self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167)
self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167)
+ class TestFloor(object):
+ def __floor__(self):
+ return 42
+ class TestNoFloor(object):
+ pass
+ self.ftest('floor(TestFloor())', math.floor(TestFloor()), 42)
+ self.assertRaises(TypeError, math.floor, TestNoFloor())
+
+ t = TestNoFloor()
+ t.__floor__ = lambda *args: args
+ self.assertRaises(TypeError, math.floor, t)
+ self.assertRaises(TypeError, math.floor, t, 0)
+
def testFmod(self):
self.assertRaises(TypeError, math.fmod)
self.ftest('fmod(10,1)', math.fmod(10,1), 0)
diff --git a/Lib/test/test_unittest.py b/Lib/test/test_unittest.py
index 9dfed7b..5a82780 100644
--- a/Lib/test/test_unittest.py
+++ b/Lib/test/test_unittest.py
@@ -2264,13 +2264,34 @@
expected = ['startTest', 'test', 'stopTest']
self.assertEqual(events, expected)
+class Test_Assertions(TestCase):
+ def test_AlmostEqual(self):
+ self.failUnlessAlmostEqual(1.00000001, 1.0)
+ self.failIfAlmostEqual(1.0000001, 1.0)
+ self.assertRaises(AssertionError,
+ self.failUnlessAlmostEqual, 1.0000001, 1.0)
+ self.assertRaises(AssertionError,
+ self.failIfAlmostEqual, 1.00000001, 1.0)
+
+ self.failUnlessAlmostEqual(1.1, 1.0, places=0)
+ self.assertRaises(AssertionError,
+ self.failUnlessAlmostEqual, 1.1, 1.0, places=1)
+
+ self.failUnlessAlmostEqual(0, .1+.1j, places=0)
+ self.failIfAlmostEqual(0, .1+.1j, places=1)
+ self.assertRaises(AssertionError,
+ self.failUnlessAlmostEqual, 0, .1+.1j, places=1)
+ self.assertRaises(AssertionError,
+ self.failIfAlmostEqual, 0, .1+.1j, places=0)
+
######################################################################
## Main
######################################################################
def test_main():
test_support.run_unittest(Test_TestCase, Test_TestLoader,
- Test_TestSuite, Test_TestResult, Test_FunctionTestCase)
+ Test_TestSuite, Test_TestResult, Test_FunctionTestCase,
+ Test_Assertions)
if __name__ == "__main__":
test_main()