gh-111495: Add tests for PyTuple C API

Lib/test/test_capi/test_tuple.py

@@ -0,0 +1,206 @@
+import unittest
+import sys
+from collections import namedtuple
+from test.support import import_helper
+
+_testcapi = import_helper.import_module('_testcapi')
+_testlimitedcapi = import_helper.import_module('_testlimitedcapi')
+
+NULL = None
+PY_SSIZE_T_MIN = _testcapi.PY_SSIZE_T_MIN
+PY_SSIZE_T_MAX = _testcapi.PY_SSIZE_T_MAX
+
+class TupleSubclass(tuple):
+    pass
+
+
+class CAPITest(unittest.TestCase):
+    def test_check(self):
+        # Test PyTuple_Check()
+        check = _testlimitedcapi.tuple_check
+
+        self.assertTrue(check((1, 2)))
+        self.assertTrue(check(()))
+        self.assertTrue(check(TupleSubclass((1, 2))))
+        self.assertFalse(check({1: 2}))
+        self.assertFalse(check([1, 2]))
+        self.assertFalse(check(42))
+        self.assertFalse(check(object()))
+
+        # CRASHES check(NULL)
+
+    def test_tuple_checkexact(self):
+        # Test PyTuple_CheckExact()
+        check = _testlimitedcapi.tuple_checkexact
+
+        self.assertTrue(check((1, 2)))
+        self.assertTrue(check(()))
+        self.assertFalse(check(TupleSubclass((1, 2))))
+        self.assertFalse(check({1: 2}))
+        self.assertFalse(check([1, 2]))
+        self.assertFalse(check(42))
+        self.assertFalse(check(object()))
+
+        # CRASHES check(NULL)
+
+    def test_tuple_new(self):
+        # Test PyTuple_New()
+        tuple_new = _testlimitedcapi.tuple_new
+        size = _testlimitedcapi.tuple_size
+
+        tup1 = tuple_new(0)
+        self.assertEqual(tup1, ())
+        self.assertEqual(size(tup1), 0)
+        self.assertIs(type(tup1), tuple)
+        tup2 = tuple_new(1)
+        self.assertIs(type(tup2), tuple)
+        self.assertEqual(size(tup2), 1)
+        self.assertIsNot(tup2, tup1)
+
+        self.assertRaises(SystemError, tuple_new, -1)
+        self.assertRaises(SystemError, tuple_new, PY_SSIZE_T_MIN)
+        self.assertRaises(MemoryError, tuple_new, PY_SSIZE_T_MAX)
+
+    def test_tuple_pack(self):
+        # Test PyTuple_Pack()
+        pack = _testlimitedcapi.tuple_pack
+
+        self.assertEqual(pack(0), ())
+        self.assertEqual(pack(1, 1), (1,))
+        self.assertEqual(pack(2, 1, 2), (1, 2))
+
+        self.assertRaises(SystemError, pack, PY_SSIZE_T_MIN)
+        self.assertRaises(SystemError, pack, -1)
+        self.assertRaises(MemoryError, pack, PY_SSIZE_T_MAX)
+
+        # CRASHES pack(1, NULL)
+        # CRASHES pack(2, 1)
+
+    def test_tuple_size(self):
+        # Test PyTuple_Size()
+        size = _testlimitedcapi.tuple_size
+
+        self.assertEqual(size((1, 2)), 2)
+        self.assertEqual(size(TupleSubclass((1, 2))), 2)
+
+        self.assertRaises(SystemError, size, [])
+        self.assertRaises(SystemError, size, 42)
+        self.assertRaises(SystemError, size, object())
+
+        # CRASHES size(NULL)
+
+    def test_tuple_get_size(self):
+        # Test PyTuple_GET_SIZE()
+        size = _testcapi.tuple_get_size
+
+        self.assertEqual(size(()), 0)
+        self.assertEqual(size((1, 2)), 2)
+        self.assertEqual(size(TupleSubclass((1, 2))), 2)
+
+    def test_tuple_getitem(self):
+        # Test PyTuple_GetItem()
+        getitem = _testlimitedcapi.tuple_getitem
+
+        tup = TupleSubclass((1, 2, 3))
+        self.assertEqual(getitem(tup, 0), 1)
+        self.assertEqual(getitem(tup, 2), 3)
+
+        tup = (1, 2, 3)
+        self.assertEqual(getitem(tup, 0), 1)
+        self.assertEqual(getitem(tup, 2), 3)
+
+        self.assertRaises(IndexError, getitem, tup, PY_SSIZE_T_MIN)
+        self.assertRaises(IndexError, getitem, tup, -1)
+        self.assertRaises(IndexError, getitem, tup, len(tup))
+        self.assertRaises(IndexError, getitem, tup, PY_SSIZE_T_MAX)
+        self.assertRaises(SystemError, getitem, [1, 2, 3], 1)
+        self.assertRaises(SystemError, getitem, 42, 1)
+
+        # CRASHES getitem(NULL, 1)
+
+    def test_tuple_get_item(self):
+        # Test PyTuple_GET_ITEM()
+        get_item = _testcapi.tuple_get_item
+
+        tup = TupleSubclass((1, 2, 3))
+        self.assertEqual(get_item(tup, 0), 1)
+        self.assertEqual(get_item(tup, 2), 3)
+
+        tup = (1, 2, 3)
+        self.assertEqual(get_item(tup, 0), 1)
+        self.assertEqual(get_item(tup, 2), 3)
+
+    def test_tuple_getslice(self):
+        # Test PyTuple_GetSlice()
+        getslice = _testlimitedcapi.tuple_getslice
+
+        # empty
+        tup = (1, 2, 3)
+        self.assertEqual(getslice(tup, PY_SSIZE_T_MIN, 0), ())
+        self.assertEqual(getslice(tup, -1, 0), ())
+        self.assertEqual(getslice(tup, 3, PY_SSIZE_T_MAX), ())
+        self.assertEqual(getslice(tup, 0, 0), ())
+        self.assertEqual(getslice(tup, 3, 0), ())
+        tup = TupleSubclass((1, 2, 3))
+        self.assertEqual(getslice(tup, PY_SSIZE_T_MIN, 0), ())
+        self.assertEqual(getslice(tup, -1, 0), ())
+        self.assertEqual(getslice(tup, 3, PY_SSIZE_T_MAX), ())
+        self.assertEqual(getslice(tup, 0, 0), ())
+        self.assertEqual(getslice(tup, 3, 0), ())
+
+        # slice
+        tup = (1, 2, 3)
+        self.assertEqual(getslice(tup, 1, 3), (2, 3))
+        tup = TupleSubclass((1, 2, 3))
+        self.assertEqual(getslice(tup, 1, 3), (2, 3))
+
+        # whole
+        tup = (1, 2, 3)
+        self.assertEqual(getslice(tup, 0, 3), tup)
+        self.assertEqual(getslice(tup, 0, 100), tup)
+        self.assertEqual(getslice(tup, -100, 100), tup)
+        tup = TupleSubclass((1, 2, 3))
+        self.assertEqual(getslice(tup, 0, 3), tup)
+        self.assertEqual(getslice(tup, 0, 100), tup)
+        self.assertEqual(getslice(tup, -100, 100), tup)
+
+        self.assertRaises(SystemError, getslice, [1, 2, 3], 0, 1)
+        self.assertRaises(SystemError, getslice, 42, 0, 1)
+        # CRASHES getslice(NULL, 0, 0)
+
+    def test_tuple_setitem(self):
+        # Test PyTuple_SetItem()
+        setitem = _testlimitedcapi.tuple_setitem
+
+        tup = (0, 0)
+        self.assertEqual(setitem(tup, 0, 1), (1, 0))
+        self.assertEqual(setitem(tup, 1, 1), (0, 1))
+
+        self.assertRaises(IndexError, setitem, tup, PY_SSIZE_T_MIN, 1)
+        self.assertRaises(IndexError, setitem, tup, -1, 1)
+        self.assertRaises(IndexError, setitem, tup, len(tup), 1)
+        self.assertRaises(IndexError, setitem, tup, PY_SSIZE_T_MAX, 1)
+        self.assertRaises(SystemError, setitem, [1], 0, 1)
+        self.assertRaises(SystemError, setitem, 42, 0, 1)
+
+        # CRASHES setitem(NULL, 1, 5)
+
+    def test_tuple_set_item(self):
+        # Test PyTuple_SET_ITEM()
+        set_item = _testcapi.tuple_set_item
+
+        tup = (0, 0)
+        self.assertEqual(set_item(tup, 0, 1), (1, 0))
+        self.assertEqual(set_item(tup, 1, 1), (0, 1))
+
+    def test_tuple_resize(self):
+        # Test PyTuple_Resize()
+        resize = _testcapi.tuple_resize
+        size = _testlimitedcapi.tuple_size
+        tup = resize(0)
+        self.assertEqual(size(tup), 0)
+        tup = resize(2)
+        self.assertEqual(size(tup), 2)
+        self.assertRaises(MemoryError, resize, PY_SSIZE_T_MAX)
+        self.assertRaises(SystemError, resize, -1)
+        self.assertRaises(SystemError, resize, PY_SSIZE_T_MIN)

