import itertools
import operator
import sys
import unittest
import warnings
from test.support import cpython_only, import_helper
_testcapi = import_helper.import_module('_testcapi')
from _testcapi import PY_SSIZE_T_MAX, PY_SSIZE_T_MIN
try:
from _testbuffer import ndarray
except ImportError:
ndarray = None
NULL = None
class BadDescr:
def __get__(self, obj, objtype=None):
raise RuntimeError
class WithDunder:
def _meth(self, *args):
if self.val:
return self.val
if self.exc:
raise self.exc
@classmethod
def with_val(cls, val):
obj = super().__new__(cls)
obj.val = val
obj.exc = None
setattr(cls, cls.methname, cls._meth)
return obj
@classmethod
def with_exc(cls, exc):
obj = super().__new__(cls)
obj.val = None
obj.exc = exc
setattr(cls, cls.methname, cls._meth)
return obj
class HasBadAttr:
def __new__(cls):
obj = super().__new__(cls)
setattr(cls, cls.methname, BadDescr())
return obj
class IndexLike(WithDunder):
methname = '__index__'
class IntLike(WithDunder):
methname = '__int__'
class FloatLike(WithDunder):
methname = '__float__'
def subclassof(base):
return type(base.__name__ + 'Subclass', (base,), {})
class SomeError(Exception):
pass
class OtherError(Exception):
pass
class CAPITest(unittest.TestCase):
def test_check(self):
# Test PyNumber_Check()
check = _testcapi.number_check
self.assertTrue(check(1))
self.assertTrue(check(IndexLike.with_val(1)))
self.assertTrue(check(IntLike.with_val(99)))
self.assertTrue(check(0.5))
self.assertTrue(check(FloatLike.with_val(4.25)))
self.assertTrue(check(1+2j))
self.assertFalse(check([]))
self.assertFalse(check("abc"))
self.assertFalse(check(object()))
self.assertFalse(check(NULL))
def test_unary_ops(self):
methmap = {'__neg__': _testcapi.number_negative, # PyNumber_Negative()
'__pos__': _testcapi.number_positive, # PyNumber_Positive()
'__abs__': _testcapi.number_absolute, # PyNumber_Absolute()
'__invert__': _testcapi.number_invert} # PyNumber_Invert()
for name, func in methmap.items():
# Generic object, has no tp_as_number structure
self.assertRaises(TypeError, func, object())
# C-API function accepts NULL
self.assertRaises(SystemError, func, NULL)
# Behave as corresponding unary operation
op = getattr(operator, name)
for x in [0, 42, -1, 3.14, 1+2j]:
try:
op(x)
except TypeError:
self.assertRaises(TypeError, func, x)
else:
self.assertEqual(func(x), op(x))
def test_binary_ops(self):
methmap = {'__add__': _testcapi.number_add, # PyNumber_Add()
'__sub__': _testcapi.number_subtract, # PyNumber_Subtract()
'__mul__': _testcapi.number_multiply, # PyNumber_Multiply()
'__matmul__': _testcapi.number_matrixmultiply, # PyNumber_MatrixMultiply()
'__floordiv__': _testcapi.number_floordivide, # PyNumber_FloorDivide()
'__truediv__': _testcapi.number_truedivide, # PyNumber_TrueDivide()
'__mod__': _testcapi.number_remainder, # PyNumber_Remainder()
'__divmod__': _testcapi.number_divmod, # PyNumber_Divmod()
'__lshift__': _testcapi.number_lshift, # PyNumber_Lshift()
'__rshift__': _testcapi.number_rshift, # PyNumber_Rshift()
'__and__': _testcapi.number_and, # PyNumber_And()
'__xor__': _testcapi.number_xor, # PyNumber_Xor()
'__or__': _testcapi.number_or, # PyNumber_Or()
'__pow__': _testcapi.number_power, # PyNumber_Power()
'__iadd__': _testcapi.number_inplaceadd, # PyNumber_InPlaceAdd()
'__isub__': _testcapi.number_inplacesubtract, # PyNumber_InPlaceSubtract()
'__imul__': _testcapi.number_inplacemultiply, # PyNumber_InPlaceMultiply()
'__imatmul__': _testcapi.number_inplacematrixmultiply, # PyNumber_InPlaceMatrixMultiply()
'__ifloordiv__': _testcapi.number_inplacefloordivide, # PyNumber_InPlaceFloorDivide()
'__itruediv__': _testcapi.number_inplacetruedivide, # PyNumber_InPlaceTrueDivide()
'__imod__': _testcapi.number_inplaceremainder, # PyNumber_InPlaceRemainder()
'__ilshift__': _testcapi.number_inplacelshift, # PyNumber_InPlaceLshift()
'__irshift__': _testcapi.number_inplacershift, # PyNumber_InPlaceRshift()
'__iand__': _testcapi.number_inplaceand, # PyNumber_InPlaceAnd()
'__ixor__': _testcapi.number_inplacexor, # PyNumber_InPlaceXor()
'__ior__': _testcapi.number_inplaceor, # PyNumber_InPlaceOr()
'__ipow__': _testcapi.number_inplacepower, # PyNumber_InPlacePower()
}
for name, func in methmap.items():
cases = [0, 42, 3.14, -1, 123, 1+2j]
# Generic object, has no tp_as_number structure
for x in cases:
self.assertRaises(TypeError, func, object(), x)
self.assertRaises(TypeError, func, x, object())
# Behave as corresponding binary operation
op = getattr(operator, name, divmod)
for x, y in itertools.combinations(cases, 2):
try:
op(x, y)
except (TypeError, ValueError, ZeroDivisionError) as exc:
self.assertRaises(exc.__class__, func, x, y)
else:
self.assertEqual(func(x, y), op(x, y))
# CRASHES func(NULL, object())
# CRASHES func(object(), NULL)
@unittest.skipIf(ndarray is None, "needs _testbuffer")
def test_misc_add(self):
# PyNumber_Add(), PyNumber_InPlaceAdd()
add = _testcapi.number_add
inplaceadd = _testcapi.number_inplaceadd
# test sq_concat/sq_inplace_concat slots
a, b, r = [1, 2], [3, 4], [1, 2, 3, 4]
self.assertEqual(add(a, b), r)
self.assertEqual(a, [1, 2])
self.assertRaises(TypeError, add, ndarray([1], (1,)), 2)
a, b, r = [1, 2], [3, 4], [1, 2, 3, 4]
self.assertEqual(inplaceadd(a, b), r)
self.assertEqual(a, r)
self.assertRaises(TypeError, inplaceadd, ndarray([1], (1,)), 2)
@unittest.skipIf(ndarray is None, "needs _testbuffer")
def test_misc_multiply(self):
# PyNumber_Multiply(), PyNumber_InPlaceMultiply()
multiply = _testcapi.number_multiply
inplacemultiply = _testcapi.number_inplacemultiply
# test sq_repeat/sq_inplace_repeat slots
a, b, r = [1], 2, [1, 1]
self.assertEqual(multiply(a, b), r)
self.assertEqual((a, b), ([1], 2))
self.assertEqual(multiply(b, a), r)
self.assertEqual((a, b), ([1], 2))
self.assertEqual(multiply([1], -1), [])
self.assertRaises(TypeError, multiply, ndarray([1], (1,)), 2)
self.assertRaises(TypeError, multiply, [1], 0.5)
self.assertRaises(OverflowError, multiply, [1], PY_SSIZE_T_MAX + 1)
self.assertRaises(MemoryError, multiply, [1, 2], PY_SSIZE_T_MAX//2 + 1)
a, b, r = [1], 2, [1, 1]
self.assertEqual(inplacemultiply(a, b), r)
self.assertEqual((a, b), (r, 2))
a = [1]
self.assertEqual(inplacemultiply(b, a), r)
self.assertEqual((a, b), ([1], 2))
self.assertRaises(TypeError, inplacemultiply, ndarray([1], (1,)), 2)
self.assertRaises(OverflowError, inplacemultiply, [1], PY_SSIZE_T_MAX + 1)
self.assertRaises(MemoryError, inplacemultiply, [1, 2], PY_SSIZE_T_MAX//2 + 1)
def test_misc_power(self):
# PyNumber_Power()
power = _testcapi.number_power
class HasPow(WithDunder):
methname = '__pow__'
# ternary op
self.assertEqual(power(4, 11, 5), pow(4, 11, 5))
self.assertRaises(TypeError, power, 4, 11, 1.25)
self.assertRaises(TypeError, power, 4, 11, HasPow.with_val(NotImplemented))
self.assertRaises(TypeError, power, 4, 11, object())
def test_long(self):
# Test PyNumber_Long()
long = _testcapi.number_long
self.assertEqual(long(42), 42)
self.assertEqual(long(1.25), 1)
self.assertEqual(long("42"), 42)
self.assertEqual(long(b"42"), 42)
self.assertEqual(long(bytearray(b"42")), 42)
self.assertEqual(long(memoryview(b"42")), 42)
self.assertEqual(long(IndexLike.with_val(99)), 99)
self.assertEqual(long(IntLike.with_val(99)), 99)
self.assertRaises(TypeError, long, IntLike.with_val(1.0))
with warnings.catch_warnings():
warnings.simplefilter("error", DeprecationWarning)
self.assertRaises(DeprecationWarning, long, IntLike.with_val(True))
with self.assertWarns(DeprecationWarning):
self.assertEqual(long(IntLike.with_val(True)), 1)
self.assertRaises(RuntimeError, long, IntLike.with_exc(RuntimeError))
self.assertRaises(TypeError, long, 1j)
self.assertRaises(TypeError, long, object())
self.assertRaises(SystemError, long, NULL)
def test_float(self):
# Test PyNumber_Float()
float_ = _testcapi.number_float
self.assertEqual(float_(1.25), 1.25)
self.assertEqual(float_(123), 123.)
self.assertEqual(float_("1.25"), 1.25)
self.assertEqual(float_(FloatLike.with_val(4.25)), 4.25)
self.assertEqual(float_(IndexLike.with_val(99)), 99.0)
self.assertEqual(float_(IndexLike.with_val(-1)), -1.0)
self.assertRaises(TypeError, float_, FloatLike.with_val(687))
with warnings.catch_warnings():
warnings.simplefilter("error", DeprecationWarning)
self.assertRaises(DeprecationWarning, float_, FloatLike.with_val(subclassof(float)(4.25)))
with self.assertWarns(DeprecationWarning):
self.assertEqual(float_(FloatLike.with_val(subclassof(float)(4.25))), 4.25)
self.assertRaises(RuntimeError, float_, FloatLike.with_exc(RuntimeError))
self.assertRaises(TypeError, float_, IndexLike.with_val(1.25))
self.assertRaises(OverflowError, float_, IndexLike.with_val(2**2000))
self.assertRaises(TypeError, float_, 1j)
self.assertRaises(TypeError, float_, object())
self.assertRaises(SystemError, float_, NULL)
def test_index(self):
# Test PyNumber_Index()
index = _testcapi.number_index
self.assertEqual(index(11), 11)
with warnings.catch_warnings():
warnings.simplefilter("error", DeprecationWarning)
self.assertRaises(DeprecationWarning, index, IndexLike.with_val(True))
with self.assertWarns(DeprecationWarning):
self.assertEqual(index(IndexLike.with_val(True)), 1)
self.assertRaises(TypeError, index, IndexLike.with_val(1.0))
self.assertRaises(RuntimeError, index, IndexLike.with_exc(RuntimeError))
self.assertRaises(TypeError, index, 1.25)
self.assertRaises(TypeError, index, "42")
self.assertRaises(TypeError, index, object())
self.assertRaises(SystemError, index, NULL)
def test_tobase(self):
# Test PyNumber_ToBase()
tobase = _testcapi.number_tobase
self.assertEqual(tobase(10, 2), bin(10))
self.assertEqual(tobase(11, 8), oct(11))
self.assertEqual(tobase(16, 10), str(16))
self.assertEqual(tobase(13, 16), hex(13))
self.assertRaises(SystemError, tobase, NULL, 2)
self.assertRaises(SystemError, tobase, 2, 3)
self.assertRaises(TypeError, tobase, 1.25, 2)
self.assertRaises(TypeError, tobase, "42", 2)
def test_asssizet(self):
# Test PyNumber_AsSsize_t()
asssizet = _testcapi.number_asssizet
for n in [*range(-6, 7), PY_SSIZE_T_MIN, PY_SSIZE_T_MAX]:
self.assertEqual(asssizet(n, OverflowError), n)
self.assertEqual(asssizet(PY_SSIZE_T_MAX+10, NULL), PY_SSIZE_T_MAX)
self.assertEqual(asssizet(PY_SSIZE_T_MIN-10, NULL), PY_SSIZE_T_MIN)
self.assertRaises(OverflowError, asssizet, PY_SSIZE_T_MAX + 10, OverflowError)
self.assertRaises(RuntimeError, asssizet, PY_SSIZE_T_MAX + 10, RuntimeError)
self.assertRaises(SystemError, asssizet, NULL, TypeError)
if __name__ == "__main__":
unittest.main()
Codebase Browser
cpython