Debian Codegraph @

Lib/test/test_capi/test_dict.py

raw
1 import unittest
2 from collections import OrderedDict, UserDict
3 from types import MappingProxyType
4 from test import support
5 from test.support import import_helper
6
7
8 _testcapi = import_helper.import_module("_testcapi")
9 _testlimitedcapi = import_helper.import_module("_testlimitedcapi")
10
11
12 NULL = None
13 INVALID_UTF8 = b'\xff'
14
15 class DictSubclass(dict):
16 def __getitem__(self, key):
17 raise RuntimeError('do not get evil')
18 def __setitem__(self, key, value):
19 raise RuntimeError('do not set evil')
20 def __delitem__(self, key):
21 raise RuntimeError('do not del evil')
22
23 def gen():
24 yield 'a'
25 yield 'b'
26 yield 'c'
27
28
29 class CAPITest(unittest.TestCase):
30
31 def test_dict_check(self):
32 check = _testlimitedcapi.dict_check
33 self.assertTrue(check({1: 2}))
34 self.assertTrue(check(OrderedDict({1: 2})))
35 self.assertFalse(check(UserDict({1: 2})))
36 self.assertFalse(check([1, 2]))
37 self.assertFalse(check(object()))
38 # CRASHES check(NULL)
39
40 def test_dict_checkexact(self):
41 check = _testlimitedcapi.dict_checkexact
42 self.assertTrue(check({1: 2}))
43 self.assertFalse(check(OrderedDict({1: 2})))
44 self.assertFalse(check(UserDict({1: 2})))
45 self.assertFalse(check([1, 2]))
46 self.assertFalse(check(object()))
47 # CRASHES check(NULL)
48
49 def test_dict_new(self):
50 dict_new = _testlimitedcapi.dict_new
51 dct = dict_new()
52 self.assertEqual(dct, {})
53 self.assertIs(type(dct), dict)
54 dct2 = dict_new()
55 self.assertIsNot(dct2, dct)
56
57 def test_dictproxy_new(self):
58 dictproxy_new = _testlimitedcapi.dictproxy_new
59 for dct in {1: 2}, OrderedDict({1: 2}), UserDict({1: 2}):
60 proxy = dictproxy_new(dct)
61 self.assertIs(type(proxy), MappingProxyType)
62 self.assertEqual(proxy, dct)
63 with self.assertRaises(TypeError):
64 proxy[1] = 3
65 self.assertEqual(proxy[1], 2)
66 dct[1] = 4
67 self.assertEqual(proxy[1], 4)
68
69 self.assertRaises(TypeError, dictproxy_new, [])
70 self.assertRaises(TypeError, dictproxy_new, 42)
71 # CRASHES dictproxy_new(NULL)
72
73 def test_dict_copy(self):
74 copy = _testlimitedcapi.dict_copy
75 for dct in {1: 2}, OrderedDict({1: 2}):
76 dct_copy = copy(dct)
77 self.assertIs(type(dct_copy), dict)
78 self.assertEqual(dct_copy, dct)
79
80 self.assertRaises(SystemError, copy, UserDict())
81 self.assertRaises(SystemError, copy, [])
82 self.assertRaises(SystemError, copy, 42)
83 self.assertRaises(SystemError, copy, NULL)
84
85 def test_dict_clear(self):
86 clear = _testlimitedcapi.dict_clear
87 dct = {1: 2}
88 clear(dct)
89 self.assertEqual(dct, {})
90
91 # NOTE: It is not safe to call it with OrderedDict.
92
93 # Has no effect for non-dicts.
94 dct = UserDict({1: 2})
95 clear(dct)
96 self.assertEqual(dct, {1: 2})
97 lst = [1, 2]
98 clear(lst)
99 self.assertEqual(lst, [1, 2])
100 clear(object())
101
102 # CRASHES? clear(NULL)
103
104 def test_dict_size(self):
105 size = _testlimitedcapi.dict_size
106 self.assertEqual(size({1: 2}), 1)
107 self.assertEqual(size(OrderedDict({1: 2})), 1)
108
109 self.assertRaises(SystemError, size, UserDict())
110 self.assertRaises(SystemError, size, [])
111 self.assertRaises(SystemError, size, 42)
112 self.assertRaises(SystemError, size, object())
113 self.assertRaises(SystemError, size, NULL)
114
115 def test_dict_getitem(self):
116 getitem = _testlimitedcapi.dict_getitem
117 dct = {'a': 1, '\U0001f40d': 2}
118 self.assertEqual(getitem(dct, 'a'), 1)
119 self.assertIs(getitem(dct, 'b'), KeyError)
120 self.assertEqual(getitem(dct, '\U0001f40d'), 2)
121
122 dct2 = DictSubclass(dct)
123 self.assertEqual(getitem(dct2, 'a'), 1)
124 self.assertIs(getitem(dct2, 'b'), KeyError)
125
126 with support.catch_unraisable_exception() as cm:
127 self.assertIs(getitem({}, []), KeyError) # unhashable
128 self.assertEqual(cm.unraisable.exc_type, TypeError)
129 self.assertEqual(str(cm.unraisable.exc_value),
130 "unhashable type: 'list'")
131
132 self.assertIs(getitem(42, 'a'), KeyError)
133 self.assertIs(getitem([1], 0), KeyError)
134 # CRASHES getitem({}, NULL)
135 # CRASHES getitem(NULL, 'a')
136
137 def test_dict_getitemstring(self):
138 getitemstring = _testlimitedcapi.dict_getitemstring
139 dct = {'a': 1, '\U0001f40d': 2}
140 self.assertEqual(getitemstring(dct, b'a'), 1)
141 self.assertIs(getitemstring(dct, b'b'), KeyError)
142 self.assertEqual(getitemstring(dct, '\U0001f40d'.encode()), 2)
143
144 dct2 = DictSubclass(dct)
145 self.assertEqual(getitemstring(dct2, b'a'), 1)
146 self.assertIs(getitemstring(dct2, b'b'), KeyError)
147
148 with support.catch_unraisable_exception() as cm:
149 self.assertIs(getitemstring({}, INVALID_UTF8), KeyError)
150 self.assertEqual(cm.unraisable.exc_type, UnicodeDecodeError)
151 self.assertRegex(str(cm.unraisable.exc_value),
152 "'utf-8' codec can't decode")
153
154 self.assertIs(getitemstring(42, b'a'), KeyError)
155 self.assertIs(getitemstring([], b'a'), KeyError)
156 # CRASHES getitemstring({}, NULL)
157 # CRASHES getitemstring(NULL, b'a')
158
159 def test_dict_getitemref(self):
160 getitem = _testcapi.dict_getitemref
161 dct = {'a': 1, '\U0001f40d': 2}
162 self.assertEqual(getitem(dct, 'a'), 1)
163 self.assertIs(getitem(dct, 'b'), KeyError)
164 self.assertEqual(getitem(dct, '\U0001f40d'), 2)
165
166 dct2 = DictSubclass(dct)
167 self.assertEqual(getitem(dct2, 'a'), 1)
168 self.assertIs(getitem(dct2, 'b'), KeyError)
169
170 self.assertRaises(SystemError, getitem, 42, 'a')
171 self.assertRaises(TypeError, getitem, {}, []) # unhashable
172 self.assertRaises(SystemError, getitem, [], 1)
173 self.assertRaises(SystemError, getitem, [], 'a')
174 # CRASHES getitem({}, NULL)
175 # CRASHES getitem(NULL, 'a')
176
177 def test_dict_getitemstringref(self):
178 getitemstring = _testcapi.dict_getitemstringref
179 dct = {'a': 1, '\U0001f40d': 2}
180 self.assertEqual(getitemstring(dct, b'a'), 1)
181 self.assertIs(getitemstring(dct, b'b'), KeyError)
182 self.assertEqual(getitemstring(dct, '\U0001f40d'.encode()), 2)
183
184 dct2 = DictSubclass(dct)
185 self.assertEqual(getitemstring(dct2, b'a'), 1)
186 self.assertIs(getitemstring(dct2, b'b'), KeyError)
187
188 self.assertRaises(SystemError, getitemstring, 42, b'a')
189 self.assertRaises(UnicodeDecodeError, getitemstring, {}, INVALID_UTF8)
190 self.assertRaises(SystemError, getitemstring, [], b'a')
191 # CRASHES getitemstring({}, NULL)
192 # CRASHES getitemstring(NULL, b'a')
193
194 def test_dict_getitemwitherror(self):
195 getitem = _testlimitedcapi.dict_getitemwitherror
196 dct = {'a': 1, '\U0001f40d': 2}
197 self.assertEqual(getitem(dct, 'a'), 1)
198 self.assertIs(getitem(dct, 'b'), KeyError)
199 self.assertEqual(getitem(dct, '\U0001f40d'), 2)
200
201 dct2 = DictSubclass(dct)
202 self.assertEqual(getitem(dct2, 'a'), 1)
203 self.assertIs(getitem(dct2, 'b'), KeyError)
204
205 self.assertRaises(SystemError, getitem, 42, 'a')
206 self.assertRaises(TypeError, getitem, {}, []) # unhashable
207 self.assertRaises(SystemError, getitem, [], 1)
208 self.assertRaises(SystemError, getitem, [], 'a')
209 # CRASHES getitem({}, NULL)
210 # CRASHES getitem(NULL, 'a')
211
212 def test_dict_contains(self):
213 contains = _testlimitedcapi.dict_contains
214 dct = {'a': 1, '\U0001f40d': 2}
215 self.assertTrue(contains(dct, 'a'))
216 self.assertFalse(contains(dct, 'b'))
217 self.assertTrue(contains(dct, '\U0001f40d'))
218
219 dct2 = DictSubclass(dct)
220 self.assertTrue(contains(dct2, 'a'))
221 self.assertFalse(contains(dct2, 'b'))
222
223 self.assertRaises(TypeError, contains, {}, []) # unhashable
224 # CRASHES contains({}, NULL)
225 # CRASHES contains(UserDict(), 'a')
226 # CRASHES contains(42, 'a')
227 # CRASHES contains(NULL, 'a')
228
229 def test_dict_contains_string(self):
230 contains_string = _testcapi.dict_containsstring
231 dct = {'a': 1, '\U0001f40d': 2}
232 self.assertTrue(contains_string(dct, b'a'))
233 self.assertFalse(contains_string(dct, b'b'))
234 self.assertTrue(contains_string(dct, '\U0001f40d'.encode()))
235 self.assertRaises(UnicodeDecodeError, contains_string, dct, INVALID_UTF8)
236
237 dct2 = DictSubclass(dct)
238 self.assertTrue(contains_string(dct2, b'a'))
239 self.assertFalse(contains_string(dct2, b'b'))
240
241 # CRASHES contains({}, NULL)
242 # CRASHES contains(NULL, b'a')
243
244 def test_dict_setitem(self):
245 setitem = _testlimitedcapi.dict_setitem
246 dct = {}
247 setitem(dct, 'a', 5)
248 self.assertEqual(dct, {'a': 5})
249 setitem(dct, '\U0001f40d', 8)
250 self.assertEqual(dct, {'a': 5, '\U0001f40d': 8})
251
252 dct2 = DictSubclass()
253 setitem(dct2, 'a', 5)
254 self.assertEqual(dct2, {'a': 5})
255
256 self.assertRaises(TypeError, setitem, {}, [], 5) # unhashable
257 self.assertRaises(SystemError, setitem, UserDict(), 'a', 5)
258 self.assertRaises(SystemError, setitem, [1], 0, 5)
259 self.assertRaises(SystemError, setitem, 42, 'a', 5)
260 # CRASHES setitem({}, NULL, 5)
261 # CRASHES setitem({}, 'a', NULL)
262 # CRASHES setitem(NULL, 'a', 5)
263
264 def test_dict_setitemstring(self):
265 setitemstring = _testlimitedcapi.dict_setitemstring
266 dct = {}
267 setitemstring(dct, b'a', 5)
268 self.assertEqual(dct, {'a': 5})
269 setitemstring(dct, '\U0001f40d'.encode(), 8)
270 self.assertEqual(dct, {'a': 5, '\U0001f40d': 8})
271
272 dct2 = DictSubclass()
273 setitemstring(dct2, b'a', 5)
274 self.assertEqual(dct2, {'a': 5})
275
276 self.assertRaises(UnicodeDecodeError, setitemstring, {}, INVALID_UTF8, 5)
277 self.assertRaises(SystemError, setitemstring, UserDict(), b'a', 5)
278 self.assertRaises(SystemError, setitemstring, 42, b'a', 5)
279 # CRASHES setitemstring({}, NULL, 5)
280 # CRASHES setitemstring({}, b'a', NULL)
281 # CRASHES setitemstring(NULL, b'a', 5)
282
283 def test_dict_delitem(self):
284 delitem = _testlimitedcapi.dict_delitem
285 dct = {'a': 1, 'c': 2, '\U0001f40d': 3}
286 delitem(dct, 'a')
287 self.assertEqual(dct, {'c': 2, '\U0001f40d': 3})
288 self.assertRaises(KeyError, delitem, dct, 'b')
289 delitem(dct, '\U0001f40d')
290 self.assertEqual(dct, {'c': 2})
291
292 dct2 = DictSubclass({'a': 1, 'c': 2})
293 delitem(dct2, 'a')
294 self.assertEqual(dct2, {'c': 2})
295 self.assertRaises(KeyError, delitem, dct2, 'b')
296
297 self.assertRaises(TypeError, delitem, {}, []) # unhashable
298 self.assertRaises(SystemError, delitem, UserDict({'a': 1}), 'a')
299 self.assertRaises(SystemError, delitem, [1], 0)
300 self.assertRaises(SystemError, delitem, 42, 'a')
301 # CRASHES delitem({}, NULL)
302 # CRASHES delitem(NULL, 'a')
303
304 def test_dict_delitemstring(self):
305 delitemstring = _testlimitedcapi.dict_delitemstring
306 dct = {'a': 1, 'c': 2, '\U0001f40d': 3}
307 delitemstring(dct, b'a')
308 self.assertEqual(dct, {'c': 2, '\U0001f40d': 3})
309 self.assertRaises(KeyError, delitemstring, dct, b'b')
310 delitemstring(dct, '\U0001f40d'.encode())
311 self.assertEqual(dct, {'c': 2})
312
313 dct2 = DictSubclass({'a': 1, 'c': 2})
314 delitemstring(dct2, b'a')
315 self.assertEqual(dct2, {'c': 2})
316 self.assertRaises(KeyError, delitemstring, dct2, b'b')
317
318 self.assertRaises(UnicodeDecodeError, delitemstring, {}, INVALID_UTF8)
319 self.assertRaises(SystemError, delitemstring, UserDict({'a': 1}), b'a')
320 self.assertRaises(SystemError, delitemstring, 42, b'a')
321 # CRASHES delitemstring({}, NULL)
322 # CRASHES delitemstring(NULL, b'a')
323
324 def test_dict_setdefault(self):
325 setdefault = _testcapi.dict_setdefault
326 dct = {}
327 self.assertEqual(setdefault(dct, 'a', 5), 5)
328 self.assertEqual(dct, {'a': 5})
329 self.assertEqual(setdefault(dct, 'a', 8), 5)
330 self.assertEqual(dct, {'a': 5})
331
332 dct2 = DictSubclass()
333 self.assertEqual(setdefault(dct2, 'a', 5), 5)
334 self.assertEqual(dct2, {'a': 5})
335 self.assertEqual(setdefault(dct2, 'a', 8), 5)
336 self.assertEqual(dct2, {'a': 5})
337
338 self.assertRaises(TypeError, setdefault, {}, [], 5) # unhashable
339 self.assertRaises(SystemError, setdefault, UserDict(), 'a', 5)
340 self.assertRaises(SystemError, setdefault, [1], 0, 5)
341 self.assertRaises(SystemError, setdefault, 42, 'a', 5)
342 # CRASHES setdefault({}, NULL, 5)
343 # CRASHES setdefault({}, 'a', NULL)
344 # CRASHES setdefault(NULL, 'a', 5)
345
346 def test_dict_setdefaultref(self):
347 setdefault = _testcapi.dict_setdefaultref
348 dct = {}
349 self.assertEqual(setdefault(dct, 'a', 5), 5)
350 self.assertEqual(dct, {'a': 5})
351 self.assertEqual(setdefault(dct, 'a', 8), 5)
352 self.assertEqual(dct, {'a': 5})
353
354 dct2 = DictSubclass()
355 self.assertEqual(setdefault(dct2, 'a', 5), 5)
356 self.assertEqual(dct2, {'a': 5})
357 self.assertEqual(setdefault(dct2, 'a', 8), 5)
358 self.assertEqual(dct2, {'a': 5})
359
360 self.assertRaises(TypeError, setdefault, {}, [], 5) # unhashable
361 self.assertRaises(SystemError, setdefault, UserDict(), 'a', 5)
362 self.assertRaises(SystemError, setdefault, [1], 0, 5)
363 self.assertRaises(SystemError, setdefault, 42, 'a', 5)
364 # CRASHES setdefault({}, NULL, 5)
365 # CRASHES setdefault({}, 'a', NULL)
366 # CRASHES setdefault(NULL, 'a', 5)
367
368 def test_mapping_keys_valuesitems(self):
369 class BadMapping(dict):
370 def keys(self):
371 return None
372 def values(self):
373 return None
374 def items(self):
375 return None
376 dict_obj = {'foo': 1, 'bar': 2, 'spam': 3}
377 for mapping in [dict_obj, DictSubclass(dict_obj), BadMapping(dict_obj)]:
378 self.assertListEqual(_testlimitedcapi.dict_keys(mapping),
379 list(dict_obj.keys()))
380 self.assertListEqual(_testlimitedcapi.dict_values(mapping),
381 list(dict_obj.values()))
382 self.assertListEqual(_testlimitedcapi.dict_items(mapping),
383 list(dict_obj.items()))
384
385 def test_dict_keys_valuesitems_bad_arg(self):
386 for mapping in UserDict(), [], object():
387 self.assertRaises(SystemError, _testlimitedcapi.dict_keys, mapping)
388 self.assertRaises(SystemError, _testlimitedcapi.dict_values, mapping)
389 self.assertRaises(SystemError, _testlimitedcapi.dict_items, mapping)
390
391 def test_dict_next(self):
392 dict_next = _testlimitedcapi.dict_next
393 self.assertIsNone(dict_next({}, 0))
394 dct = {'a': 1, 'b': 2, 'c': 3}
395 pos = 0
396 pairs = []
397 while True:
398 res = dict_next(dct, pos)
399 if res is None:
400 break
401 rc, pos, key, value = res
402 self.assertEqual(rc, 1)
403 pairs.append((key, value))
404 self.assertEqual(pairs, list(dct.items()))
405
406 # CRASHES dict_next(NULL, 0)
407
408 def test_dict_update(self):
409 update = _testlimitedcapi.dict_update
410 for cls1 in dict, DictSubclass:
411 for cls2 in dict, DictSubclass, UserDict:
412 dct = cls1({'a': 1, 'b': 2})
413 update(dct, cls2({'b': 3, 'c': 4}))
414 self.assertEqual(dct, {'a': 1, 'b': 3, 'c': 4})
415
416 self.assertRaises(AttributeError, update, {}, [])
417 self.assertRaises(AttributeError, update, {}, 42)
418 self.assertRaises(SystemError, update, UserDict(), {})
419 self.assertRaises(SystemError, update, 42, {})
420 self.assertRaises(SystemError, update, {}, NULL)
421 self.assertRaises(SystemError, update, NULL, {})
422
423 def test_dict_merge(self):
424 merge = _testlimitedcapi.dict_merge
425 for cls1 in dict, DictSubclass:
426 for cls2 in dict, DictSubclass, UserDict:
427 dct = cls1({'a': 1, 'b': 2})
428 merge(dct, cls2({'b': 3, 'c': 4}), 0)
429 self.assertEqual(dct, {'a': 1, 'b': 2, 'c': 4})
430 dct = cls1({'a': 1, 'b': 2})
431 merge(dct, cls2({'b': 3, 'c': 4}), 1)
432 self.assertEqual(dct, {'a': 1, 'b': 3, 'c': 4})
433
434 self.assertRaises(AttributeError, merge, {}, [], 0)
435 self.assertRaises(AttributeError, merge, {}, 42, 0)
436 self.assertRaises(SystemError, merge, UserDict(), {}, 0)
437 self.assertRaises(SystemError, merge, 42, {}, 0)
438 self.assertRaises(SystemError, merge, {}, NULL, 0)
439 self.assertRaises(SystemError, merge, NULL, {}, 0)
440
441 def test_dict_mergefromseq2(self):
442 mergefromseq2 = _testlimitedcapi.dict_mergefromseq2
443 for cls1 in dict, DictSubclass:
444 for cls2 in list, iter:
445 dct = cls1({'a': 1, 'b': 2})
446 mergefromseq2(dct, cls2([('b', 3), ('c', 4)]), 0)
447 self.assertEqual(dct, {'a': 1, 'b': 2, 'c': 4})
448 dct = cls1({'a': 1, 'b': 2})
449 mergefromseq2(dct, cls2([('b', 3), ('c', 4)]), 1)
450 self.assertEqual(dct, {'a': 1, 'b': 3, 'c': 4})
451
452 self.assertRaises(ValueError, mergefromseq2, {}, [(1,)], 0)
453 self.assertRaises(ValueError, mergefromseq2, {}, [(1, 2, 3)], 0)
454 self.assertRaises(TypeError, mergefromseq2, {}, [1], 0)
455 self.assertRaises(TypeError, mergefromseq2, {}, 42, 0)
456 # CRASHES mergefromseq2(UserDict(), [], 0)
457 # CRASHES mergefromseq2(42, [], 0)
458 # CRASHES mergefromseq2({}, NULL, 0)
459 # CRASHES mergefromseq2(NULL, {}, 0)
460
461 def test_dict_pop(self):
462 # Test PyDict_Pop()
463 dict_pop = _testcapi.dict_pop
464 dict_pop_null = _testcapi.dict_pop_null
465
466 # key present, get removed value
467 mydict = {"key": "value", "key2": "value2"}
468 self.assertEqual(dict_pop(mydict, "key"), (1, "value"))
469 self.assertEqual(mydict, {"key2": "value2"})
470 self.assertEqual(dict_pop(mydict, "key2"), (1, "value2"))
471 self.assertEqual(mydict, {})
472
473 # key present, ignore removed value
474 mydict = {"key": "value", "key2": "value2"}
475 self.assertEqual(dict_pop_null(mydict, "key"), 1)
476 self.assertEqual(mydict, {"key2": "value2"})
477 self.assertEqual(dict_pop_null(mydict, "key2"), 1)
478 self.assertEqual(mydict, {})
479
480 # key missing, expect removed value; empty dict has a fast path
481 self.assertEqual(dict_pop({}, "key"), (0, NULL))
482 self.assertEqual(dict_pop({"a": 1}, "key"), (0, NULL))
483
484 # key missing, ignored removed value; empty dict has a fast path
485 self.assertEqual(dict_pop_null({}, "key"), 0)
486 self.assertEqual(dict_pop_null({"a": 1}, "key"), 0)
487
488 # dict error
489 not_dict = UserDict({1: 2})
490 self.assertRaises(SystemError, dict_pop, not_dict, "key")
491 self.assertRaises(SystemError, dict_pop_null, not_dict, "key")
492
493 # key error; don't hash key if dict is empty
494 not_hashable_key = ["list"]
495 self.assertEqual(dict_pop({}, not_hashable_key), (0, NULL))
496 with self.assertRaises(TypeError):
497 dict_pop({'key': 1}, not_hashable_key)
498 dict_pop({}, NULL) # key is not checked if dict is empty
499
500 # CRASHES dict_pop(NULL, "key")
501 # CRASHES dict_pop({"a": 1}, NULL)
502
503 def test_dict_popstring(self):
504 # Test PyDict_PopString()
505 dict_popstring = _testcapi.dict_popstring
506 dict_popstring_null = _testcapi.dict_popstring_null
507
508 # key present, get removed value
509 mydict = {"key": "value", "key2": "value2"}
510 self.assertEqual(dict_popstring(mydict, "key"), (1, "value"))
511 self.assertEqual(mydict, {"key2": "value2"})
512 self.assertEqual(dict_popstring(mydict, "key2"), (1, "value2"))
513 self.assertEqual(mydict, {})
514
515 # key present, ignore removed value
516 mydict = {"key": "value", "key2": "value2"}
517 self.assertEqual(dict_popstring_null(mydict, "key"), 1)
518 self.assertEqual(mydict, {"key2": "value2"})
519 self.assertEqual(dict_popstring_null(mydict, "key2"), 1)
520 self.assertEqual(mydict, {})
521
522 # key missing; empty dict has a fast path
523 self.assertEqual(dict_popstring({}, "key"), (0, NULL))
524 self.assertEqual(dict_popstring_null({}, "key"), 0)
525 self.assertEqual(dict_popstring({"a": 1}, "key"), (0, NULL))
526 self.assertEqual(dict_popstring_null({"a": 1}, "key"), 0)
527
528 # non-ASCII key
529 non_ascii = '\U0001f40d'
530 dct = {'\U0001f40d': 123}
531 self.assertEqual(dict_popstring(dct, '\U0001f40d'.encode()), (1, 123))
532 dct = {'\U0001f40d': 123}
533 self.assertEqual(dict_popstring_null(dct, '\U0001f40d'.encode()), 1)
534
535 # dict error
536 not_dict = UserDict({1: 2})
537 self.assertRaises(SystemError, dict_popstring, not_dict, "key")
538 self.assertRaises(SystemError, dict_popstring_null, not_dict, "key")
539
540 # key error
541 self.assertRaises(UnicodeDecodeError, dict_popstring, {1: 2}, INVALID_UTF8)
542 self.assertRaises(UnicodeDecodeError, dict_popstring_null, {1: 2}, INVALID_UTF8)
543
544 # CRASHES dict_popstring(NULL, "key")
545 # CRASHES dict_popstring({}, NULL)
546 # CRASHES dict_popstring({"a": 1}, NULL)
547
548
549 if __name__ == "__main__":
550 unittest.main()