Debian Codegraph @

Lib/test/test_capi/test_abstract.py

raw
1 import unittest
2 from collections import OrderedDict
3 from test import support
4 from test.support import import_helper
5
6 _testcapi = import_helper.import_module('_testcapi')
7 _testlimitedcapi = import_helper.import_module('_testlimitedcapi')
8 from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
9
10 NULL = None
11
12 class StrSubclass(str):
13 pass
14
15 class BytesSubclass(bytes):
16 pass
17
18 class WithStr:
19 def __init__(self, value):
20 self.value = value
21 def __str__(self):
22 return self.value
23
24 class WithRepr:
25 def __init__(self, value):
26 self.value = value
27 def __repr__(self):
28 return self.value
29
30 class WithBytes:
31 def __init__(self, value):
32 self.value = value
33 def __bytes__(self):
34 return self.value
35
36 class TestObject:
37 @property
38 def evil(self):
39 raise RuntimeError('do not get evil')
40 @evil.setter
41 def evil(self, value):
42 raise RuntimeError('do not set evil')
43 @evil.deleter
44 def evil(self):
45 raise RuntimeError('do not del evil')
46
47 class ProxyGetItem:
48 def __init__(self, obj):
49 self.obj = obj
50 def __getitem__(self, key):
51 return self.obj[key]
52
53 class ProxySetItem:
54 def __init__(self, obj):
55 self.obj = obj
56 def __setitem__(self, key, value):
57 self.obj[key] = value
58
59 class ProxyDelItem:
60 def __init__(self, obj):
61 self.obj = obj
62 def __delitem__(self, key):
63 del self.obj[key]
64
65 def gen():
66 yield 'a'
67 yield 'b'
68 yield 'c'
69
70
71 class CAPITest(unittest.TestCase):
72 def assertTypedEqual(self, actual, expected):
73 self.assertIs(type(actual), type(expected))
74 self.assertEqual(actual, expected)
75
76 def test_object_str(self):
77 # Test PyObject_Str()
78 object_str = _testlimitedcapi.object_str
79 self.assertTypedEqual(object_str(''), '')
80 self.assertTypedEqual(object_str('abc'), 'abc')
81 self.assertTypedEqual(object_str('\U0001f40d'), '\U0001f40d')
82 self.assertTypedEqual(object_str(StrSubclass('abc')), 'abc')
83 self.assertTypedEqual(object_str(WithStr('abc')), 'abc')
84 self.assertTypedEqual(object_str(WithStr(StrSubclass('abc'))), StrSubclass('abc'))
85 self.assertTypedEqual(object_str(WithRepr('<abc>')), '<abc>')
86 self.assertTypedEqual(object_str(WithRepr(StrSubclass('<abc>'))), StrSubclass('<abc>'))
87 self.assertTypedEqual(object_str(NULL), '<NULL>')
88
89 def test_object_repr(self):
90 # Test PyObject_Repr()
91 object_repr = _testlimitedcapi.object_repr
92 self.assertTypedEqual(object_repr(''), "''")
93 self.assertTypedEqual(object_repr('abc'), "'abc'")
94 self.assertTypedEqual(object_repr('\U0001f40d'), "'\U0001f40d'")
95 self.assertTypedEqual(object_repr(StrSubclass('abc')), "'abc'")
96 self.assertTypedEqual(object_repr(WithRepr('<abc>')), '<abc>')
97 self.assertTypedEqual(object_repr(WithRepr(StrSubclass('<abc>'))), StrSubclass('<abc>'))
98 self.assertTypedEqual(object_repr(WithRepr('<\U0001f40d>')), '<\U0001f40d>')
99 self.assertTypedEqual(object_repr(WithRepr(StrSubclass('<\U0001f40d>'))), StrSubclass('<\U0001f40d>'))
100 self.assertTypedEqual(object_repr(NULL), '<NULL>')
101
102 def test_object_ascii(self):
103 # Test PyObject_ASCII()
104 object_ascii = _testlimitedcapi.object_ascii
105 self.assertTypedEqual(object_ascii(''), "''")
106 self.assertTypedEqual(object_ascii('abc'), "'abc'")
107 self.assertTypedEqual(object_ascii('\U0001f40d'), r"'\U0001f40d'")
108 self.assertTypedEqual(object_ascii(StrSubclass('abc')), "'abc'")
109 self.assertTypedEqual(object_ascii(WithRepr('<abc>')), '<abc>')
110 self.assertTypedEqual(object_ascii(WithRepr(StrSubclass('<abc>'))), StrSubclass('<abc>'))
111 self.assertTypedEqual(object_ascii(WithRepr('<\U0001f40d>')), r'<\U0001f40d>')
112 self.assertTypedEqual(object_ascii(WithRepr(StrSubclass('<\U0001f40d>'))), r'<\U0001f40d>')
113 self.assertTypedEqual(object_ascii(NULL), '<NULL>')
114
115 def test_object_bytes(self):
116 # Test PyObject_Bytes()
117 object_bytes = _testlimitedcapi.object_bytes
118 self.assertTypedEqual(object_bytes(b''), b'')
119 self.assertTypedEqual(object_bytes(b'abc'), b'abc')
120 self.assertTypedEqual(object_bytes(BytesSubclass(b'abc')), b'abc')
121 self.assertTypedEqual(object_bytes(WithBytes(b'abc')), b'abc')
122 self.assertTypedEqual(object_bytes(WithBytes(BytesSubclass(b'abc'))), BytesSubclass(b'abc'))
123 self.assertTypedEqual(object_bytes(bytearray(b'abc')), b'abc')
124 self.assertTypedEqual(object_bytes(memoryview(b'abc')), b'abc')
125 self.assertTypedEqual(object_bytes([97, 98, 99]), b'abc')
126 self.assertTypedEqual(object_bytes((97, 98, 99)), b'abc')
127 self.assertTypedEqual(object_bytes(iter([97, 98, 99])), b'abc')
128 self.assertRaises(TypeError, object_bytes, WithBytes(bytearray(b'abc')))
129 self.assertRaises(TypeError, object_bytes, WithBytes([97, 98, 99]))
130 self.assertRaises(TypeError, object_bytes, 3)
131 self.assertRaises(TypeError, object_bytes, 'abc')
132 self.assertRaises(TypeError, object_bytes, object())
133 self.assertTypedEqual(object_bytes(NULL), b'<NULL>')
134
135 def test_object_getattr(self):
136 xgetattr = _testlimitedcapi.object_getattr
137 obj = TestObject()
138 obj.a = 11
139 setattr(obj, '\U0001f40d', 22)
140 self.assertEqual(xgetattr(obj, 'a'), 11)
141 self.assertRaises(AttributeError, xgetattr, obj, 'b')
142 self.assertEqual(xgetattr(obj, '\U0001f40d'), 22)
143
144 self.assertRaises(RuntimeError, xgetattr, obj, 'evil')
145 self.assertRaises(TypeError, xgetattr, obj, 1)
146 # CRASHES xgetattr(obj, NULL)
147 # CRASHES xgetattr(NULL, 'a')
148
149 def test_object_getattrstring(self):
150 getattrstring = _testlimitedcapi.object_getattrstring
151 obj = TestObject()
152 obj.a = 11
153 setattr(obj, '\U0001f40d', 22)
154 self.assertEqual(getattrstring(obj, b'a'), 11)
155 self.assertRaises(AttributeError, getattrstring, obj, b'b')
156 self.assertEqual(getattrstring(obj, '\U0001f40d'.encode()), 22)
157
158 self.assertRaises(RuntimeError, getattrstring, obj, b'evil')
159 self.assertRaises(UnicodeDecodeError, getattrstring, obj, b'\xff')
160 # CRASHES getattrstring(obj, NULL)
161 # CRASHES getattrstring(NULL, b'a')
162
163 def test_object_getoptionalattr(self):
164 getoptionalattr = _testcapi.object_getoptionalattr
165 obj = TestObject()
166 obj.a = 11
167 setattr(obj, '\U0001f40d', 22)
168 self.assertEqual(getoptionalattr(obj, 'a'), 11)
169 self.assertIs(getoptionalattr(obj, 'b'), AttributeError)
170 self.assertEqual(getoptionalattr(obj, '\U0001f40d'), 22)
171
172 self.assertRaises(RuntimeError, getoptionalattr, obj, 'evil')
173 self.assertRaises(TypeError, getoptionalattr, obj, 1)
174 # CRASHES getoptionalattr(obj, NULL)
175 # CRASHES getoptionalattr(NULL, 'a')
176
177 def test_object_getoptionalattrstring(self):
178 getoptionalattrstring = _testcapi.object_getoptionalattrstring
179 obj = TestObject()
180 obj.a = 11
181 setattr(obj, '\U0001f40d', 22)
182 self.assertEqual(getoptionalattrstring(obj, b'a'), 11)
183 self.assertIs(getoptionalattrstring(obj, b'b'), AttributeError)
184 self.assertEqual(getoptionalattrstring(obj, '\U0001f40d'.encode()), 22)
185
186 self.assertRaises(RuntimeError, getoptionalattrstring, obj, b'evil')
187 self.assertRaises(UnicodeDecodeError, getoptionalattrstring, obj, b'\xff')
188 # CRASHES getoptionalattrstring(obj, NULL)
189 # CRASHES getoptionalattrstring(NULL, b'a')
190
191 def test_object_hasattr(self):
192 xhasattr = _testlimitedcapi.object_hasattr
193 obj = TestObject()
194 obj.a = 1
195 setattr(obj, '\U0001f40d', 2)
196 self.assertTrue(xhasattr(obj, 'a'))
197 self.assertFalse(xhasattr(obj, 'b'))
198 self.assertTrue(xhasattr(obj, '\U0001f40d'))
199
200 with support.catch_unraisable_exception() as cm:
201 self.assertFalse(xhasattr(obj, 'evil'))
202 self.assertEqual(cm.unraisable.exc_type, RuntimeError)
203 self.assertEqual(str(cm.unraisable.exc_value),
204 'do not get evil')
205
206 with support.catch_unraisable_exception() as cm:
207 self.assertFalse(xhasattr(obj, 1))
208 self.assertEqual(cm.unraisable.exc_type, TypeError)
209 self.assertEqual(str(cm.unraisable.exc_value),
210 "attribute name must be string, not 'int'")
211
212 # CRASHES xhasattr(obj, NULL)
213 # CRASHES xhasattr(NULL, 'a')
214
215 def test_object_hasattrstring(self):
216 hasattrstring = _testlimitedcapi.object_hasattrstring
217 obj = TestObject()
218 obj.a = 1
219 setattr(obj, '\U0001f40d', 2)
220 self.assertTrue(hasattrstring(obj, b'a'))
221 self.assertFalse(hasattrstring(obj, b'b'))
222 self.assertTrue(hasattrstring(obj, '\U0001f40d'.encode()))
223
224 with support.catch_unraisable_exception() as cm:
225 self.assertFalse(hasattrstring(obj, b'evil'))
226 self.assertEqual(cm.unraisable.exc_type, RuntimeError)
227 self.assertEqual(str(cm.unraisable.exc_value),
228 'do not get evil')
229
230 with support.catch_unraisable_exception() as cm:
231 self.assertFalse(hasattrstring(obj, b'\xff'))
232 self.assertEqual(cm.unraisable.exc_type, UnicodeDecodeError)
233 self.assertRegex(str(cm.unraisable.exc_value),
234 "'utf-8' codec can't decode")
235
236 # CRASHES hasattrstring(obj, NULL)
237 # CRASHES hasattrstring(NULL, b'a')
238
239 def test_object_hasattrwitherror(self):
240 xhasattr = _testcapi.object_hasattrwitherror
241 obj = TestObject()
242 obj.a = 1
243 setattr(obj, '\U0001f40d', 2)
244 self.assertTrue(xhasattr(obj, 'a'))
245 self.assertFalse(xhasattr(obj, 'b'))
246 self.assertTrue(xhasattr(obj, '\U0001f40d'))
247
248 self.assertRaises(RuntimeError, xhasattr, obj, 'evil')
249 self.assertRaises(TypeError, xhasattr, obj, 1)
250 # CRASHES xhasattr(obj, NULL)
251 # CRASHES xhasattr(NULL, 'a')
252
253 def test_object_hasattrstringwitherror(self):
254 hasattrstring = _testcapi.object_hasattrstringwitherror
255 obj = TestObject()
256 obj.a = 1
257 setattr(obj, '\U0001f40d', 2)
258 self.assertTrue(hasattrstring(obj, b'a'))
259 self.assertFalse(hasattrstring(obj, b'b'))
260 self.assertTrue(hasattrstring(obj, '\U0001f40d'.encode()))
261
262 self.assertRaises(RuntimeError, hasattrstring, obj, b'evil')
263 self.assertRaises(UnicodeDecodeError, hasattrstring, obj, b'\xff')
264 # CRASHES hasattrstring(obj, NULL)
265 # CRASHES hasattrstring(NULL, b'a')
266
267 def test_object_setattr(self):
268 xsetattr = _testlimitedcapi.object_setattr
269 obj = TestObject()
270 xsetattr(obj, 'a', 5)
271 self.assertEqual(obj.a, 5)
272 xsetattr(obj, '\U0001f40d', 8)
273 self.assertEqual(getattr(obj, '\U0001f40d'), 8)
274
275 # PyObject_SetAttr(obj, attr_name, NULL) removes the attribute
276 xsetattr(obj, 'a', NULL)
277 self.assertNotHasAttr(obj, 'a')
278 self.assertRaises(AttributeError, xsetattr, obj, 'b', NULL)
279 self.assertRaises(RuntimeError, xsetattr, obj, 'evil', NULL)
280
281 self.assertRaises(RuntimeError, xsetattr, obj, 'evil', 'good')
282 self.assertRaises(AttributeError, xsetattr, 42, 'a', 5)
283 self.assertRaises(TypeError, xsetattr, obj, 1, 5)
284 # CRASHES xsetattr(obj, NULL, 5)
285 # CRASHES xsetattr(NULL, 'a', 5)
286
287 def test_object_setattrstring(self):
288 setattrstring = _testlimitedcapi.object_setattrstring
289 obj = TestObject()
290 setattrstring(obj, b'a', 5)
291 self.assertEqual(obj.a, 5)
292 setattrstring(obj, '\U0001f40d'.encode(), 8)
293 self.assertEqual(getattr(obj, '\U0001f40d'), 8)
294
295 # PyObject_SetAttrString(obj, attr_name, NULL) removes the attribute
296 setattrstring(obj, b'a', NULL)
297 self.assertNotHasAttr(obj, 'a')
298 self.assertRaises(AttributeError, setattrstring, obj, b'b', NULL)
299 self.assertRaises(RuntimeError, setattrstring, obj, b'evil', NULL)
300
301 self.assertRaises(RuntimeError, setattrstring, obj, b'evil', 'good')
302 self.assertRaises(AttributeError, setattrstring, 42, b'a', 5)
303 self.assertRaises(TypeError, setattrstring, obj, 1, 5)
304 self.assertRaises(UnicodeDecodeError, setattrstring, obj, b'\xff', 5)
305 # CRASHES setattrstring(obj, NULL, 5)
306 # CRASHES setattrstring(NULL, b'a', 5)
307
308 def test_object_delattr(self):
309 xdelattr = _testlimitedcapi.object_delattr
310 obj = TestObject()
311 obj.a = 1
312 setattr(obj, '\U0001f40d', 2)
313 xdelattr(obj, 'a')
314 self.assertNotHasAttr(obj, 'a')
315 self.assertRaises(AttributeError, xdelattr, obj, 'b')
316 xdelattr(obj, '\U0001f40d')
317 self.assertNotHasAttr(obj, '\U0001f40d')
318
319 self.assertRaises(AttributeError, xdelattr, 42, 'numerator')
320 self.assertRaises(RuntimeError, xdelattr, obj, 'evil')
321 self.assertRaises(TypeError, xdelattr, obj, 1)
322 # CRASHES xdelattr(obj, NULL)
323 # CRASHES xdelattr(NULL, 'a')
324
325 def test_object_delattrstring(self):
326 delattrstring = _testlimitedcapi.object_delattrstring
327 obj = TestObject()
328 obj.a = 1
329 setattr(obj, '\U0001f40d', 2)
330 delattrstring(obj, b'a')
331 self.assertNotHasAttr(obj, 'a')
332 self.assertRaises(AttributeError, delattrstring, obj, b'b')
333 delattrstring(obj, '\U0001f40d'.encode())
334 self.assertNotHasAttr(obj, '\U0001f40d')
335
336 self.assertRaises(AttributeError, delattrstring, 42, b'numerator')
337 self.assertRaises(RuntimeError, delattrstring, obj, b'evil')
338 self.assertRaises(UnicodeDecodeError, delattrstring, obj, b'\xff')
339 # CRASHES delattrstring(obj, NULL)
340 # CRASHES delattrstring(NULL, b'a')
341
342
343 def test_mapping_check(self):
344 check = _testlimitedcapi.mapping_check
345 self.assertTrue(check({1: 2}))
346 self.assertTrue(check([1, 2]))
347 self.assertTrue(check((1, 2)))
348 self.assertTrue(check('abc'))
349 self.assertTrue(check(b'abc'))
350 self.assertFalse(check(42))
351 self.assertFalse(check(object()))
352 self.assertFalse(check(NULL))
353
354 def test_mapping_size(self):
355 for size in _testlimitedcapi.mapping_size, _testlimitedcapi.mapping_length:
356 self.assertEqual(size({1: 2}), 1)
357 self.assertEqual(size([1, 2]), 2)
358 self.assertEqual(size((1, 2)), 2)
359 self.assertEqual(size('abc'), 3)
360 self.assertEqual(size(b'abc'), 3)
361
362 self.assertRaises(TypeError, size, 42)
363 self.assertRaises(TypeError, size, object())
364 self.assertRaises(SystemError, size, NULL)
365
366 def test_object_getitem(self):
367 getitem = _testlimitedcapi.object_getitem
368 dct = {'a': 1, '\U0001f40d': 2}
369 self.assertEqual(getitem(dct, 'a'), 1)
370 self.assertRaises(KeyError, getitem, dct, 'b')
371 self.assertEqual(getitem(dct, '\U0001f40d'), 2)
372
373 dct2 = ProxyGetItem(dct)
374 self.assertEqual(getitem(dct2, 'a'), 1)
375 self.assertRaises(KeyError, getitem, dct2, 'b')
376
377 self.assertEqual(getitem(['a', 'b', 'c'], 1), 'b')
378
379 self.assertRaises(TypeError, getitem, 42, 'a')
380 self.assertRaises(TypeError, getitem, {}, []) # unhashable
381 self.assertRaises(SystemError, getitem, {}, NULL)
382 self.assertRaises(IndexError, getitem, [], 1)
383 self.assertRaises(TypeError, getitem, [], 'a')
384 self.assertRaises(SystemError, getitem, NULL, 'a')
385
386 def test_mapping_getitemstring(self):
387 getitemstring = _testlimitedcapi.mapping_getitemstring
388 dct = {'a': 1, '\U0001f40d': 2}
389 self.assertEqual(getitemstring(dct, b'a'), 1)
390 self.assertRaises(KeyError, getitemstring, dct, b'b')
391 self.assertEqual(getitemstring(dct, '\U0001f40d'.encode()), 2)
392
393 dct2 = ProxyGetItem(dct)
394 self.assertEqual(getitemstring(dct2, b'a'), 1)
395 self.assertRaises(KeyError, getitemstring, dct2, b'b')
396
397 self.assertRaises(TypeError, getitemstring, 42, b'a')
398 self.assertRaises(UnicodeDecodeError, getitemstring, {}, b'\xff')
399 self.assertRaises(SystemError, getitemstring, {}, NULL)
400 self.assertRaises(TypeError, getitemstring, [], b'a')
401 self.assertRaises(SystemError, getitemstring, NULL, b'a')
402
403 def test_mapping_getoptionalitem(self):
404 getitem = _testcapi.mapping_getoptionalitem
405 dct = {'a': 1, '\U0001f40d': 2}
406 self.assertEqual(getitem(dct, 'a'), 1)
407 self.assertEqual(getitem(dct, 'b'), KeyError)
408 self.assertEqual(getitem(dct, '\U0001f40d'), 2)
409
410 dct2 = ProxyGetItem(dct)
411 self.assertEqual(getitem(dct2, 'a'), 1)
412 self.assertEqual(getitem(dct2, 'b'), KeyError)
413
414 self.assertEqual(getitem(['a', 'b', 'c'], 1), 'b')
415
416 self.assertRaises(TypeError, getitem, 42, 'a')
417 self.assertRaises(TypeError, getitem, {}, []) # unhashable
418 self.assertRaises(IndexError, getitem, [], 1)
419 self.assertRaises(TypeError, getitem, [], 'a')
420 # CRASHES getitem({}, NULL)
421 # CRASHES getitem(NULL, 'a')
422
423 def test_mapping_getoptionalitemstring(self):
424 getitemstring = _testcapi.mapping_getoptionalitemstring
425 dct = {'a': 1, '\U0001f40d': 2}
426 self.assertEqual(getitemstring(dct, b'a'), 1)
427 self.assertEqual(getitemstring(dct, b'b'), KeyError)
428 self.assertEqual(getitemstring(dct, '\U0001f40d'.encode()), 2)
429
430 dct2 = ProxyGetItem(dct)
431 self.assertEqual(getitemstring(dct2, b'a'), 1)
432 self.assertEqual(getitemstring(dct2, b'b'), KeyError)
433
434 self.assertRaises(TypeError, getitemstring, 42, b'a')
435 self.assertRaises(UnicodeDecodeError, getitemstring, {}, b'\xff')
436 self.assertRaises(SystemError, getitemstring, {}, NULL)
437 self.assertRaises(TypeError, getitemstring, [], b'a')
438 # CRASHES getitemstring(NULL, b'a')
439
440 def test_mapping_haskey(self):
441 haskey = _testlimitedcapi.mapping_haskey
442 dct = {'a': 1, '\U0001f40d': 2}
443 self.assertTrue(haskey(dct, 'a'))
444 self.assertFalse(haskey(dct, 'b'))
445 self.assertTrue(haskey(dct, '\U0001f40d'))
446
447 dct2 = ProxyGetItem(dct)
448 self.assertTrue(haskey(dct2, 'a'))
449 self.assertFalse(haskey(dct2, 'b'))
450
451 self.assertTrue(haskey(['a', 'b', 'c'], 1))
452
453 with support.catch_unraisable_exception() as cm:
454 self.assertFalse(haskey(42, 'a'))
455 self.assertEqual(cm.unraisable.exc_type, TypeError)
456 self.assertEqual(str(cm.unraisable.exc_value),
457 "'int' object is not subscriptable")
458
459 with support.catch_unraisable_exception() as cm:
460 self.assertFalse(haskey({}, []))
461 self.assertEqual(cm.unraisable.exc_type, TypeError)
462 self.assertEqual(str(cm.unraisable.exc_value),
463 "cannot use 'list' as a dict key "
464 "(unhashable type: 'list')")
465
466 with support.catch_unraisable_exception() as cm:
467 self.assertFalse(haskey([], 1))
468 self.assertEqual(cm.unraisable.exc_type, IndexError)
469 self.assertEqual(str(cm.unraisable.exc_value),
470 'list index out of range')
471
472 with support.catch_unraisable_exception() as cm:
473 self.assertFalse(haskey([], 'a'))
474 self.assertEqual(cm.unraisable.exc_type, TypeError)
475 self.assertEqual(str(cm.unraisable.exc_value),
476 'list indices must be integers or slices, not str')
477
478 with support.catch_unraisable_exception() as cm:
479 self.assertFalse(haskey({}, NULL))
480 self.assertEqual(cm.unraisable.exc_type, SystemError)
481 self.assertEqual(str(cm.unraisable.exc_value),
482 'null argument to internal routine')
483
484 with support.catch_unraisable_exception() as cm:
485 self.assertFalse(haskey(NULL, 'a'))
486 self.assertEqual(cm.unraisable.exc_type, SystemError)
487 self.assertEqual(str(cm.unraisable.exc_value),
488 'null argument to internal routine')
489
490 def test_mapping_haskeystring(self):
491 haskeystring = _testlimitedcapi.mapping_haskeystring
492 dct = {'a': 1, '\U0001f40d': 2}
493 self.assertTrue(haskeystring(dct, b'a'))
494 self.assertFalse(haskeystring(dct, b'b'))
495 self.assertTrue(haskeystring(dct, '\U0001f40d'.encode()))
496
497 dct2 = ProxyGetItem(dct)
498 self.assertTrue(haskeystring(dct2, b'a'))
499 self.assertFalse(haskeystring(dct2, b'b'))
500
501 with support.catch_unraisable_exception() as cm:
502 self.assertFalse(haskeystring(42, b'a'))
503 self.assertEqual(cm.unraisable.exc_type, TypeError)
504 self.assertEqual(str(cm.unraisable.exc_value),
505 "'int' object is not subscriptable")
506
507 with support.catch_unraisable_exception() as cm:
508 self.assertFalse(haskeystring({}, b'\xff'))
509 self.assertEqual(cm.unraisable.exc_type, UnicodeDecodeError)
510 self.assertRegex(str(cm.unraisable.exc_value),
511 "'utf-8' codec can't decode")
512
513 with support.catch_unraisable_exception() as cm:
514 self.assertFalse(haskeystring({}, NULL))
515 self.assertEqual(cm.unraisable.exc_type, SystemError)
516 self.assertEqual(str(cm.unraisable.exc_value),
517 "null argument to internal routine")
518
519 with support.catch_unraisable_exception() as cm:
520 self.assertFalse(haskeystring([], b'a'))
521 self.assertEqual(cm.unraisable.exc_type, TypeError)
522 self.assertEqual(str(cm.unraisable.exc_value),
523 'list indices must be integers or slices, not str')
524
525 with support.catch_unraisable_exception() as cm:
526 self.assertFalse(haskeystring(NULL, b'a'))
527 self.assertEqual(cm.unraisable.exc_type, SystemError)
528 self.assertEqual(str(cm.unraisable.exc_value),
529 "null argument to internal routine")
530
531 def test_mapping_haskeywitherror(self):
532 haskey = _testlimitedcapi.mapping_haskeywitherror
533 dct = {'a': 1, '\U0001f40d': 2}
534 self.assertTrue(haskey(dct, 'a'))
535 self.assertFalse(haskey(dct, 'b'))
536 self.assertTrue(haskey(dct, '\U0001f40d'))
537
538 dct2 = ProxyGetItem(dct)
539 self.assertTrue(haskey(dct2, 'a'))
540 self.assertFalse(haskey(dct2, 'b'))
541
542 self.assertTrue(haskey(['a', 'b', 'c'], 1))
543
544 self.assertRaises(TypeError, haskey, 42, 'a')
545 self.assertRaises(TypeError, haskey, {}, []) # unhashable
546 self.assertRaises(IndexError, haskey, [], 1)
547 self.assertRaises(TypeError, haskey, [], 'a')
548
549 # CRASHES haskey({}, NULL))
550 # CRASHES haskey(NULL, 'a'))
551
552 def test_mapping_haskeystringwitherror(self):
553 haskeystring = _testlimitedcapi.mapping_haskeystringwitherror
554 dct = {'a': 1, '\U0001f40d': 2}
555 self.assertTrue(haskeystring(dct, b'a'))
556 self.assertFalse(haskeystring(dct, b'b'))
557 self.assertTrue(haskeystring(dct, '\U0001f40d'.encode()))
558
559 dct2 = ProxyGetItem(dct)
560 self.assertTrue(haskeystring(dct2, b'a'))
561 self.assertFalse(haskeystring(dct2, b'b'))
562
563 self.assertRaises(TypeError, haskeystring, 42, b'a')
564 self.assertRaises(UnicodeDecodeError, haskeystring, {}, b'\xff')
565 self.assertRaises(SystemError, haskeystring, {}, NULL)
566 self.assertRaises(TypeError, haskeystring, [], b'a')
567 # CRASHES haskeystring(NULL, b'a')
568
569 def test_object_setitem(self):
570 setitem = _testlimitedcapi.object_setitem
571 dct = {}
572 setitem(dct, 'a', 5)
573 self.assertEqual(dct, {'a': 5})
574 setitem(dct, '\U0001f40d', 8)
575 self.assertEqual(dct, {'a': 5, '\U0001f40d': 8})
576
577 dct = {}
578 dct2 = ProxySetItem(dct)
579 setitem(dct2, 'a', 5)
580 self.assertEqual(dct, {'a': 5})
581
582 lst = ['a', 'b', 'c']
583 setitem(lst, 1, 'x')
584 self.assertEqual(lst, ['a', 'x', 'c'])
585
586 self.assertRaises(TypeError, setitem, 42, 'a', 5)
587 self.assertRaises(TypeError, setitem, {}, [], 5) # unhashable
588 self.assertRaises(SystemError, setitem, {}, NULL, 5)
589 self.assertRaises(SystemError, setitem, {}, 'a', NULL)
590 self.assertRaises(IndexError, setitem, [], 1, 5)
591 self.assertRaises(TypeError, setitem, [], 'a', 5)
592 self.assertRaises(TypeError, setitem, (), 1, 5)
593 self.assertRaises(SystemError, setitem, NULL, 'a', 5)
594
595 def test_mapping_setitemstring(self):
596 setitemstring = _testlimitedcapi.mapping_setitemstring
597 dct = {}
598 setitemstring(dct, b'a', 5)
599 self.assertEqual(dct, {'a': 5})
600 setitemstring(dct, '\U0001f40d'.encode(), 8)
601 self.assertEqual(dct, {'a': 5, '\U0001f40d': 8})
602
603 dct = {}
604 dct2 = ProxySetItem(dct)
605 setitemstring(dct2, b'a', 5)
606 self.assertEqual(dct, {'a': 5})
607
608 self.assertRaises(TypeError, setitemstring, 42, b'a', 5)
609 self.assertRaises(UnicodeDecodeError, setitemstring, {}, b'\xff', 5)
610 self.assertRaises(SystemError, setitemstring, {}, NULL, 5)
611 self.assertRaises(SystemError, setitemstring, {}, b'a', NULL)
612 self.assertRaises(TypeError, setitemstring, [], b'a', 5)
613 self.assertRaises(SystemError, setitemstring, NULL, b'a', 5)
614
615 def test_object_delitem(self):
616 for delitem in _testlimitedcapi.object_delitem, _testlimitedcapi.mapping_delitem:
617 dct = {'a': 1, 'c': 2, '\U0001f40d': 3}
618 delitem(dct, 'a')
619 self.assertEqual(dct, {'c': 2, '\U0001f40d': 3})
620 self.assertRaises(KeyError, delitem, dct, 'b')
621 delitem(dct, '\U0001f40d')
622 self.assertEqual(dct, {'c': 2})
623
624 dct = {'a': 1, 'c': 2}
625 dct2 = ProxyDelItem(dct)
626 delitem(dct2, 'a')
627 self.assertEqual(dct, {'c': 2})
628 self.assertRaises(KeyError, delitem, dct2, 'b')
629
630 lst = ['a', 'b', 'c']
631 delitem(lst, 1)
632 self.assertEqual(lst, ['a', 'c'])
633
634 self.assertRaises(TypeError, delitem, 42, 'a')
635 self.assertRaises(TypeError, delitem, {}, []) # unhashable
636 self.assertRaises(SystemError, delitem, {}, NULL)
637 self.assertRaises(IndexError, delitem, [], 1)
638 self.assertRaises(TypeError, delitem, [], 'a')
639 self.assertRaises(SystemError, delitem, NULL, 'a')
640
641 def test_mapping_delitemstring(self):
642 delitemstring = _testlimitedcapi.mapping_delitemstring
643 dct = {'a': 1, 'c': 2, '\U0001f40d': 3}
644 delitemstring(dct, b'a')
645 self.assertEqual(dct, {'c': 2, '\U0001f40d': 3})
646 self.assertRaises(KeyError, delitemstring, dct, b'b')
647 delitemstring(dct, '\U0001f40d'.encode())
648 self.assertEqual(dct, {'c': 2})
649
650 dct = {'a': 1, 'c': 2}
651 dct2 = ProxyDelItem(dct)
652 delitemstring(dct2, b'a')
653 self.assertEqual(dct, {'c': 2})
654 self.assertRaises(KeyError, delitemstring, dct2, b'b')
655
656 self.assertRaises(TypeError, delitemstring, 42, b'a')
657 self.assertRaises(UnicodeDecodeError, delitemstring, {}, b'\xff')
658 self.assertRaises(SystemError, delitemstring, {}, NULL)
659 self.assertRaises(TypeError, delitemstring, [], b'a')
660 self.assertRaises(SystemError, delitemstring, NULL, b'a')
661
662 def test_mapping_keys_valuesitems(self):
663 class Mapping1(dict):
664 def keys(self):
665 return list(super().keys())
666 def values(self):
667 return list(super().values())
668 def items(self):
669 return list(super().items())
670 class Mapping2(dict):
671 def keys(self):
672 return tuple(super().keys())
673 def values(self):
674 return tuple(super().values())
675 def items(self):
676 return tuple(super().items())
677 dict_obj = {'foo': 1, 'bar': 2, 'spam': 3}
678
679 for mapping in [{}, OrderedDict(), Mapping1(), Mapping2(),
680 dict_obj, OrderedDict(dict_obj),
681 Mapping1(dict_obj), Mapping2(dict_obj)]:
682 self.assertListEqual(_testlimitedcapi.mapping_keys(mapping),
683 list(mapping.keys()))
684 self.assertListEqual(_testlimitedcapi.mapping_values(mapping),
685 list(mapping.values()))
686 self.assertListEqual(_testlimitedcapi.mapping_items(mapping),
687 list(mapping.items()))
688
689 def test_mapping_keys_valuesitems_bad_arg(self):
690 self.assertRaises(AttributeError, _testlimitedcapi.mapping_keys, object())
691 self.assertRaises(AttributeError, _testlimitedcapi.mapping_values, object())
692 self.assertRaises(AttributeError, _testlimitedcapi.mapping_items, object())
693 self.assertRaises(AttributeError, _testlimitedcapi.mapping_keys, [])
694 self.assertRaises(AttributeError, _testlimitedcapi.mapping_values, [])
695 self.assertRaises(AttributeError, _testlimitedcapi.mapping_items, [])
696 self.assertRaises(SystemError, _testlimitedcapi.mapping_keys, NULL)
697 self.assertRaises(SystemError, _testlimitedcapi.mapping_values, NULL)
698 self.assertRaises(SystemError, _testlimitedcapi.mapping_items, NULL)
699
700 class BadMapping:
701 def keys(self):
702 return None
703 def values(self):
704 return None
705 def items(self):
706 return None
707 bad_mapping = BadMapping()
708 self.assertRaises(TypeError, _testlimitedcapi.mapping_keys, bad_mapping)
709 self.assertRaises(TypeError, _testlimitedcapi.mapping_values, bad_mapping)
710 self.assertRaises(TypeError, _testlimitedcapi.mapping_items, bad_mapping)
711
712 def test_sequence_check(self):
713 check = _testlimitedcapi.sequence_check
714 self.assertFalse(check({1: 2}))
715 self.assertTrue(check([1, 2]))
716 self.assertTrue(check((1, 2)))
717 self.assertTrue(check('abc'))
718 self.assertTrue(check(b'abc'))
719 self.assertFalse(check(42))
720 self.assertFalse(check(object()))
721 # CRASHES check(NULL)
722
723 def test_sequence_size(self):
724 for size in _testlimitedcapi.sequence_size, _testlimitedcapi.sequence_length:
725 self.assertEqual(size([1, 2]), 2)
726 self.assertEqual(size((1, 2)), 2)
727 self.assertEqual(size('abc'), 3)
728 self.assertEqual(size(b'abc'), 3)
729
730 self.assertRaises(TypeError, size, {})
731 self.assertRaises(TypeError, size, 42)
732 self.assertRaises(TypeError, size, object())
733 self.assertRaises(SystemError, size, NULL)
734
735 def test_sequence_getitem(self):
736 getitem = _testlimitedcapi.sequence_getitem
737 lst = ['a', 'b', 'c']
738 self.assertEqual(getitem(lst, 1), 'b')
739 self.assertEqual(getitem(lst, -1), 'c')
740 self.assertRaises(IndexError, getitem, lst, 3)
741 self.assertRaises(IndexError, getitem, lst, PY_SSIZE_T_MAX)
742 self.assertRaises(IndexError, getitem, lst, PY_SSIZE_T_MIN)
743
744 self.assertRaises(TypeError, getitem, 42, 1)
745 self.assertRaises(TypeError, getitem, {}, 1)
746 self.assertRaises(SystemError, getitem, NULL, 1)
747
748 def test_sequence_concat(self):
749 concat = _testlimitedcapi.sequence_concat
750 self.assertEqual(concat(['a', 'b'], [1, 2]), ['a', 'b', 1, 2])
751 self.assertEqual(concat(('a', 'b'), (1, 2)), ('a', 'b', 1, 2))
752
753 self.assertRaises(TypeError, concat, [], ())
754 self.assertRaises(TypeError, concat, (), [])
755 self.assertRaises(TypeError, concat, [], 42)
756 self.assertRaises(TypeError, concat, 42, [])
757 self.assertRaises(TypeError, concat, 42, 43)
758 self.assertRaises(SystemError, concat, [], NULL)
759 self.assertRaises(SystemError, concat, NULL, [])
760
761 def test_sequence_repeat(self):
762 repeat = _testlimitedcapi.sequence_repeat
763 self.assertEqual(repeat(['a', 'b'], 2), ['a', 'b', 'a', 'b'])
764 self.assertEqual(repeat(('a', 'b'), 2), ('a', 'b', 'a', 'b'))
765 self.assertEqual(repeat(['a', 'b'], 0), [])
766 self.assertEqual(repeat(['a', 'b'], -1), [])
767 self.assertEqual(repeat(['a', 'b'], PY_SSIZE_T_MIN), [])
768 self.assertEqual(repeat([], PY_SSIZE_T_MAX), [])
769 self.assertRaises(MemoryError, repeat, ['a', 'b'], PY_SSIZE_T_MAX)
770
771 self.assertRaises(TypeError, repeat, set(), 2)
772 self.assertRaises(TypeError, repeat, 42, 2)
773 self.assertRaises(SystemError, repeat, NULL, 2)
774
775 def test_sequence_inplaceconcat(self):
776 inplaceconcat = _testlimitedcapi.sequence_inplaceconcat
777 lst = ['a', 'b']
778 res = inplaceconcat(lst, [1, 2])
779 self.assertEqual(res, ['a', 'b', 1, 2])
780 self.assertIs(res, lst)
781 lst = ['a', 'b']
782 res = inplaceconcat(lst, (1, 2))
783 self.assertEqual(res, ['a', 'b', 1, 2])
784 self.assertIs(res, lst)
785 self.assertEqual(inplaceconcat(('a', 'b'), (1, 2)), ('a', 'b', 1, 2))
786
787 self.assertRaises(TypeError, inplaceconcat, (), [])
788 self.assertRaises(TypeError, inplaceconcat, [], 42)
789 self.assertRaises(TypeError, inplaceconcat, 42, [])
790 self.assertRaises(TypeError, inplaceconcat, 42, 43)
791 self.assertRaises(SystemError, inplaceconcat, [], NULL)
792 self.assertRaises(SystemError, inplaceconcat, NULL, [])
793
794 def test_sequence_inplacerepeat(self):
795 inplacerepeat = _testlimitedcapi.sequence_inplacerepeat
796 lst = ['a', 'b']
797 res = inplacerepeat(lst, 2)
798 self.assertEqual(res, ['a', 'b', 'a', 'b'])
799 self.assertIs(res, lst)
800 self.assertEqual(inplacerepeat(('a', 'b'), 2), ('a', 'b', 'a', 'b'))
801 self.assertEqual(inplacerepeat(['a', 'b'], 0), [])
802 self.assertEqual(inplacerepeat(['a', 'b'], -1), [])
803 self.assertEqual(inplacerepeat(['a', 'b'], PY_SSIZE_T_MIN), [])
804 self.assertEqual(inplacerepeat([], PY_SSIZE_T_MAX), [])
805 self.assertRaises(MemoryError, inplacerepeat, ['a', 'b'], PY_SSIZE_T_MAX)
806
807 self.assertRaises(TypeError, inplacerepeat, set(), 2)
808 self.assertRaises(TypeError, inplacerepeat, 42, 2)
809 self.assertRaises(SystemError, inplacerepeat, NULL, 2)
810
811 def test_sequence_setitem(self):
812 setitem = _testlimitedcapi.sequence_setitem
813 lst = ['a', 'b', 'c']
814 setitem(lst, 1, 'x')
815 self.assertEqual(lst, ['a', 'x', 'c'])
816 setitem(lst, -1, 'y')
817 self.assertEqual(lst, ['a', 'x', 'y'])
818
819 setitem(lst, 0, NULL)
820 self.assertEqual(lst, ['x', 'y'])
821 self.assertRaises(IndexError, setitem, lst, 3, 'x')
822 self.assertRaises(IndexError, setitem, lst, PY_SSIZE_T_MAX, 'x')
823 self.assertRaises(IndexError, setitem, lst, PY_SSIZE_T_MIN, 'x')
824
825 self.assertRaises(TypeError, setitem, 42, 1, 'x')
826 self.assertRaises(TypeError, setitem, {}, 1, 'x')
827 self.assertRaises(SystemError, setitem, NULL, 1, 'x')
828
829 def test_sequence_delitem(self):
830 delitem = _testlimitedcapi.sequence_delitem
831 lst = ['a', 'b', 'c']
832 delitem(lst, 1)
833 self.assertEqual(lst, ['a', 'c'])
834 delitem(lst, -1)
835 self.assertEqual(lst, ['a'])
836 self.assertRaises(IndexError, delitem, lst, 3)
837 self.assertRaises(IndexError, delitem, lst, PY_SSIZE_T_MAX)
838 self.assertRaises(IndexError, delitem, lst, PY_SSIZE_T_MIN)
839
840 self.assertRaises(TypeError, delitem, 42, 1)
841 self.assertRaises(TypeError, delitem, {}, 1)
842 self.assertRaises(SystemError, delitem, NULL, 1)
843
844 def test_sequence_setslice(self):
845 setslice = _testlimitedcapi.sequence_setslice
846
847 # Correct case:
848 for start in [*range(-6, 7), PY_SSIZE_T_MIN, PY_SSIZE_T_MAX]:
849 for stop in [*range(-6, 7), PY_SSIZE_T_MIN, PY_SSIZE_T_MAX]:
850 data = [1, 2, 3, 4, 5]
851 data_copy = [1, 2, 3, 4, 5]
852 setslice(data, start, stop, [8, 9])
853 data_copy[start:stop] = [8, 9]
854 self.assertEqual(data, data_copy)
855
856 data = [1, 2, 3, 4, 5]
857 data_copy = [1, 2, 3, 4, 5]
858 setslice(data, start, stop, NULL)
859 del data_copy[start:stop]
860 self.assertEqual(data, data_copy)
861
862 # Custom class:
863 class Custom:
864 def __setitem__(self, index, value):
865 self.index = index
866 self.value = value
867
868 c = Custom()
869 setslice(c, 0, 5, 'abc')
870 self.assertEqual(c.index, slice(0, 5))
871 self.assertEqual(c.value, 'abc')
872
873 # Immutable sequences must raise:
874 bad_seq1 = (1, 2, 3, 4)
875 self.assertRaises(TypeError, setslice, bad_seq1, 1, 3, (8, 9))
876 self.assertEqual(bad_seq1, (1, 2, 3, 4))
877
878 bad_seq2 = 'abcd'
879 self.assertRaises(TypeError, setslice, bad_seq2, 1, 3, 'xy')
880 self.assertEqual(bad_seq2, 'abcd')
881
882 # Not a sequence:
883 self.assertRaises(TypeError, setslice, object(), 1, 3, 'xy')
884 self.assertRaises(SystemError, setslice, NULL, 1, 3, 'xy')
885
886 def test_sequence_delslice(self):
887 delslice = _testlimitedcapi.sequence_delslice
888
889 # Correct case:
890 for start in [*range(-6, 7), PY_SSIZE_T_MIN, PY_SSIZE_T_MAX]:
891 for stop in [*range(-6, 7), PY_SSIZE_T_MIN, PY_SSIZE_T_MAX]:
892 data = [1, 2, 3, 4, 5]
893 data_copy = [1, 2, 3, 4, 5]
894 delslice(data, start, stop)
895 del data_copy[start:stop]
896 self.assertEqual(data, data_copy)
897
898 # Custom class:
899 class Custom:
900 def __delitem__(self, index):
901 self.index = index
902
903 c = Custom()
904 delslice(c, 0, 5)
905 self.assertEqual(c.index, slice(0, 5))
906
907 # Immutable sequences must raise:
908 bad_seq1 = (1, 2, 3, 4)
909 self.assertRaises(TypeError, delslice, bad_seq1, 1, 3)
910 self.assertEqual(bad_seq1, (1, 2, 3, 4))
911
912 bad_seq2 = 'abcd'
913 self.assertRaises(TypeError, delslice, bad_seq2, 1, 3)
914 self.assertEqual(bad_seq2, 'abcd')
915
916 # Not a sequence:
917 self.assertRaises(TypeError, delslice, object(), 1, 3)
918 self.assertRaises(SystemError, delslice, NULL, 1, 3)
919
920 mapping = {1: 'a', 2: 'b', 3: 'c'}
921 self.assertRaises(KeyError, delslice, mapping, 1, 3)
922 self.assertEqual(mapping, {1: 'a', 2: 'b', 3: 'c'})
923
924 def test_sequence_count(self):
925 count = _testlimitedcapi.sequence_count
926
927 lst = ['a', 'b', 'a']
928 self.assertEqual(count(lst, 'a'), 2)
929 self.assertEqual(count(lst, 'c'), 0)
930 self.assertEqual(count(iter(lst), 'a'), 2)
931 self.assertEqual(count(iter(lst), 'c'), 0)
932 self.assertEqual(count({'a': 2}, 'a'), 1)
933
934 self.assertRaises(TypeError, count, 42, 'a')
935 self.assertRaises(SystemError, count, [], NULL)
936 self.assertRaises(SystemError, count, [1], NULL)
937 self.assertRaises(SystemError, count, NULL, 'a')
938
939 def test_sequence_contains(self):
940 contains = _testlimitedcapi.sequence_contains
941
942 lst = ['a', 'b', 'a']
943 self.assertEqual(contains(lst, 'a'), 1)
944 self.assertEqual(contains(lst, 'c'), 0)
945 self.assertEqual(contains(iter(lst), 'a'), 1)
946 self.assertEqual(contains(iter(lst), 'c'), 0)
947 self.assertEqual(contains({'a': 2}, 'a'), 1)
948
949 # XXX Only for empty sequences. Should be SystemError?
950 self.assertEqual(contains([], NULL), 0)
951
952 self.assertRaises(TypeError, contains, 42, 'a')
953 self.assertRaises(SystemError, contains, [1], NULL)
954 # CRASHES contains({}, NULL)
955 # CRASHES contains(set(), NULL)
956 # CRASHES contains(NULL, 'a')
957
958 def test_sequence_index(self):
959 index = _testlimitedcapi.sequence_index
960
961 lst = ['a', 'b', 'a']
962 self.assertEqual(index(lst, 'a'), 0)
963 self.assertEqual(index(lst, 'b'), 1)
964 self.assertRaises(ValueError, index, lst, 'c')
965 self.assertEqual(index(iter(lst), 'a'), 0)
966 self.assertEqual(index(iter(lst), 'b'), 1)
967 self.assertRaises(ValueError, index, iter(lst), 'c')
968 dct = {'a': 2, 'b': 3}
969 self.assertEqual(index(dct, 'a'), 0)
970 self.assertEqual(index(dct, 'b'), 1)
971 self.assertRaises(ValueError, index, dct, 'c')
972
973 self.assertRaises(TypeError, index, 42, 'a')
974 self.assertRaises(SystemError, index, [], NULL)
975 self.assertRaises(SystemError, index, [1], NULL)
976 self.assertRaises(SystemError, index, NULL, 'a')
977
978 def test_sequence_list(self):
979 xlist = _testlimitedcapi.sequence_list
980 self.assertEqual(xlist(['a', 'b', 'c']), ['a', 'b', 'c'])
981 self.assertEqual(xlist(('a', 'b', 'c')), ['a', 'b', 'c'])
982 self.assertEqual(xlist(iter(['a', 'b', 'c'])), ['a', 'b', 'c'])
983 self.assertEqual(xlist(gen()), ['a', 'b', 'c'])
984
985 self.assertRaises(TypeError, xlist, 42)
986 self.assertRaises(SystemError, xlist, NULL)
987
988 def test_sequence_tuple(self):
989 xtuple = _testlimitedcapi.sequence_tuple
990 self.assertEqual(xtuple(['a', 'b', 'c']), ('a', 'b', 'c'))
991 self.assertEqual(xtuple(('a', 'b', 'c')), ('a', 'b', 'c'))
992 self.assertEqual(xtuple(iter(['a', 'b', 'c'])), ('a', 'b', 'c'))
993 self.assertEqual(xtuple(gen()), ('a', 'b', 'c'))
994
995 self.assertRaises(TypeError, xtuple, 42)
996 self.assertRaises(SystemError, xtuple, NULL)
997
998 def test_sequence_fast(self):
999 # Test PySequence_Fast()
1000 sequence_fast = _testlimitedcapi.sequence_fast
1001 sequence_fast_get_size = _testcapi.sequence_fast_get_size
1002 sequence_fast_get_item = _testcapi.sequence_fast_get_item
1003
1004 tpl = ('a', 'b', 'c')
1005 fast = sequence_fast(tpl, "err_msg")
1006 self.assertIs(fast, tpl)
1007 self.assertEqual(sequence_fast_get_size(fast), 3)
1008 self.assertEqual(sequence_fast_get_item(fast, 2), 'c')
1009
1010 lst = ['a', 'b', 'c']
1011 fast = sequence_fast(lst, "err_msg")
1012 self.assertIs(fast, lst)
1013 self.assertEqual(sequence_fast_get_size(fast), 3)
1014 self.assertEqual(sequence_fast_get_item(fast, 2), 'c')
1015
1016 it = iter(['A', 'B'])
1017 fast = sequence_fast(it, "err_msg")
1018 self.assertEqual(fast, ['A', 'B'])
1019 self.assertEqual(sequence_fast_get_size(fast), 2)
1020 self.assertEqual(sequence_fast_get_item(fast, 1), 'B')
1021
1022 text = 'fast'
1023 fast = sequence_fast(text, "err_msg")
1024 self.assertEqual(fast, ['f', 'a', 's', 't'])
1025 self.assertEqual(sequence_fast_get_size(fast), 4)
1026 self.assertEqual(sequence_fast_get_item(fast, 0), 'f')
1027
1028 self.assertRaises(TypeError, sequence_fast, 42, "err_msg")
1029 self.assertRaises(SystemError, sequence_fast, NULL, "err_msg")
1030
1031 # CRASHES sequence_fast_get_size(NULL)
1032 # CRASHES sequence_fast_get_item(NULL, 0)
1033
1034 def test_object_generichash(self):
1035 # Test PyObject_GenericHash()
1036 generichash = _testcapi.object_generichash
1037 for obj in object(), 1, 'string', []:
1038 self.assertEqual(generichash(obj), object.__hash__(obj))
1039
1040 def run_iter_api_test(self, next_func):
1041 for data in (), [], (1, 2, 3), [1 , 2, 3], "123":
1042 with self.subTest(data=data):
1043 items = []
1044 it = iter(data)
1045 while (item := next_func(it)) is not None:
1046 items.append(item)
1047 self.assertEqual(items, list(data))
1048
1049 class Broken:
1050 def __init__(self):
1051 self.count = 0
1052
1053 def __next__(self):
1054 if self.count < 3:
1055 self.count += 1
1056 return self.count
1057 else:
1058 raise TypeError('bad type')
1059
1060 it = Broken()
1061 self.assertEqual(next_func(it), 1)
1062 self.assertEqual(next_func(it), 2)
1063 self.assertEqual(next_func(it), 3)
1064 with self.assertRaisesRegex(TypeError, 'bad type'):
1065 next_func(it)
1066
1067 def test_iter_next(self):
1068 from _testcapi import PyIter_Next
1069 self.run_iter_api_test(PyIter_Next)
1070 # CRASHES PyIter_Next(10)
1071
1072 def test_iter_nextitem(self):
1073 from _testcapi import PyIter_NextItem
1074 self.run_iter_api_test(PyIter_NextItem)
1075
1076 regex = "expected.*iterator.*got.*'int'"
1077 with self.assertRaisesRegex(TypeError, regex):
1078 PyIter_NextItem(10)
1079
1080
1081 if __name__ == "__main__":
1082 unittest.main()