Modules/Setup.stdlib.in

@@ -164,7 +164,7 @@
 @MODULE__TESTBUFFER_TRUE@_testbuffer _testbuffer.c
 @MODULE__TESTINTERNALCAPI_TRUE@_testinternalcapi _testinternalcapi.c _testinternalcapi/test_lock.c _testinternalcapi/pytime.c _testinternalcapi/set.c _testinternalcapi/test_critical_sections.c
 @MODULE__TESTCAPI_TRUE@_testcapi _testcapimodule.c _testcapi/vectorcall.c _testcapi/heaptype.c _testcapi/abstract.c _testcapi/unicode.c _testcapi/dict.c _testcapi/set.c _testcapi/list.c _testcapi/tuple.c _testcapi/getargs.c _testcapi/datetime.c _testcapi/docstring.c _testcapi/mem.c _testcapi/watchers.c _testcapi/long.c _testcapi/float.c _testcapi/complex.c _testcapi/numbers.c _testcapi/structmember.c _testcapi/exceptions.c _testcapi/code.c _testcapi/buffer.c _testcapi/pyatomic.c _testcapi/run.c _testcapi/file.c _testcapi/codec.c _testcapi/immortal.c _testcapi/gc.c _testcapi/hash.c _testcapi/time.c _testcapi/bytes.c _testcapi/object.c _testcapi/monitoring.c
