| 1 |
import unittest |
| 2 |
from test.support import import_helper |
| 3 |
from collections import UserList |
| 4 |
_testcapi = import_helper.import_module('_testcapi') |
| 5 |
_testlimitedcapi = import_helper.import_module('_testlimitedcapi') |
| 6 |
|
| 7 |
NULL = None |
| 8 |
PY_SSIZE_T_MIN = _testcapi.PY_SSIZE_T_MIN |
| 9 |
PY_SSIZE_T_MAX = _testcapi.PY_SSIZE_T_MAX |
| 10 |
|
| 11 |
class ListSubclass(list): |
| 12 |
pass |
| 13 |
|
| 14 |
|
| 15 |
class DelAppend: |
| 16 |
def __init__(self, lst, item): |
| 17 |
self.lst = lst |
| 18 |
self.item = item |
| 19 |
|
| 20 |
def __del__(self): |
| 21 |
self.lst.append(self.item) |
| 22 |
|
| 23 |
|
| 24 |
class CAPITest(unittest.TestCase): |
| 25 |
def test_check(self): |
| 26 |
# Test PyList_Check() |
| 27 |
check = _testlimitedcapi.list_check |
| 28 |
self.assertTrue(check([1, 2])) |
| 29 |
self.assertTrue(check([])) |
| 30 |
self.assertTrue(check(ListSubclass([1, 2]))) |
| 31 |
self.assertFalse(check({1: 2})) |
| 32 |
self.assertFalse(check((1, 2))) |
| 33 |
self.assertFalse(check(42)) |
| 34 |
self.assertFalse(check(object())) |
| 35 |
|
| 36 |
# CRASHES check(NULL) |
| 37 |
|
| 38 |
|
| 39 |
def test_list_check_exact(self): |
| 40 |
# Test PyList_CheckExact() |
| 41 |
check = _testlimitedcapi.list_check_exact |
| 42 |
self.assertTrue(check([1])) |
| 43 |
self.assertTrue(check([])) |
| 44 |
self.assertFalse(check(ListSubclass([1]))) |
| 45 |
self.assertFalse(check(UserList([1, 2]))) |
| 46 |
self.assertFalse(check({1: 2})) |
| 47 |
self.assertFalse(check(object())) |
| 48 |
|
| 49 |
# CRASHES check(NULL) |
| 50 |
|
| 51 |
def test_list_new(self): |
| 52 |
# Test PyList_New() |
| 53 |
list_new = _testlimitedcapi.list_new |
| 54 |
lst = list_new(0) |
| 55 |
self.assertEqual(lst, []) |
| 56 |
self.assertIs(type(lst), list) |
| 57 |
lst2 = list_new(0) |
| 58 |
self.assertIsNot(lst2, lst) |
| 59 |
self.assertRaises(SystemError, list_new, NULL) |
| 60 |
self.assertRaises(SystemError, list_new, -1) |
| 61 |
|
| 62 |
def test_list_size(self): |
| 63 |
# Test PyList_Size() |
| 64 |
size = _testlimitedcapi.list_size |
| 65 |
self.assertEqual(size([]), 0) |
| 66 |
self.assertEqual(size([1, 2]), 2) |
| 67 |
self.assertEqual(size(ListSubclass([1, 2])), 2) |
| 68 |
self.assertRaises(SystemError, size, UserList()) |
| 69 |
self.assertRaises(SystemError, size, {}) |
| 70 |
self.assertRaises(SystemError, size, 23) |
| 71 |
self.assertRaises(SystemError, size, object()) |
| 72 |
# CRASHES size(NULL) |
| 73 |
|
| 74 |
def test_list_get_size(self): |
| 75 |
# Test PyList_GET_SIZE() |
| 76 |
size = _testcapi.list_get_size |
| 77 |
self.assertEqual(size([]), 0) |
| 78 |
self.assertEqual(size([1, 2]), 2) |
| 79 |
self.assertEqual(size(ListSubclass([1, 2])), 2) |
| 80 |
# CRASHES size(object()) |
| 81 |
# CRASHES size(23) |
| 82 |
# CRASHES size({}) |
| 83 |
# CRASHES size(UserList()) |
| 84 |
# CRASHES size(NULL) |
| 85 |
|
| 86 |
def check_list_get_item(self, getitem, exctype): |
| 87 |
# Common test cases for PyList_GetItem() and PyList_GetItemRef() |
| 88 |
lst = [1, 2, 3] |
| 89 |
self.assertEqual(getitem(lst, 0), 1) |
| 90 |
self.assertEqual(getitem(lst, 2), 3) |
| 91 |
self.assertRaises(IndexError, getitem, lst, 3) |
| 92 |
self.assertRaises(IndexError, getitem, lst, -1) |
| 93 |
self.assertRaises(IndexError, getitem, lst, PY_SSIZE_T_MIN) |
| 94 |
self.assertRaises(IndexError, getitem, lst, PY_SSIZE_T_MAX) |
| 95 |
self.assertRaises(exctype, getitem, 42, 1) |
| 96 |
self.assertRaises(exctype, getitem, (1, 2, 3), 1) |
| 97 |
self.assertRaises(exctype, getitem, {1: 2}, 1) |
| 98 |
# CRASHES getitem(NULL, 1) |
| 99 |
|
| 100 |
def test_list_getitem(self): |
| 101 |
# Test PyList_GetItem() |
| 102 |
self.check_list_get_item(_testlimitedcapi.list_getitem, SystemError) |
| 103 |
|
| 104 |
def test_list_get_item_ref(self): |
| 105 |
# Test PyList_GetItemRef() |
| 106 |
self.check_list_get_item(_testlimitedcapi.list_get_item_ref, TypeError) |
| 107 |
|
| 108 |
def test_list_get_item(self): |
| 109 |
# Test PyList_GET_ITEM() |
| 110 |
get_item = _testcapi.list_get_item |
| 111 |
lst = [1, 2, [1, 2, 3]] |
| 112 |
self.assertEqual(get_item(lst, 0), 1) |
| 113 |
self.assertEqual(get_item(lst, 2), [1, 2, 3]) |
| 114 |
|
| 115 |
# CRASHES for out of index: get_item(lst, 3) |
| 116 |
# CRASHES for get_item(lst, PY_SSIZE_T_MIN) |
| 117 |
# CRASHES for get_item(lst, PY_SSIZE_T_MAX) |
| 118 |
# CRASHES get_item(21, 2) |
| 119 |
# CRASHES get_item(NULL, 1) |
| 120 |
|
| 121 |
def test_list_setitem(self): |
| 122 |
# Test PyList_SetItem() |
| 123 |
setitem = _testlimitedcapi.list_setitem |
| 124 |
lst = [1, 2, 3] |
| 125 |
setitem(lst, 0, 10) |
| 126 |
self.assertEqual(lst, [10, 2, 3]) |
| 127 |
setitem(lst, 2, 12) |
| 128 |
self.assertEqual(lst, [10, 2, 12]) |
| 129 |
self.assertRaises(IndexError, setitem, lst, 3 , 5) |
| 130 |
self.assertRaises(IndexError, setitem, lst, -1, 5) |
| 131 |
self.assertRaises(IndexError, setitem, lst, PY_SSIZE_T_MIN, 5) |
| 132 |
self.assertRaises(IndexError, setitem, lst, PY_SSIZE_T_MAX, 5) |
| 133 |
self.assertRaises(SystemError, setitem, (1, 2, 3), 1, 5) |
| 134 |
self.assertRaises(SystemError, setitem, {1: 2}, 1, 5) |
| 135 |
|
| 136 |
# CRASHES setitem(NULL, 'a', 5) |
| 137 |
|
| 138 |
def test_list_set_item(self): |
| 139 |
# Test PyList_SET_ITEM() |
| 140 |
set_item = _testcapi.list_set_item |
| 141 |
lst = [1, 2, 3] |
| 142 |
set_item(lst, 1, 10) |
| 143 |
set_item(lst, 2, [1, 2, 3]) |
| 144 |
self.assertEqual(lst, [1, 10, [1, 2, 3]]) |
| 145 |
|
| 146 |
# CRASHES for set_item([1], -1, 5) |
| 147 |
# CRASHES for set_item([1], PY_SSIZE_T_MIN, 5) |
| 148 |
# CRASHES for set_item([1], PY_SSIZE_T_MAX, 5) |
| 149 |
# CRASHES for set_item([], 0, 1) |
| 150 |
# CRASHES for set_item(NULL, 0, 1) |
| 151 |
|
| 152 |
|
| 153 |
def test_list_insert(self): |
| 154 |
# Test PyList_Insert() |
| 155 |
insert = _testlimitedcapi.list_insert |
| 156 |
lst = [1, 2, 3] |
| 157 |
insert(lst, 0, 23) |
| 158 |
self.assertEqual(lst, [23, 1, 2, 3]) |
| 159 |
insert(lst, -1, 22) |
| 160 |
self.assertEqual(lst, [23, 1, 2, 22, 3]) |
| 161 |
insert(lst, PY_SSIZE_T_MIN, 1) |
| 162 |
self.assertEqual(lst[0], 1) |
| 163 |
insert(lst, len(lst), 123) |
| 164 |
self.assertEqual(lst[-1], 123) |
| 165 |
insert(lst, len(lst)-1, 124) |
| 166 |
self.assertEqual(lst[-2], 124) |
| 167 |
insert(lst, PY_SSIZE_T_MAX, 223) |
| 168 |
self.assertEqual(lst[-1], 223) |
| 169 |
|
| 170 |
self.assertRaises(SystemError, insert, (1, 2, 3), 1, 5) |
| 171 |
self.assertRaises(SystemError, insert, {1: 2}, 1, 5) |
| 172 |
|
| 173 |
# CRASHES insert(NULL, 1, 5) |
| 174 |
|
| 175 |
def test_list_append(self): |
| 176 |
# Test PyList_Append() |
| 177 |
append = _testlimitedcapi.list_append |
| 178 |
lst = [1, 2, 3] |
| 179 |
append(lst, 10) |
| 180 |
self.assertEqual(lst, [1, 2, 3, 10]) |
| 181 |
append(lst, [4, 5]) |
| 182 |
self.assertEqual(lst, [1, 2, 3, 10, [4, 5]]) |
| 183 |
self.assertRaises(SystemError, append, lst, NULL) |
| 184 |
self.assertRaises(SystemError, append, (), 0) |
| 185 |
self.assertRaises(SystemError, append, 42, 0) |
| 186 |
# CRASHES append(NULL, 0) |
| 187 |
|
| 188 |
def test_list_getslice(self): |
| 189 |
# Test PyList_GetSlice() |
| 190 |
getslice = _testlimitedcapi.list_getslice |
| 191 |
lst = [1, 2, 3] |
| 192 |
|
| 193 |
# empty |
| 194 |
self.assertEqual(getslice(lst, PY_SSIZE_T_MIN, 0), []) |
| 195 |
self.assertEqual(getslice(lst, -1, 0), []) |
| 196 |
self.assertEqual(getslice(lst, 3, PY_SSIZE_T_MAX), []) |
| 197 |
|
| 198 |
# slice |
| 199 |
self.assertEqual(getslice(lst, 1, 3), [2, 3]) |
| 200 |
|
| 201 |
# whole |
| 202 |
self.assertEqual(getslice(lst, 0, len(lst)), lst) |
| 203 |
self.assertEqual(getslice(lst, 0, 100), lst) |
| 204 |
self.assertEqual(getslice(lst, -100, 100), lst) |
| 205 |
|
| 206 |
self.assertRaises(SystemError, getslice, (1, 2, 3), 0, 0) |
| 207 |
self.assertRaises(SystemError, getslice, 'abc', 0, 0) |
| 208 |
self.assertRaises(SystemError, getslice, 42, 0, 0) |
| 209 |
|
| 210 |
# CRASHES getslice(NULL, 0, 0) |
| 211 |
|
| 212 |
def test_list_setslice(self): |
| 213 |
# Test PyList_SetSlice() |
| 214 |
list_setslice = _testlimitedcapi.list_setslice |
| 215 |
def set_slice(lst, low, high, value): |
| 216 |
lst = lst.copy() |
| 217 |
self.assertEqual(list_setslice(lst, low, high, value), 0) |
| 218 |
return lst |
| 219 |
|
| 220 |
# insert items |
| 221 |
self.assertEqual(set_slice([], 0, 0, list("abc")), list("abc")) |
| 222 |
self.assertEqual(set_slice([], PY_SSIZE_T_MIN, PY_SSIZE_T_MIN, list("abc")), list("abc")) |
| 223 |
self.assertEqual(set_slice([], PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, list("abc")), list("abc")) |
| 224 |
lst = list("abc") |
| 225 |
self.assertEqual(set_slice(lst, 0, 0, ["X"]), list("Xabc")) |
| 226 |
self.assertEqual(set_slice(lst, 1, 1, list("XY")), list("aXYbc")) |
| 227 |
self.assertEqual(set_slice(lst, len(lst), len(lst), ["X"]), list("abcX")) |
| 228 |
# self.assertEqual(set_slice(lst, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, ["X"]), list("abcX")) |
| 229 |
|
| 230 |
# replace items |
| 231 |
lst = list("abc") |
| 232 |
self.assertEqual(set_slice(lst, -100, 1, list("X")), list("Xbc")) |
| 233 |
self.assertEqual(set_slice(lst, 1, 2, list("X")), list("aXc")) |
| 234 |
self.assertEqual(set_slice(lst, 1, 3, list("XY")), list("aXY")) |
| 235 |
self.assertEqual(set_slice(lst, 0, 3, list("XYZ")), list("XYZ")) |
| 236 |
|
| 237 |
# delete items |
| 238 |
lst = list("abcdef") |
| 239 |
self.assertEqual(set_slice(lst, 0, len(lst), []), []) |
| 240 |
self.assertEqual(set_slice(lst, -100, 100, []), []) |
| 241 |
self.assertEqual(set_slice(lst, 1, 5, []), list("af")) |
| 242 |
self.assertEqual(set_slice(lst, 3, len(lst), []), list("abc")) |
| 243 |
|
| 244 |
# delete items with NULL |
| 245 |
lst = list("abcdef") |
| 246 |
self.assertEqual(set_slice(lst, 0, len(lst), NULL), []) |
| 247 |
self.assertEqual(set_slice(lst, 3, len(lst), NULL), list("abc")) |
| 248 |
|
| 249 |
self.assertRaises(SystemError, list_setslice, (), 0, 0, []) |
| 250 |
self.assertRaises(SystemError, list_setslice, 42, 0, 0, []) |
| 251 |
|
| 252 |
# Item finalizer modify the list (clear the list) |
| 253 |
lst = [] |
| 254 |
lst.append(DelAppend(lst, 'zombie')) |
| 255 |
self.assertEqual(list_setslice(lst, 0, len(lst), NULL), 0) |
| 256 |
self.assertEqual(lst, ['zombie']) |
| 257 |
|
| 258 |
# Item finalizer modify the list (remove an list item) |
| 259 |
lst = [] |
| 260 |
lst.append(DelAppend(lst, 'zombie')) |
| 261 |
lst.extend("abc") |
| 262 |
self.assertEqual(list_setslice(lst, 0, 1, NULL), 0) |
| 263 |
self.assertEqual(lst, ['a', 'b', 'c', 'zombie']) |
| 264 |
|
| 265 |
# CRASHES setslice(NULL, 0, 0, []) |
| 266 |
|
| 267 |
def test_list_sort(self): |
| 268 |
# Test PyList_Sort() |
| 269 |
sort = _testlimitedcapi.list_sort |
| 270 |
lst = [4, 6, 7, 3, 1, 5, 9, 2, 0, 8] |
| 271 |
sort(lst) |
| 272 |
self.assertEqual(lst, list(range(10))) |
| 273 |
|
| 274 |
lst2 = ListSubclass([4, 6, 7, 3, 1, 5, 9, 2, 0, 8]) |
| 275 |
sort(lst2) |
| 276 |
self.assertEqual(lst2, list(range(10))) |
| 277 |
|
| 278 |
self.assertRaises(SystemError, sort, ()) |
| 279 |
self.assertRaises(SystemError, sort, object()) |
| 280 |
self.assertRaises(SystemError, sort, NULL) |
| 281 |
|
| 282 |
|
| 283 |
def test_list_reverse(self): |
| 284 |
# Test PyList_Reverse() |
| 285 |
reverse = _testlimitedcapi.list_reverse |
| 286 |
def list_reverse(lst): |
| 287 |
self.assertEqual(reverse(lst), 0) |
| 288 |
return lst |
| 289 |
|
| 290 |
self.assertEqual(list_reverse([]), []) |
| 291 |
self.assertEqual(list_reverse([2, 5, 10]), [10, 5, 2]) |
| 292 |
self.assertEqual(list_reverse(list_reverse([2, 5, 10])), [2, 5, 10]) |
| 293 |
|
| 294 |
self.assertRaises(SystemError, reverse, ()) |
| 295 |
self.assertRaises(SystemError, reverse, object()) |
| 296 |
self.assertRaises(SystemError, reverse, NULL) |
| 297 |
|
| 298 |
def test_list_astuple(self): |
| 299 |
# Test PyList_AsTuple() |
| 300 |
astuple = _testlimitedcapi.list_astuple |
| 301 |
self.assertEqual(astuple([]), ()) |
| 302 |
self.assertEqual(astuple([[]]), ([],)) |
| 303 |
self.assertEqual(astuple([2, 5, 10]), (2, 5, 10)) |
| 304 |
|
| 305 |
self.assertRaises(SystemError, astuple, ()) |
| 306 |
self.assertRaises(SystemError, astuple, object()) |
| 307 |
self.assertRaises(SystemError, astuple, NULL) |
| 308 |
|
| 309 |
def test_list_clear(self): |
| 310 |
# Test PyList_Clear() |
| 311 |
list_clear = _testcapi.list_clear |
| 312 |
|
| 313 |
lst = [1, 2, 3] |
| 314 |
self.assertEqual(list_clear(lst), 0) |
| 315 |
self.assertEqual(lst, []) |
| 316 |
|
| 317 |
lst = [] |
| 318 |
self.assertEqual(list_clear(lst), 0) |
| 319 |
self.assertEqual(lst, []) |
| 320 |
|
| 321 |
self.assertRaises(SystemError, list_clear, ()) |
| 322 |
self.assertRaises(SystemError, list_clear, object()) |
| 323 |
|
| 324 |
# Item finalizer modify the list |
| 325 |
lst = [] |
| 326 |
lst.append(DelAppend(lst, 'zombie')) |
| 327 |
list_clear(lst) |
| 328 |
self.assertEqual(lst, ['zombie']) |
| 329 |
|
| 330 |
# CRASHES list_clear(NULL) |
| 331 |
|
| 332 |
def test_list_extend(self): |
| 333 |
# Test PyList_Extend() |
| 334 |
list_extend = _testcapi.list_extend |
| 335 |
|
| 336 |
for other_type in (list, tuple, str, iter): |
| 337 |
lst = list("ab") |
| 338 |
arg = other_type("def") |
| 339 |
self.assertEqual(list_extend(lst, arg), 0) |
| 340 |
self.assertEqual(lst, list("abdef")) |
| 341 |
|
| 342 |
# PyList_Extend(lst, lst) |
| 343 |
lst = list("abc") |
| 344 |
self.assertEqual(list_extend(lst, lst), 0) |
| 345 |
self.assertEqual(lst, list("abcabc")) |
| 346 |
|
| 347 |
self.assertRaises(TypeError, list_extend, [], object()) |
| 348 |
self.assertRaises(SystemError, list_extend, (), list("abc")) |
| 349 |
|
| 350 |
# CRASHES list_extend(NULL, []) |
| 351 |
# CRASHES list_extend([], NULL) |
| 352 |
|
| 353 |
def test_uninitialized_list_repr(self): |
| 354 |
lst = _testlimitedcapi.list_new(3) |
| 355 |
self.assertEqual(repr(lst), '[<NULL>, <NULL>, <NULL>]') |
| 356 |
|
| 357 |
|
| 358 |
if __name__ == "__main__": |
| 359 |
unittest.main() |