From 8cbb0b8b448b18095f4fe909881c2b5846318c91 Mon Sep 17 00:00:00 2001 From: kalyanr Date: Wed, 1 Nov 2023 20:40:39 +0530 Subject: [PATCH 1/6] init Signed-off-by: kalyanr --- Lib/test/test_capi/test_tuple.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Lib/test/test_capi/test_tuple.py diff --git a/Lib/test/test_capi/test_tuple.py b/Lib/test/test_capi/test_tuple.py new file mode 100644 index 00000000000000..e69de29bb2d1d6 From ebb84ac838f38aa8507a98f8c7499ed553d11800 Mon Sep 17 00:00:00 2001 From: kalyanr Date: Wed, 1 Nov 2023 22:16:55 +0530 Subject: [PATCH 2/6] add check test Signed-off-by: kalyanr --- Lib/test/test_capi/test_tuple.py | 35 ++++++++++++++++++++++++++++++++ Modules/_testcapi/tuple.c | 16 +++++++++++++++ 2 files changed, 51 insertions(+) diff --git a/Lib/test/test_capi/test_tuple.py b/Lib/test/test_capi/test_tuple.py index e69de29bb2d1d6..d7a3884d1ba653 100644 --- a/Lib/test/test_capi/test_tuple.py +++ b/Lib/test/test_capi/test_tuple.py @@ -0,0 +1,35 @@ +import unittest +import sys +from test.support import import_helper +_testcapi = import_helper.import_module('_testcapi') + +NULL = None +PY_SSIZE_T_MIN = _testcapi.PY_SSIZE_T_MIN +PY_SSIZE_T_MAX = _testcapi.PY_SSIZE_T_MAX + + +class CAPITest(unittest.TestCase): + def test_check(self): + # Test PyList_Check() + check = _testcapi.tuple_check + self.assertTrue(check((1, 2))) + self.assertTrue(check(())) + self.assertFalse(check({1: 2})) + self.assertFalse(check([1, 2])) + self.assertFalse(check(42)) + self.assertFalse(check(object())) + + # CRASHES check(NULL) + + + # def test_list_check_exact(self): + # # Test PyList_CheckExact() + # check = _testcapi.tuple_checkexact + # self.assertTrue(check([1])) + # self.assertTrue(check([])) + # self.assertFalse(check(ListSubclass([1]))) + # self.assertFalse(check(UserList([1, 2]))) + # self.assertFalse(check({1: 2})) + # self.assertFalse(check(object())) + + # CRASHES check(NULL) \ No newline at end of file diff --git a/Modules/_testcapi/tuple.c b/Modules/_testcapi/tuple.c index 95dde8c0edadbe..cdabaf5ecc4194 100644 --- a/Modules/_testcapi/tuple.c +++ b/Modules/_testcapi/tuple.c @@ -2,7 +2,23 @@ #include "util.h" +static PyObject * +tuple_check(PyObject* Py_UNUSED(module), PyObject *obj) +{ + NULLABLE(obj); + return PyLong_FromLong(PyTuple_Check(obj)); +} + +static PyObject * +tuple_checkexact(PyObject* Py_UNUSED(module), PyObject *obj) +{ + NULLABLE(obj); + return PyLong_FromLong(PyTuple_CheckExact(obj)); +} + static PyMethodDef test_methods[] = { + {"tuple_check", tuple_check, METH_O}, + {"tuple_check_exact", tuple_checkexact, METH_O}, {NULL}, }; From 480f80bfc9376e03528874d53c113de9ef80775e Mon Sep 17 00:00:00 2001 From: kalyanr Date: Wed, 1 Nov 2023 23:13:59 +0530 Subject: [PATCH 3/6] update c tests Signed-off-by: kalyanr --- Modules/_testcapi/tuple.c | 117 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 117 insertions(+) diff --git a/Modules/_testcapi/tuple.c b/Modules/_testcapi/tuple.c index cdabaf5ecc4194..be8dc7f7320bac 100644 --- a/Modules/_testcapi/tuple.c +++ b/Modules/_testcapi/tuple.c @@ -16,9 +16,126 @@ tuple_checkexact(PyObject* Py_UNUSED(module), PyObject *obj) return PyLong_FromLong(PyTuple_CheckExact(obj)); } +static PyObject * +tuple_new(PyObject* Py_UNUSED(module), PyObject *obj) +{ + return PyTuple_New(PyLong_AsSsize_t(obj)); +} + +static PyObject * +tuple_pack(PyObject *Py_UNUSED(module), PyObject *args) +{ + Py_RETURN_NONE; +} + +static PyObject * +tuple_size(PyObject *Py_UNUSED(module), PyObject *obj) +{ + NULLABLE(obj); + RETURN_SIZE(PyTuple_Size(obj)); +} + +static PyObject * +tuple_get_size(PyObject *Py_UNUSED(module), PyObject *obj) +{ + NULLABLE(obj); + RETURN_SIZE(PyTuple_GET_SIZE(obj)); +} + +static PyObject * +tuple_getitem(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_GetItem(obj, i)); +} + +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_getslice(PyObject *Py_UNUSED(module), PyObject *args) +{ + PyObject *obj; + Py_ssize_t ilow, ihigh; + if ( !PyArg_ParseTuple(args, "Onn", &obj, &ilow, &ihigh)){ + return NULL; + } + NULLABLE(obj); + return PyTuple_GetSlice(obj, ilow, ihigh); + +} + +static PyObject * +tuple_setitem(PyObject *Py_UNUSED(module), PyObject *args) +{ + PyObject *obj, *value; + Py_ssize_t i; + if ( !PyArg_ParseTuple(args, "OnO", &obj, &i, &value)){ + return NULL; + } + NULLABLE(obj); + NULLABLE(value); + RETURN_INT(PyTuple_SetItem(obj, i, Py_XNewRef(value))); + +} + +static PyObject * +tuple_set_item(PyObject *Py_UNUSED(module), PyObject *args) +{ + PyObject *obj, *value; + Py_ssize_t i; + if ( !PyArg_ParseTuple(args, "OnO", &obj, &i, &value)){ + return NULL; + } + NULLABLE(obj); + NULLABLE(value); + PyTuple_SET_ITEM(obj, i, Py_XNewRef(value)); + Py_RETURN_NONE; + +} + +static PyObject * +tuple_resize(PyObject *Py_UNUSED(module), PyObject *args) +{ + PyObject *obj; + Py_ssize_t newsize; + if ( !PyArg_ParseTuple(args, "On", &obj, &newsize)){ + return NULL; + } + NULLABLE(obj); + RETURN_INT(_PyTuple_Resize(obj, newsize)); + +} + + + static PyMethodDef test_methods[] = { {"tuple_check", tuple_check, METH_O}, {"tuple_check_exact", tuple_checkexact, METH_O}, + {"tuple_new", tuple_new, METH_O}, + {"tuple_pack", tuple_pack, METH_VARARGS}, + {"tuple_size", tuple_size, METH_O}, + {"tuple_get_size", tuple_get_size, METH_O}, + {"tuple_getitem", tuple_getitem, METH_VARARGS}, + {"tuple_get_item", tuple_get_item, METH_VARARGS}, + {"tuple_getslice", tuple_getslice, METH_VARARGS}, + {"tuple_setitem", tuple_setitem, METH_VARARGS}, + {"tuple_set_item", tuple_set_item, METH_VARARGS}, + {"tuple_resize", tuple_resize, METH_VARARGS}, {NULL}, }; From 497f009460920a22005e6c36ec4d86364a17aa80 Mon Sep 17 00:00:00 2001 From: kalyanr Date: Wed, 1 Nov 2023 23:30:25 +0530 Subject: [PATCH 4/6] add test Signed-off-by: kalyanr --- Lib/test/test_capi/test_tuple.py | 250 +++++++++++++++++++++++++++++-- Modules/_testcapi/tuple.c | 2 +- 2 files changed, 240 insertions(+), 12 deletions(-) diff --git a/Lib/test/test_capi/test_tuple.py b/Lib/test/test_capi/test_tuple.py index d7a3884d1ba653..1f703a17326a3a 100644 --- a/Lib/test/test_capi/test_tuple.py +++ b/Lib/test/test_capi/test_tuple.py @@ -1,5 +1,6 @@ import unittest import sys +from collections import namedtuple from test.support import import_helper _testcapi = import_helper.import_module('_testcapi') @@ -7,10 +8,12 @@ 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 PyList_Check() + # Test PyTuple_Check() check = _testcapi.tuple_check self.assertTrue(check((1, 2))) self.assertTrue(check(())) @@ -22,14 +25,239 @@ def test_check(self): # CRASHES check(NULL) - # def test_list_check_exact(self): - # # Test PyList_CheckExact() - # check = _testcapi.tuple_checkexact - # self.assertTrue(check([1])) - # self.assertTrue(check([])) - # self.assertFalse(check(ListSubclass([1]))) - # self.assertFalse(check(UserList([1, 2]))) - # self.assertFalse(check({1: 2})) - # self.assertFalse(check(object())) + def test_tuple_checkexact(self): + # Test PyTuple_CheckExact() + check = _testcapi.tuple_checkexact + self.assertTrue(check((1, 2))) + self.assertTrue(check(())) + self.assertFalse(check(TupleSubclass((1, 2)))) + self.assertFalse(check({1: 2})) + self.assertFalse(check(object())) + + # CRASHES check(NULL) + + # def test_tuple_new(self): + # # Test PyTuple_New() + # list_new = _testcapi.list_new + # lst = list_new(0) + # self.assertEqual(lst, []) + # self.assertIs(type(lst), list) + # lst2 = list_new(0) + # self.assertIsNot(lst2, lst) + # self.assertRaises(SystemError, list_new, NULL) + # self.assertRaises(SystemError, list_new, -1) + + # def test_tuple_size(self): + # # Test PyTuple_Size() + # size = _testcapi.list_size + # self.assertEqual(size([1, 2]), 2) + # self.assertEqual(size(ListSubclass([1, 2])), 2) + # self.assertRaises(SystemError, size, UserList()) + # self.assertRaises(SystemError, size, {}) + # self.assertRaises(SystemError, size, 23) + # self.assertRaises(SystemError, size, object()) + # # CRASHES size(NULL) + + # def test_tuple_get_size(self): + # # Test PyTuple_GET_SIZE() + # size = _testcapi.list_get_size + # self.assertEqual(size([1, 2]), 2) + # self.assertEqual(size(ListSubclass([1, 2])), 2) + # # CRASHES size(object()) + # # CRASHES size(23) + # # CRASHES size({}) + # # CRASHES size(UserList()) + # # CRASHES size(NULL) + + + # def test_tuple_getitem(self): + # # Test PyTuple_GetItem() + # getitem = _testcapi.list_getitem + # lst = [1, 2, 3] + # self.assertEqual(getitem(lst, 0), 1) + # self.assertEqual(getitem(lst, len(lst)-1), 3) + # self.assertRaises(IndexError, getitem, lst, -1) + # self.assertRaises(IndexError, getitem, lst, PY_SSIZE_T_MIN) + # self.assertRaises(IndexError, getitem, lst, PY_SSIZE_T_MAX) + # self.assertRaises(IndexError, getitem, lst, len(lst)) + # self.assertRaises(SystemError, getitem, 42, 1) + + # # CRASHES getitem(NULL, 1) + + # def test_tuple_get_item(self): + # # Test PyTuple_GET_ITEM() + # get_item = _testcapi.list_get_item + # lst = [1, 2, [1, 2, 3]] + # self.assertEqual(get_item(lst, 0), 1) + # self.assertEqual(get_item(lst, 2), [1, 2, 3]) + + # # CRASHES for get_item(lst, PY_SSIZE_T_MIN) + # # CRASHES for get_item(lst, PY_SSIZE_T_MAX) + # # CRASHES for out of index: get_item(lst, 3) + # # CRASHES get_item(21, 2) + # # CRASHES get_item(Null,1) + + + # def test_tuple_setitem(self): + # # Test PyTuple_SetItem() + # setitem = _testcapi.list_setitem + # lst = [1, 2, 3] + # setitem(lst, 0, 10) + # self.assertEqual(lst[0], 10) + # setitem(lst, len(lst)-1, 12) + # self.assertEqual(lst[-1], 12) + # self.assertRaises(IndexError, setitem, lst, PY_SSIZE_T_MIN, 5) + # self.assertRaises(IndexError, setitem, lst, PY_SSIZE_T_MAX, 5) + # self.assertRaises(IndexError, setitem, lst, -1, 5) + # self.assertRaises(IndexError, setitem, lst, len(lst) , 5) + # self.assertRaises(TypeError, setitem, lst, 1.5, 10) + # self.assertRaises(TypeError, setitem, 23, 'a', 5) + # self.assertRaises(SystemError, setitem, {}, 0, 5) + + # # CRASHES setitem(NULL, 'a', 5) + + # def test_tuple_set_item(self): + # # Test PyTuple_SET_ITEM() + # set_item = _testcapi.list_set_item + # lst = [1, 2, 3] + # set_item(lst, 1, 10) + # set_item(lst, 2, [1, 2, 3]) + # self.assertEqual(lst[2], [1, 2, 3]) + + # # CRASHES for set_item([1], PY_SSIZE_T_MIN, 5) + # # CRASHES for set_item([1], PY_SSIZE_T_MAX, 5) + # # CRASHES for set_item([1], -1, 5) + # # CRASHES for set_item([], 0, 1) + # # CRASHES for set_item(NULL, 0, 1) + + + # def test_tuple_insert(self): + # # Test PyTuple_Insert() + # insert = _testcapi.list_insert + # lst = [1, 2, 3] + # insert(lst, 0, 23) + # self.assertEqual(lst[0], 23) + # insert(lst, -1, 22) + # self.assertEqual(lst[-2], 22) + # insert(lst, PY_SSIZE_T_MIN, 1) + # self.assertEqual(lst[0], 1) + # insert(lst, len(lst), 123) + # self.assertEqual(lst[-1], 123) + # insert(lst, len(lst)-1, 124) + # self.assertEqual(lst[-2], 124) + # insert(lst, PY_SSIZE_T_MAX, 223) + # self.assertEqual(lst[-1], 223) + + # self.assertRaises(TypeError, insert, lst, 1.5, 10) + # self.assertRaises(TypeError, insert, 23, 'a', 5) + # self.assertRaises(SystemError, insert, {}, 0, 5) + + # # CRASHES insert(NULL, 'a', 5) + + # def test_tuple_append(self): + # # Test PyTuple_Append() + # append = _testcapi.list_append + # lst = [1, 2, 3] + # append(lst, 1) + # self.assertEqual(lst[-1], 1) + # append(lst, [4,5,6]) + # self.assertEqual(lst[-1], [4,5,6]) + # self.assertRaises(SystemError, append, lst, NULL) + # # CRASHES append(NULL, 0) + + # def test_tuple_getslice(self): + # # Test PyTuple_GetSlice() + # getslice = _testcapi.list_getslice + # lst = [1,2,3] + + # # empty + # self.assertEqual(getslice(lst, PY_SSIZE_T_MIN, 0), []) + # self.assertEqual(getslice(lst, -1, 0), []) + # self.assertEqual(getslice(lst, 3, PY_SSIZE_T_MAX), []) + + # # slice + # self.assertEqual(getslice(lst, 1, 3), [2, 3]) + + # # whole + # self.assertEqual(getslice(lst, 0, len(lst)), lst) + # self.assertEqual(getslice(lst, 0, 100), lst) + # self.assertEqual(getslice(lst, -100, 100), lst) + + # self.assertRaises(TypeError, lst, 'a', '2') + + # # CRASHES getslice(NULL, 0, 0) + + # def test_tuple_setslice(self): + # # Test PyTuple_SetSlice() + # def set_slice(lst, low, high, value): + # lst = lst.copy() + # self.assertEqual(_testcapi.list_setslice(lst, low, high, value), 0) + # return lst + + # # insert items + # self.assertEqual(set_slice([], 0, 0, list("abc")), list("abc")) + # self.assertEqual(set_slice([], PY_SSIZE_T_MIN, PY_SSIZE_T_MIN, list("abc")), list("abc")) + # self.assertEqual(set_slice([], PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, list("abc")), list("abc")) + # lst = list("abc") + # self.assertEqual(set_slice(lst, 0, 0, ["X"]), list("Xabc")) + # self.assertEqual(set_slice(lst, 1, 1, list("XY")), list("aXYbc")) + # self.assertEqual(set_slice(lst, len(lst), len(lst), ["X"]), list("abcX")) + # # self.assertEqual(set_slice(lst, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, ["X"]), list("abcX")) + + # # replace items + # lst = list("abc") + # self.assertEqual(set_slice(lst, -100, 1, list("X")), list("Xbc")) + # self.assertEqual(set_slice(lst, 1, 2, list("X")), list("aXc")) + # self.assertEqual(set_slice(lst, 1, 3, list("XY")), list("aXY")) + # self.assertEqual(set_slice(lst, 0, 3, list("XYZ")), list("XYZ")) + + # # delete items + # lst = list("abcdef") + # self.assertEqual(set_slice(lst, 0, len(lst), []), []) + # self.assertEqual(set_slice(lst, -100, 100, []), []) + # self.assertEqual(set_slice(lst, 1, 5, []), list("af")) + # self.assertEqual(set_slice(lst, 3, len(lst), []), list("abc")) + + # # delete items with NULL + # lst = list("abcdef") + # self.assertEqual(set_slice(lst, 0, len(lst), NULL), []) + # self.assertEqual(set_slice(lst, 3, len(lst), NULL), list("abc")) + + # # CRASHES PyTuple_SetSlice(NULL, 0, 0, ["x"]) + + # def test_tuple_sort(self): + # # Test PyTuple_Sort() + # sort = _testcapi.list_sort + # lst = [4, 6, 7, 3, 1, 5, 9, 2, 0, 8] + # sort(lst) + # self.assertEqual(lst, list(range(10))) + + # lst2 = ListSubclass([4, 6, 7, 3, 1, 5, 9, 2, 0, 8]) + # sort(lst2) + # self.assertEqual(lst2, list(range(10))) + + # self.assertRaises(SystemError, sort, object()) + # self.assertRaises(SystemError, sort, NULL) + + + # def test_tuple_reverse(self): + # # Test PyTuple_Reverse() + # reverse = _testcapi.list_reverse + # def list_reverse(lst): + # self.assertEqual(reverse(lst), 0) + # return lst + + # self.assertEqual(list_reverse([]), []) + # self.assertEqual(list_reverse([2, 5, 10]), [10, 5, 2]) + + # self.assertRaises(SystemError, reverse, object()) + # self.assertRaises(SystemError, reverse, NULL) + + # def test_tuple_astuple(self): + # # Test PyTuple_AsTuple() + # astuple = _testcapi.list_astuple + # self.assertEqual(astuple([]), ()) + # self.assertEqual(astuple([2, 5, 10]), (2, 5, 10)) - # CRASHES check(NULL) \ No newline at end of file + # self.assertRaises(SystemError, astuple, object()) + # self.assertRaises(SystemError, astuple, NULL) diff --git a/Modules/_testcapi/tuple.c b/Modules/_testcapi/tuple.c index be8dc7f7320bac..cbab5bb93d1fc7 100644 --- a/Modules/_testcapi/tuple.c +++ b/Modules/_testcapi/tuple.c @@ -125,7 +125,7 @@ tuple_resize(PyObject *Py_UNUSED(module), PyObject *args) static PyMethodDef test_methods[] = { {"tuple_check", tuple_check, METH_O}, - {"tuple_check_exact", tuple_checkexact, METH_O}, + {"tuple_checkexact", tuple_checkexact, METH_O}, {"tuple_new", tuple_new, METH_O}, {"tuple_pack", tuple_pack, METH_VARARGS}, {"tuple_size", tuple_size, METH_O}, From ed3b9baee47a8a53a9ab624891540c85a4f22c7b Mon Sep 17 00:00:00 2001 From: kalyanr Date: Thu, 2 Nov 2023 00:53:47 +0530 Subject: [PATCH 5/6] add tests Signed-off-by: kalyanr --- Lib/test/test_capi/test_tuple.py | 343 +++++++++++-------------------- 1 file changed, 121 insertions(+), 222 deletions(-) diff --git a/Lib/test/test_capi/test_tuple.py b/Lib/test/test_capi/test_tuple.py index 1f703a17326a3a..03505b2ba92c20 100644 --- a/Lib/test/test_capi/test_tuple.py +++ b/Lib/test/test_capi/test_tuple.py @@ -36,228 +36,127 @@ def test_tuple_checkexact(self): # CRASHES check(NULL) - # def test_tuple_new(self): - # # Test PyTuple_New() - # list_new = _testcapi.list_new - # lst = list_new(0) - # self.assertEqual(lst, []) - # self.assertIs(type(lst), list) - # lst2 = list_new(0) - # self.assertIsNot(lst2, lst) - # self.assertRaises(SystemError, list_new, NULL) - # self.assertRaises(SystemError, list_new, -1) - - # def test_tuple_size(self): - # # Test PyTuple_Size() - # size = _testcapi.list_size - # self.assertEqual(size([1, 2]), 2) - # self.assertEqual(size(ListSubclass([1, 2])), 2) - # self.assertRaises(SystemError, size, UserList()) - # self.assertRaises(SystemError, size, {}) - # self.assertRaises(SystemError, size, 23) - # self.assertRaises(SystemError, size, object()) - # # CRASHES size(NULL) - - # def test_tuple_get_size(self): - # # Test PyTuple_GET_SIZE() - # size = _testcapi.list_get_size - # self.assertEqual(size([1, 2]), 2) - # self.assertEqual(size(ListSubclass([1, 2])), 2) - # # CRASHES size(object()) - # # CRASHES size(23) - # # CRASHES size({}) - # # CRASHES size(UserList()) - # # CRASHES size(NULL) - - - # def test_tuple_getitem(self): - # # Test PyTuple_GetItem() - # getitem = _testcapi.list_getitem - # lst = [1, 2, 3] - # self.assertEqual(getitem(lst, 0), 1) - # self.assertEqual(getitem(lst, len(lst)-1), 3) - # self.assertRaises(IndexError, getitem, lst, -1) - # self.assertRaises(IndexError, getitem, lst, PY_SSIZE_T_MIN) - # self.assertRaises(IndexError, getitem, lst, PY_SSIZE_T_MAX) - # self.assertRaises(IndexError, getitem, lst, len(lst)) - # self.assertRaises(SystemError, getitem, 42, 1) + def test_tuple_new(self): + # Test PyTuple_New() + tuple_new = _testcapi.tuple_new + tup = tuple_new(0) + self.assertEqual(tup, ()) + self.assertIs(type(tup), tuple) + tup2 = tuple_new(1) + self.assertIsNot(tup2, tup) + self.assertRaises(SystemError, tuple_new, NULL) + self.assertRaises(SystemError, tuple_new, -1) + + + def test_tuple_pack(self): + # Test PyTuple_Pack() + pass + + def test_tuple_size(self): + # Test PyTuple_Size() + size = _testcapi.tuple_size + self.assertEqual(size((1, 2)), 2) + self.assertEqual(size(TupleSubclass((1, 2))), 2) + self.assertRaises(SystemError, size, {}) + self.assertRaises(SystemError, size, 23) + 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) + # CRASHES size(object()) + # CRASHES size(23) + # CRASHES size({}) + # CRASHES size(UserList()) + # CRASHES size(NULL) + + + def test_tuple_getitem(self): + # Test PyTuple_GetItem() + getitem = _testcapi.tuple_getitem + tup = (1, 2, 3) + self.assertEqual(getitem(tup, 0), 1) + self.assertEqual(getitem(tup, len(tup)-1), 3) + self.assertRaises(IndexError, getitem, tup, -1) + self.assertRaises(IndexError, getitem, tup, PY_SSIZE_T_MIN) + self.assertRaises(IndexError, getitem, tup, PY_SSIZE_T_MAX) + self.assertRaises(IndexError, getitem, tup, len(tup)) + self.assertRaises(SystemError, getitem, 42, 1) # # CRASHES getitem(NULL, 1) - # def test_tuple_get_item(self): - # # Test PyTuple_GET_ITEM() - # get_item = _testcapi.list_get_item - # lst = [1, 2, [1, 2, 3]] - # self.assertEqual(get_item(lst, 0), 1) - # self.assertEqual(get_item(lst, 2), [1, 2, 3]) - - # # CRASHES for get_item(lst, PY_SSIZE_T_MIN) - # # CRASHES for get_item(lst, PY_SSIZE_T_MAX) - # # CRASHES for out of index: get_item(lst, 3) - # # CRASHES get_item(21, 2) - # # CRASHES get_item(Null,1) - - - # def test_tuple_setitem(self): - # # Test PyTuple_SetItem() - # setitem = _testcapi.list_setitem - # lst = [1, 2, 3] - # setitem(lst, 0, 10) - # self.assertEqual(lst[0], 10) - # setitem(lst, len(lst)-1, 12) - # self.assertEqual(lst[-1], 12) - # self.assertRaises(IndexError, setitem, lst, PY_SSIZE_T_MIN, 5) - # self.assertRaises(IndexError, setitem, lst, PY_SSIZE_T_MAX, 5) - # self.assertRaises(IndexError, setitem, lst, -1, 5) - # self.assertRaises(IndexError, setitem, lst, len(lst) , 5) - # self.assertRaises(TypeError, setitem, lst, 1.5, 10) - # self.assertRaises(TypeError, setitem, 23, 'a', 5) - # self.assertRaises(SystemError, setitem, {}, 0, 5) - - # # CRASHES setitem(NULL, 'a', 5) - - # def test_tuple_set_item(self): - # # Test PyTuple_SET_ITEM() - # set_item = _testcapi.list_set_item - # lst = [1, 2, 3] - # set_item(lst, 1, 10) - # set_item(lst, 2, [1, 2, 3]) - # self.assertEqual(lst[2], [1, 2, 3]) - - # # CRASHES for set_item([1], PY_SSIZE_T_MIN, 5) - # # CRASHES for set_item([1], PY_SSIZE_T_MAX, 5) - # # CRASHES for set_item([1], -1, 5) - # # CRASHES for set_item([], 0, 1) - # # CRASHES for set_item(NULL, 0, 1) - - - # def test_tuple_insert(self): - # # Test PyTuple_Insert() - # insert = _testcapi.list_insert - # lst = [1, 2, 3] - # insert(lst, 0, 23) - # self.assertEqual(lst[0], 23) - # insert(lst, -1, 22) - # self.assertEqual(lst[-2], 22) - # insert(lst, PY_SSIZE_T_MIN, 1) - # self.assertEqual(lst[0], 1) - # insert(lst, len(lst), 123) - # self.assertEqual(lst[-1], 123) - # insert(lst, len(lst)-1, 124) - # self.assertEqual(lst[-2], 124) - # insert(lst, PY_SSIZE_T_MAX, 223) - # self.assertEqual(lst[-1], 223) - - # self.assertRaises(TypeError, insert, lst, 1.5, 10) - # self.assertRaises(TypeError, insert, 23, 'a', 5) - # self.assertRaises(SystemError, insert, {}, 0, 5) - - # # CRASHES insert(NULL, 'a', 5) - - # def test_tuple_append(self): - # # Test PyTuple_Append() - # append = _testcapi.list_append - # lst = [1, 2, 3] - # append(lst, 1) - # self.assertEqual(lst[-1], 1) - # append(lst, [4,5,6]) - # self.assertEqual(lst[-1], [4,5,6]) - # self.assertRaises(SystemError, append, lst, NULL) - # # CRASHES append(NULL, 0) - - # def test_tuple_getslice(self): - # # Test PyTuple_GetSlice() - # getslice = _testcapi.list_getslice - # lst = [1,2,3] - - # # empty - # self.assertEqual(getslice(lst, PY_SSIZE_T_MIN, 0), []) - # self.assertEqual(getslice(lst, -1, 0), []) - # self.assertEqual(getslice(lst, 3, PY_SSIZE_T_MAX), []) - - # # slice - # self.assertEqual(getslice(lst, 1, 3), [2, 3]) - - # # whole - # self.assertEqual(getslice(lst, 0, len(lst)), lst) - # self.assertEqual(getslice(lst, 0, 100), lst) - # self.assertEqual(getslice(lst, -100, 100), lst) - - # self.assertRaises(TypeError, lst, 'a', '2') - - # # CRASHES getslice(NULL, 0, 0) - - # def test_tuple_setslice(self): - # # Test PyTuple_SetSlice() - # def set_slice(lst, low, high, value): - # lst = lst.copy() - # self.assertEqual(_testcapi.list_setslice(lst, low, high, value), 0) - # return lst - - # # insert items - # self.assertEqual(set_slice([], 0, 0, list("abc")), list("abc")) - # self.assertEqual(set_slice([], PY_SSIZE_T_MIN, PY_SSIZE_T_MIN, list("abc")), list("abc")) - # self.assertEqual(set_slice([], PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, list("abc")), list("abc")) - # lst = list("abc") - # self.assertEqual(set_slice(lst, 0, 0, ["X"]), list("Xabc")) - # self.assertEqual(set_slice(lst, 1, 1, list("XY")), list("aXYbc")) - # self.assertEqual(set_slice(lst, len(lst), len(lst), ["X"]), list("abcX")) - # # self.assertEqual(set_slice(lst, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, ["X"]), list("abcX")) - - # # replace items - # lst = list("abc") - # self.assertEqual(set_slice(lst, -100, 1, list("X")), list("Xbc")) - # self.assertEqual(set_slice(lst, 1, 2, list("X")), list("aXc")) - # self.assertEqual(set_slice(lst, 1, 3, list("XY")), list("aXY")) - # self.assertEqual(set_slice(lst, 0, 3, list("XYZ")), list("XYZ")) - - # # delete items - # lst = list("abcdef") - # self.assertEqual(set_slice(lst, 0, len(lst), []), []) - # self.assertEqual(set_slice(lst, -100, 100, []), []) - # self.assertEqual(set_slice(lst, 1, 5, []), list("af")) - # self.assertEqual(set_slice(lst, 3, len(lst), []), list("abc")) - - # # delete items with NULL - # lst = list("abcdef") - # self.assertEqual(set_slice(lst, 0, len(lst), NULL), []) - # self.assertEqual(set_slice(lst, 3, len(lst), NULL), list("abc")) - - # # CRASHES PyTuple_SetSlice(NULL, 0, 0, ["x"]) - - # def test_tuple_sort(self): - # # Test PyTuple_Sort() - # sort = _testcapi.list_sort - # lst = [4, 6, 7, 3, 1, 5, 9, 2, 0, 8] - # sort(lst) - # self.assertEqual(lst, list(range(10))) - - # lst2 = ListSubclass([4, 6, 7, 3, 1, 5, 9, 2, 0, 8]) - # sort(lst2) - # self.assertEqual(lst2, list(range(10))) - - # self.assertRaises(SystemError, sort, object()) - # self.assertRaises(SystemError, sort, NULL) - - - # def test_tuple_reverse(self): - # # Test PyTuple_Reverse() - # reverse = _testcapi.list_reverse - # def list_reverse(lst): - # self.assertEqual(reverse(lst), 0) - # return lst - - # self.assertEqual(list_reverse([]), []) - # self.assertEqual(list_reverse([2, 5, 10]), [10, 5, 2]) - - # self.assertRaises(SystemError, reverse, object()) - # self.assertRaises(SystemError, reverse, NULL) - - # def test_tuple_astuple(self): - # # Test PyTuple_AsTuple() - # astuple = _testcapi.list_astuple - # self.assertEqual(astuple([]), ()) - # self.assertEqual(astuple([2, 5, 10]), (2, 5, 10)) - - # self.assertRaises(SystemError, astuple, object()) - # self.assertRaises(SystemError, astuple, NULL) + def test_tuple_get_item(self): + # Test PyTuple_GET_ITEM() + get_item = _testcapi.tuple_get_item + tup = (1, 2, 3) + self.assertEqual(get_item(tup, 0), 1) + self.assertEqual(get_item(tup, 2), 3) + + # CRASHES for get_item(tup, -1) + # CRASHES for get_item(tup, PY_SSIZE_T_MIN) + # CRASHES for get_item(tup, PY_SSIZE_T_MAX) + # CRASHES for out of index: get_item(tup, 3) + # CRASHES get_item(21, 2) + # CRASHES get_item(Null,1) + + def test_tuple_getslice(self): + # Test PyTuple_GetSlice() + getslice = _testcapi.tuple_getslice + tup = (1,2,3) + + # empty + self.assertEqual(getslice(tup, PY_SSIZE_T_MIN, 0), ()) + self.assertEqual(getslice(tup, -1, 0), ()) + self.assertEqual(getslice(tup, 3, PY_SSIZE_T_MAX), ()) + + # slice + self.assertEqual(getslice(tup, 1, 3), (2, 3)) + + # whole + self.assertEqual(getslice(tup, 0, len(tup)), tup) + self.assertEqual(getslice(tup, 0, 100), tup) + self.assertEqual(getslice(tup, -100, 100), tup) + + self.assertRaises(TypeError, tup, 'a', '2') + + # CRASHES getslice(NULL, 0, 0) + + + def test_tuple_setitem(self): + # Test PyTuple_SetItem() + setitem = _testcapi.tuple_setitem + tup = (1, 2, 3) + self.assertRaises(SystemError, setitem, tup, 1, 0) + self.assertRaises(SystemError, setitem, {}, 0, 5) + self.assertRaises(SystemError, setitem, tup, PY_SSIZE_T_MIN, 5) + self.assertRaises(SystemError, setitem, tup, PY_SSIZE_T_MAX, 5) + self.assertRaises(SystemError, setitem, tup, -1, 5) + self.assertRaises(SystemError, setitem, tup, len(tup) , 5) + self.assertRaises(TypeError, setitem, 23, 'a', 5) + self.assertRaises(TypeError, setitem, tup, 1.5, 10) + + # CRASHES setitem(NULL, 'a', 5) + + def test_tuple_set_item(self): + # Test PyTuple_SET_ITEM() + set_item = _testcapi.tuple_set_item + tup = (1, 2, 3) + set_item(tup, 1, (1, 2)) + self.assertEqual(tup, (1, (1, 2), 3)) + + # CRASHES for set_item([1], PY_SSIZE_T_MIN, 5) + # CRASHES for set_item([1], PY_SSIZE_T_MAX, 5) + # CRASHES for set_item([1], -1, 5) + # CRASHES for set_item([], 0, 1) + # CRASHES for set_item(NULL, 0, 1) + + def test_tuple_resize(self): + # Test PyTuple_Resize() + pass + + From 1073d78d5ba3b164a64a59d0a47db8d6f23c0f45 Mon Sep 17 00:00:00 2001 From: kalyanr Date: Thu, 2 Nov 2023 00:53:52 +0530 Subject: [PATCH 6/6] add tests Signed-off-by: kalyanr --- Lib/test/test_capi/test_tuple.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/Lib/test/test_capi/test_tuple.py b/Lib/test/test_capi/test_tuple.py index 03505b2ba92c20..503622d1a1cfbd 100644 --- a/Lib/test/test_capi/test_tuple.py +++ b/Lib/test/test_capi/test_tuple.py @@ -158,5 +158,3 @@ def test_tuple_set_item(self): def test_tuple_resize(self): # Test PyTuple_Resize() pass - -