-@MODULE__TESTLIMITEDCAPI_TRUE@_testlimitedcapi _testlimitedcapi.c _testlimitedcapi/abstract.c _testlimitedcapi/bytearray.c _testlimitedcapi/bytes.c _testlimitedcapi/complex.c _testlimitedcapi/dict.c _testlimitedcapi/float.c _testlimitedcapi/heaptype_relative.c _testlimitedcapi/list.c _testlimitedcapi/long.c _testlimitedcapi/object.c _testlimitedcapi/pyos.c _testlimitedcapi/set.c _testlimitedcapi/sys.c _testlimitedcapi/unicode.c _testlimitedcapi/vectorcall_limited.c
+@MODULE__TESTLIMITEDCAPI_TRUE@_testlimitedcapi _testlimitedcapi.c _testlimitedcapi/abstract.c _testlimitedcapi/bytearray.c _testlimitedcapi/bytes.c _testlimitedcapi/complex.c _testlimitedcapi/dict.c _testlimitedcapi/float.c _testlimitedcapi/heaptype_relative.c _testlimitedcapi/list.c _testlimitedcapi/long.c _testlimitedcapi/object.c _testlimitedcapi/pyos.c _testlimitedcapi/set.c _testlimitedcapi/sys.c _testlimitedcapi/tuple.c _testlimitedcapi/unicode.c _testlimitedcapi/vectorcall_limited.c
 @MODULE__TESTCLINIC_TRUE@_testclinic _testclinic.c
 @MODULE__TESTCLINIC_LIMITED_TRUE@_testclinic_limited _testclinic_limited.c
 

