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()
Codebase Browser
cpython