| from math import isnan |
| import errno |
| import unittest |
| import warnings |
| |
| from test.test_capi.test_getargs import (BadComplex, BadComplex2, Complex, |
| FloatSubclass, Float, BadFloat, |
| BadFloat2, ComplexSubclass) |
| from test.support import import_helper |
| |
| |
| _testcapi = import_helper.import_module('_testcapi') |
| _testlimitedcapi = import_helper.import_module('_testlimitedcapi') |
| |
| NULL = None |
| INF = float("inf") |
| NAN = float("nan") |
| DBL_MAX = _testcapi.DBL_MAX |
| |
| |
| class BadComplex3: |
| def __complex__(self): |
| raise RuntimeError |
| |
| |
| class CAPIComplexTest(unittest.TestCase): |
| def test_check(self): |
| # Test PyComplex_Check() |
| check = _testlimitedcapi.complex_check |
| |
| self.assertTrue(check(1+2j)) |
| self.assertTrue(check(ComplexSubclass(1+2j))) |
| self.assertFalse(check(Complex())) |
| self.assertFalse(check(3)) |
| self.assertFalse(check(3.0)) |
| self.assertFalse(check(object())) |
| |
| # CRASHES check(NULL) |
| |
| def test_checkexact(self): |
| # PyComplex_CheckExact() |
| checkexact = _testlimitedcapi.complex_checkexact |
| |
| self.assertTrue(checkexact(1+2j)) |
| self.assertFalse(checkexact(ComplexSubclass(1+2j))) |
| self.assertFalse(checkexact(Complex())) |
| self.assertFalse(checkexact(3)) |
| self.assertFalse(checkexact(3.0)) |
| self.assertFalse(checkexact(object())) |
| |
| # CRASHES checkexact(NULL) |
| |
| def test_fromccomplex(self): |
| # Test PyComplex_FromCComplex() |
| fromccomplex = _testcapi.complex_fromccomplex |
| |
| self.assertEqual(fromccomplex(1+2j), 1.0+2.0j) |
| |
| def test_fromdoubles(self): |
| # Test PyComplex_FromDoubles() |
| fromdoubles = _testlimitedcapi.complex_fromdoubles |
| |
| self.assertEqual(fromdoubles(1.0, 2.0), 1.0+2.0j) |
| |
| def test_realasdouble(self): |
| # Test PyComplex_RealAsDouble() |
| realasdouble = _testlimitedcapi.complex_realasdouble |
| |
| self.assertEqual(realasdouble(1+2j), 1.0) |
| self.assertEqual(realasdouble(-1+0j), -1.0) |
| self.assertEqual(realasdouble(4.25), 4.25) |
| self.assertEqual(realasdouble(-1.0), -1.0) |
| self.assertEqual(realasdouble(42), 42.) |
| self.assertEqual(realasdouble(-1), -1.0) |
| |
| # Test subclasses of complex/float |
| self.assertEqual(realasdouble(ComplexSubclass(1+2j)), 1.0) |
| self.assertEqual(realasdouble(FloatSubclass(4.25)), 4.25) |
| |
| # Test types with __complex__ dunder method |
| self.assertEqual(realasdouble(Complex()), 4.25) |
| self.assertRaises(TypeError, realasdouble, BadComplex()) |
| with self.assertWarns(DeprecationWarning): |
| self.assertEqual(realasdouble(BadComplex2()), 4.25) |
| with warnings.catch_warnings(): |
| warnings.simplefilter("error", DeprecationWarning) |
| self.assertRaises(DeprecationWarning, realasdouble, BadComplex2()) |
| self.assertRaises(RuntimeError, realasdouble, BadComplex3()) |
| |
| # Test types with __float__ dunder method |
| self.assertEqual(realasdouble(Float()), 4.25) |
| self.assertRaises(TypeError, realasdouble, BadFloat()) |
| with self.assertWarns(DeprecationWarning): |
| self.assertEqual(realasdouble(BadFloat2()), 4.25) |
| |
| self.assertRaises(TypeError, realasdouble, object()) |
| |
| # CRASHES realasdouble(NULL) |
| |
| def test_imagasdouble(self): |
| # Test PyComplex_ImagAsDouble() |
| imagasdouble = _testlimitedcapi.complex_imagasdouble |
| |
| self.assertEqual(imagasdouble(1+2j), 2.0) |
| self.assertEqual(imagasdouble(1-1j), -1.0) |
| self.assertEqual(imagasdouble(4.25), 0.0) |
| self.assertEqual(imagasdouble(42), 0.0) |
| |
| # Test subclasses of complex/float |
| self.assertEqual(imagasdouble(ComplexSubclass(1+2j)), 2.0) |
| self.assertEqual(imagasdouble(FloatSubclass(4.25)), 0.0) |
| |
| # Test types with __complex__ dunder method |
| self.assertEqual(imagasdouble(Complex()), 0.5) |
| self.assertRaises(TypeError, imagasdouble, BadComplex()) |
| with self.assertWarns(DeprecationWarning): |
| self.assertEqual(imagasdouble(BadComplex2()), 0.5) |
| with warnings.catch_warnings(): |
| warnings.simplefilter("error", DeprecationWarning) |
| self.assertRaises(DeprecationWarning, imagasdouble, BadComplex2()) |
| self.assertRaises(RuntimeError, imagasdouble, BadComplex3()) |
| |
| # Test types with __float__ dunder method |
| self.assertEqual(imagasdouble(Float()), 0.0) |
| self.assertRaises(TypeError, imagasdouble, BadFloat()) |
| with self.assertWarns(DeprecationWarning): |
| self.assertEqual(imagasdouble(BadFloat2()), 0.0) |
| |
| self.assertRaises(TypeError, imagasdouble, object()) |
| |
| # CRASHES imagasdouble(NULL) |
| |
| def test_asccomplex(self): |
| # Test PyComplex_AsCComplex() |
| asccomplex = _testcapi.complex_asccomplex |
| |
| self.assertEqual(asccomplex(1+2j), 1.0+2.0j) |
| self.assertEqual(asccomplex(-1+2j), -1.0+2.0j) |
| self.assertEqual(asccomplex(4.25), 4.25+0.0j) |
| self.assertEqual(asccomplex(-1.0), -1.0+0.0j) |
| self.assertEqual(asccomplex(42), 42+0j) |
| self.assertEqual(asccomplex(-1), -1.0+0.0j) |
| |
| # Test subclasses of complex/float |
| self.assertEqual(asccomplex(ComplexSubclass(1+2j)), 1.0+2.0j) |
| self.assertEqual(asccomplex(FloatSubclass(4.25)), 4.25+0.0j) |
| |
| # Test types with __complex__ dunder method |
| self.assertEqual(asccomplex(Complex()), 4.25+0.5j) |
| self.assertRaises(TypeError, asccomplex, BadComplex()) |
| with self.assertWarns(DeprecationWarning): |
| self.assertEqual(asccomplex(BadComplex2()), 4.25+0.5j) |
| with warnings.catch_warnings(): |
| warnings.simplefilter("error", DeprecationWarning) |
| self.assertRaises(DeprecationWarning, asccomplex, BadComplex2()) |
| self.assertRaises(RuntimeError, asccomplex, BadComplex3()) |
| |
| # Test types with __float__ dunder method |
| self.assertEqual(asccomplex(Float()), 4.25+0.0j) |
| self.assertRaises(TypeError, asccomplex, BadFloat()) |
| with self.assertWarns(DeprecationWarning): |
| self.assertEqual(asccomplex(BadFloat2()), 4.25+0.0j) |
| |
| self.assertRaises(TypeError, asccomplex, object()) |
| |
| # CRASHES asccomplex(NULL) |
| |
| def test_py_c_sum(self): |
| # Test _Py_c_sum() |
| _py_c_sum = _testcapi._py_c_sum |
| |
| self.assertEqual(_py_c_sum(1, 1j), (1+1j, 0)) |
| |
| def test_py_c_diff(self): |
| # Test _Py_c_diff() |
| _py_c_diff = _testcapi._py_c_diff |
| |
| self.assertEqual(_py_c_diff(1, 1j), (1-1j, 0)) |
| |
| def test_py_c_neg(self): |
| # Test _Py_c_neg() |
| _py_c_neg = _testcapi._py_c_neg |
| |
| self.assertEqual(_py_c_neg(1+1j), -1-1j) |
| |
| def test_py_c_prod(self): |
| # Test _Py_c_prod() |
| _py_c_prod = _testcapi._py_c_prod |
| |
| self.assertEqual(_py_c_prod(2, 1j), (2j, 0)) |
| |
| def test_py_c_quot(self): |
| # Test _Py_c_quot() |
| _py_c_quot = _testcapi._py_c_quot |
| |
| self.assertEqual(_py_c_quot(1, 1j), (-1j, 0)) |
| self.assertEqual(_py_c_quot(1, -1j), (1j, 0)) |
| self.assertEqual(_py_c_quot(1j, 2), (0.5j, 0)) |
| self.assertEqual(_py_c_quot(1j, -2), (-0.5j, 0)) |
| self.assertEqual(_py_c_quot(1, 2j), (-0.5j, 0)) |
| |
| z, e = _py_c_quot(NAN, 1j) |
| self.assertTrue(isnan(z.real)) |
| self.assertTrue(isnan(z.imag)) |
| self.assertEqual(e, 0) |
| |
| z, e = _py_c_quot(1j, NAN) |
| self.assertTrue(isnan(z.real)) |
| self.assertTrue(isnan(z.imag)) |
| self.assertEqual(e, 0) |
| |
| self.assertEqual(_py_c_quot(1, 0j)[1], errno.EDOM) |
| |
| def test_py_c_pow(self): |
| # Test _Py_c_pow() |
| _py_c_pow = _testcapi._py_c_pow |
| |
| self.assertEqual(_py_c_pow(1j, 0j), (1+0j, 0)) |
| self.assertEqual(_py_c_pow(1, 1j), (1+0j, 0)) |
| self.assertEqual(_py_c_pow(0j, 1), (0j, 0)) |
| self.assertAlmostEqual(_py_c_pow(1j, 2)[0], -1.0+0j) |
| |
| r, e = _py_c_pow(1+1j, -1) |
| self.assertAlmostEqual(r, 0.5-0.5j) |
| self.assertEqual(e, 0) |
| |
| self.assertEqual(_py_c_pow(0j, -1)[1], errno.EDOM) |
| self.assertEqual(_py_c_pow(0j, 1j)[1], errno.EDOM) |
| self.assertEqual(_py_c_pow(*[DBL_MAX+1j]*2)[0], complex(*[INF]*2)) |
| |
| |
| def test_py_c_abs(self): |
| # Test _Py_c_abs() |
| _py_c_abs = _testcapi._py_c_abs |
| |
| self.assertEqual(_py_c_abs(-1), (1.0, 0)) |
| self.assertEqual(_py_c_abs(1j), (1.0, 0)) |
| |
| self.assertEqual(_py_c_abs(complex('+inf+1j')), (INF, 0)) |
| self.assertEqual(_py_c_abs(complex('-inf+1j')), (INF, 0)) |
| self.assertEqual(_py_c_abs(complex('1.25+infj')), (INF, 0)) |
| self.assertEqual(_py_c_abs(complex('1.25-infj')), (INF, 0)) |
| |
| self.assertTrue(isnan(_py_c_abs(complex('1.25+nanj'))[0])) |
| self.assertTrue(isnan(_py_c_abs(complex('nan-1j'))[0])) |
| |
| self.assertEqual(_py_c_abs(complex(*[DBL_MAX]*2))[1], errno.ERANGE) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