Modules/_testcapi/tuple.c

@@ -2,14 +2,80 @@
 #include "util.h"
 
 
+static PyObject *
+tuple_get_size(PyObject *Py_UNUSED(module), PyObject *obj)
+{
+    NULLABLE(obj);
+    RETURN_SIZE(PyTuple_GET_SIZE(obj));
+}
+
+static PyObject *
+tuple_get_item(PyObject *Py_UNUSED(module), PyObject *args)
+{
+    PyObject *obj;
+    Py_ssize_t i;
+    if (!PyArg_ParseTuple(args, "On", &obj, &i)) {
+        return NULL;
+    }
+    NULLABLE(obj);
+    return Py_XNewRef(PyTuple_GET_ITEM(obj, i));
+}
+
+static PyObject *
+tuple_set_item(PyObject *Py_UNUSED(module), PyObject *args)
+{
+    PyObject *obj, *value, *newtuple;
+    Py_ssize_t i;
+    if (!PyArg_ParseTuple(args, "OnO", &obj, &i, &value)) {
+        return NULL;
+    }
+    NULLABLE(obj);
+    NULLABLE(value);
+    if (obj) {
+        Py_ssize_t size = PyTuple_Size(obj);
+        newtuple = PyTuple_New(size);
+        if (!newtuple) {
+            return NULL;
+        }
+        for (Py_ssize_t n = 0; n < size; n++) {
+            PyTuple_SetItem(newtuple, n, Py_XNewRef(PyTuple_GetItem(obj, n)));
+        }
+    }
+    else {
+        newtuple = obj;
+    }
+    PyTuple_SET_ITEM(newtuple, i, Py_XNewRef(value));
+    return newtuple;
+}
+
+static PyObject *
+tuple_resize(PyObject *Py_UNUSED(module), PyObject *args)
+{
+    Py_ssize_t newsize;
+    if (!PyArg_ParseTuple(args, "n", &newsize)) {
+        return NULL;
+    }
+    PyObject *obj = PyTuple_New(0);
+    int r = _PyTuple_Resize(&obj, newsize);
+    if (r == -1) {
+        return NULL;
+    }
+    return obj;
+}
+
+
 static PyMethodDef test_methods[] = {
+    {"tuple_get_size", tuple_get_size, METH_O},
+    {"tuple_get_item", tuple_get_item, METH_VARARGS},
+    {"tuple_set_item", tuple_set_item, METH_VARARGS},
+    {"tuple_resize", tuple_resize, METH_VARARGS},
     {NULL},
 };
 
 int
 _PyTestCapi_Init_Tuple(PyObject *m)
 {
-    if (PyModule_AddFunctions(m, test_methods) < 0){
+    if (PyModule_AddFunctions(m, test_methods) < 0) {
         return -1;
     }
 

Modules/_testlimitedcapi.c

@@ -68,6 +68,9 @@ PyInit__testlimitedcapi(void)
     if (_PyTestLimitedCAPI_Init_Sys(mod) < 0) {
         return NULL;
     }
+    if (_PyTestLimitedCAPI_Init_Tuple(mod) < 0) {
+        return NULL;
+    }
     if (_PyTestLimitedCAPI_Init_Unicode(mod) < 0) {
         return NULL;
     }

Modules/_testlimitedcapi/parts.h

@@ -35,6 +35,7 @@ int _PyTestLimitedCAPI_Init_Long(PyObject *module);
 int _PyTestLimitedCAPI_Init_PyOS(PyObject *module);
 int _PyTestLimitedCAPI_Init_Set(PyObject *module);
 int _PyTestLimitedCAPI_Init_Sys(PyObject *module);
+int _PyTestLimitedCAPI_Init_Tuple(PyObject *module);
 int _PyTestLimitedCAPI_Init_Unicode(PyObject *module);
 int _PyTestLimitedCAPI_Init_VectorcallLimited(PyObject *module);