python (3.12.0)
1 # tests common to dict and UserDict
2 import unittest
3 import collections
4 import sys
5 from test.support import C_RECURSION_LIMIT
6
7
8 class ESC[4;38;5;81mBasicTestMappingProtocol(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
9 # This base class can be used to check that an object conforms to the
10 # mapping protocol
11
12 # Functions that can be useful to override to adapt to dictionary
13 # semantics
14 type2test = None # which class is being tested (overwrite in subclasses)
15
16 def _reference(self):
17 """Return a dictionary of values which are invariant by storage
18 in the object under test."""
19 return {"1": "2", "key1":"value1", "key2":(1,2,3)}
20 def _empty_mapping(self):
21 """Return an empty mapping object"""
22 return self.type2test()
23 def _full_mapping(self, data):
24 """Return a mapping object with the value contained in data
25 dictionary"""
26 x = self._empty_mapping()
27 for key, value in data.items():
28 x[key] = value
29 return x
30
31 def __init__(self, *args, **kw):
32 unittest.TestCase.__init__(self, *args, **kw)
33 self.reference = self._reference().copy()
34
35 # A (key, value) pair not in the mapping
36 key, value = self.reference.popitem()
37 self.other = {key:value}
38
39 # A (key, value) pair in the mapping
40 key, value = self.reference.popitem()
41 self.inmapping = {key:value}
42 self.reference[key] = value
43
44 def test_read(self):
45 # Test for read only operations on mapping
46 p = self._empty_mapping()
47 p1 = dict(p) #workaround for singleton objects
48 d = self._full_mapping(self.reference)
49 if d is p:
50 p = p1
51 #Indexing
52 for key, value in self.reference.items():
53 self.assertEqual(d[key], value)
54 knownkey = list(self.other.keys())[0]
55 self.assertRaises(KeyError, lambda:d[knownkey])
56 #len
57 self.assertEqual(len(p), 0)
58 self.assertEqual(len(d), len(self.reference))
59 #__contains__
60 for k in self.reference:
61 self.assertIn(k, d)
62 for k in self.other:
63 self.assertNotIn(k, d)
64 #cmp
65 self.assertEqual(p, p)
66 self.assertEqual(d, d)
67 self.assertNotEqual(p, d)
68 self.assertNotEqual(d, p)
69 #bool
70 if p: self.fail("Empty mapping must compare to False")
71 if not d: self.fail("Full mapping must compare to True")
72 # keys(), items(), iterkeys() ...
73 def check_iterandlist(iter, lst, ref):
74 self.assertTrue(hasattr(iter, '__next__'))
75 self.assertTrue(hasattr(iter, '__iter__'))
76 x = list(iter)
77 self.assertTrue(set(x)==set(lst)==set(ref))
78 check_iterandlist(iter(d.keys()), list(d.keys()),
79 self.reference.keys())
80 check_iterandlist(iter(d), list(d.keys()), self.reference.keys())
81 check_iterandlist(iter(d.values()), list(d.values()),
82 self.reference.values())
83 check_iterandlist(iter(d.items()), list(d.items()),
84 self.reference.items())
85 #get
86 key, value = next(iter(d.items()))
87 knownkey, knownvalue = next(iter(self.other.items()))
88 self.assertEqual(d.get(key, knownvalue), value)
89 self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
90 self.assertNotIn(knownkey, d)
91
92 def test_write(self):
93 # Test for write operations on mapping
94 p = self._empty_mapping()
95 #Indexing
96 for key, value in self.reference.items():
97 p[key] = value
98 self.assertEqual(p[key], value)
99 for key in self.reference.keys():
100 del p[key]
101 self.assertRaises(KeyError, lambda:p[key])
102 p = self._empty_mapping()
103 #update
104 p.update(self.reference)
105 self.assertEqual(dict(p), self.reference)
106 items = list(p.items())
107 p = self._empty_mapping()
108 p.update(items)
109 self.assertEqual(dict(p), self.reference)
110 d = self._full_mapping(self.reference)
111 #setdefault
112 key, value = next(iter(d.items()))
113 knownkey, knownvalue = next(iter(self.other.items()))
114 self.assertEqual(d.setdefault(key, knownvalue), value)
115 self.assertEqual(d[key], value)
116 self.assertEqual(d.setdefault(knownkey, knownvalue), knownvalue)
117 self.assertEqual(d[knownkey], knownvalue)
118 #pop
119 self.assertEqual(d.pop(knownkey), knownvalue)
120 self.assertNotIn(knownkey, d)
121 self.assertRaises(KeyError, d.pop, knownkey)
122 default = 909
123 d[knownkey] = knownvalue
124 self.assertEqual(d.pop(knownkey, default), knownvalue)
125 self.assertNotIn(knownkey, d)
126 self.assertEqual(d.pop(knownkey, default), default)
127 #popitem
128 key, value = d.popitem()
129 self.assertNotIn(key, d)
130 self.assertEqual(value, self.reference[key])
131 p=self._empty_mapping()
132 self.assertRaises(KeyError, p.popitem)
133
134 def test_constructor(self):
135 self.assertEqual(self._empty_mapping(), self._empty_mapping())
136
137 def test_bool(self):
138 self.assertTrue(not self._empty_mapping())
139 self.assertTrue(self.reference)
140 self.assertTrue(bool(self._empty_mapping()) is False)
141 self.assertTrue(bool(self.reference) is True)
142
143 def test_keys(self):
144 d = self._empty_mapping()
145 self.assertEqual(list(d.keys()), [])
146 d = self.reference
147 self.assertIn(list(self.inmapping.keys())[0], d.keys())
148 self.assertNotIn(list(self.other.keys())[0], d.keys())
149 self.assertRaises(TypeError, d.keys, None)
150
151 def test_values(self):
152 d = self._empty_mapping()
153 self.assertEqual(list(d.values()), [])
154
155 self.assertRaises(TypeError, d.values, None)
156
157 def test_items(self):
158 d = self._empty_mapping()
159 self.assertEqual(list(d.items()), [])
160
161 self.assertRaises(TypeError, d.items, None)
162
163 def test_len(self):
164 d = self._empty_mapping()
165 self.assertEqual(len(d), 0)
166
167 def test_getitem(self):
168 d = self.reference
169 self.assertEqual(d[list(self.inmapping.keys())[0]],
170 list(self.inmapping.values())[0])
171
172 self.assertRaises(TypeError, d.__getitem__)
173
174 def test_update(self):
175 # mapping argument
176 d = self._empty_mapping()
177 d.update(self.other)
178 self.assertEqual(list(d.items()), list(self.other.items()))
179
180 # No argument
181 d = self._empty_mapping()
182 d.update()
183 self.assertEqual(d, self._empty_mapping())
184
185 # item sequence
186 d = self._empty_mapping()
187 d.update(self.other.items())
188 self.assertEqual(list(d.items()), list(self.other.items()))
189
190 # Iterator
191 d = self._empty_mapping()
192 d.update(self.other.items())
193 self.assertEqual(list(d.items()), list(self.other.items()))
194
195 # FIXME: Doesn't work with UserDict
196 # self.assertRaises((TypeError, AttributeError), d.update, None)
197 self.assertRaises((TypeError, AttributeError), d.update, 42)
198
199 outerself = self
200 class ESC[4;38;5;81mSimpleUserDict:
201 def __init__(self):
202 self.d = outerself.reference
203 def keys(self):
204 return self.d.keys()
205 def __getitem__(self, i):
206 return self.d[i]
207 d.clear()
208 d.update(SimpleUserDict())
209 i1 = sorted(d.items())
210 i2 = sorted(self.reference.items())
211 self.assertEqual(i1, i2)
212
213 class ESC[4;38;5;81mExc(ESC[4;38;5;149mException): pass
214
215 d = self._empty_mapping()
216 class ESC[4;38;5;81mFailingUserDict:
217 def keys(self):
218 raise Exc
219 self.assertRaises(Exc, d.update, FailingUserDict())
220
221 d.clear()
222
223 class ESC[4;38;5;81mFailingUserDict:
224 def keys(self):
225 class ESC[4;38;5;81mBogonIter:
226 def __init__(self):
227 self.i = 1
228 def __iter__(self):
229 return self
230 def __next__(self):
231 if self.i:
232 self.i = 0
233 return 'a'
234 raise Exc
235 return BogonIter()
236 def __getitem__(self, key):
237 return key
238 self.assertRaises(Exc, d.update, FailingUserDict())
239
240 class ESC[4;38;5;81mFailingUserDict:
241 def keys(self):
242 class ESC[4;38;5;81mBogonIter:
243 def __init__(self):
244 self.i = ord('a')
245 def __iter__(self):
246 return self
247 def __next__(self):
248 if self.i <= ord('z'):
249 rtn = chr(self.i)
250 self.i += 1
251 return rtn
252 raise StopIteration
253 return BogonIter()
254 def __getitem__(self, key):
255 raise Exc
256 self.assertRaises(Exc, d.update, FailingUserDict())
257
258 d = self._empty_mapping()
259 class ESC[4;38;5;81mbadseq(ESC[4;38;5;149mobject):
260 def __iter__(self):
261 return self
262 def __next__(self):
263 raise Exc()
264
265 self.assertRaises(Exc, d.update, badseq())
266
267 self.assertRaises(ValueError, d.update, [(1, 2, 3)])
268
269 # no test_fromkeys or test_copy as both os.environ and selves don't support it
270
271 def test_get(self):
272 d = self._empty_mapping()
273 self.assertTrue(d.get(list(self.other.keys())[0]) is None)
274 self.assertEqual(d.get(list(self.other.keys())[0], 3), 3)
275 d = self.reference
276 self.assertTrue(d.get(list(self.other.keys())[0]) is None)
277 self.assertEqual(d.get(list(self.other.keys())[0], 3), 3)
278 self.assertEqual(d.get(list(self.inmapping.keys())[0]),
279 list(self.inmapping.values())[0])
280 self.assertEqual(d.get(list(self.inmapping.keys())[0], 3),
281 list(self.inmapping.values())[0])
282 self.assertRaises(TypeError, d.get)
283 self.assertRaises(TypeError, d.get, None, None, None)
284
285 def test_setdefault(self):
286 d = self._empty_mapping()
287 self.assertRaises(TypeError, d.setdefault)
288
289 def test_popitem(self):
290 d = self._empty_mapping()
291 self.assertRaises(KeyError, d.popitem)
292 self.assertRaises(TypeError, d.popitem, 42)
293
294 def test_pop(self):
295 d = self._empty_mapping()
296 k, v = list(self.inmapping.items())[0]
297 d[k] = v
298 self.assertRaises(KeyError, d.pop, list(self.other.keys())[0])
299
300 self.assertEqual(d.pop(k), v)
301 self.assertEqual(len(d), 0)
302
303 self.assertRaises(KeyError, d.pop, k)
304
305
306 class ESC[4;38;5;81mTestMappingProtocol(ESC[4;38;5;149mBasicTestMappingProtocol):
307 def test_constructor(self):
308 BasicTestMappingProtocol.test_constructor(self)
309 self.assertTrue(self._empty_mapping() is not self._empty_mapping())
310 self.assertEqual(self.type2test(x=1, y=2), {"x": 1, "y": 2})
311
312 def test_bool(self):
313 BasicTestMappingProtocol.test_bool(self)
314 self.assertTrue(not self._empty_mapping())
315 self.assertTrue(self._full_mapping({"x": "y"}))
316 self.assertTrue(bool(self._empty_mapping()) is False)
317 self.assertTrue(bool(self._full_mapping({"x": "y"})) is True)
318
319 def test_keys(self):
320 BasicTestMappingProtocol.test_keys(self)
321 d = self._empty_mapping()
322 self.assertEqual(list(d.keys()), [])
323 d = self._full_mapping({'a': 1, 'b': 2})
324 k = d.keys()
325 self.assertIn('a', k)
326 self.assertIn('b', k)
327 self.assertNotIn('c', k)
328
329 def test_values(self):
330 BasicTestMappingProtocol.test_values(self)
331 d = self._full_mapping({1:2})
332 self.assertEqual(list(d.values()), [2])
333
334 def test_items(self):
335 BasicTestMappingProtocol.test_items(self)
336
337 d = self._full_mapping({1:2})
338 self.assertEqual(list(d.items()), [(1, 2)])
339
340 def test_contains(self):
341 d = self._empty_mapping()
342 self.assertNotIn('a', d)
343 self.assertTrue(not ('a' in d))
344 self.assertTrue('a' not in d)
345 d = self._full_mapping({'a': 1, 'b': 2})
346 self.assertIn('a', d)
347 self.assertIn('b', d)
348 self.assertNotIn('c', d)
349
350 self.assertRaises(TypeError, d.__contains__)
351
352 def test_len(self):
353 BasicTestMappingProtocol.test_len(self)
354 d = self._full_mapping({'a': 1, 'b': 2})
355 self.assertEqual(len(d), 2)
356
357 def test_getitem(self):
358 BasicTestMappingProtocol.test_getitem(self)
359 d = self._full_mapping({'a': 1, 'b': 2})
360 self.assertEqual(d['a'], 1)
361 self.assertEqual(d['b'], 2)
362 d['c'] = 3
363 d['a'] = 4
364 self.assertEqual(d['c'], 3)
365 self.assertEqual(d['a'], 4)
366 del d['b']
367 self.assertEqual(d, {'a': 4, 'c': 3})
368
369 self.assertRaises(TypeError, d.__getitem__)
370
371 def test_clear(self):
372 d = self._full_mapping({1:1, 2:2, 3:3})
373 d.clear()
374 self.assertEqual(d, {})
375
376 self.assertRaises(TypeError, d.clear, None)
377
378 def test_update(self):
379 BasicTestMappingProtocol.test_update(self)
380 # mapping argument
381 d = self._empty_mapping()
382 d.update({1:100})
383 d.update({2:20})
384 d.update({1:1, 2:2, 3:3})
385 self.assertEqual(d, {1:1, 2:2, 3:3})
386
387 # no argument
388 d.update()
389 self.assertEqual(d, {1:1, 2:2, 3:3})
390
391 # keyword arguments
392 d = self._empty_mapping()
393 d.update(x=100)
394 d.update(y=20)
395 d.update(x=1, y=2, z=3)
396 self.assertEqual(d, {"x":1, "y":2, "z":3})
397
398 # item sequence
399 d = self._empty_mapping()
400 d.update([("x", 100), ("y", 20)])
401 self.assertEqual(d, {"x":100, "y":20})
402
403 # Both item sequence and keyword arguments
404 d = self._empty_mapping()
405 d.update([("x", 100), ("y", 20)], x=1, y=2)
406 self.assertEqual(d, {"x":1, "y":2})
407
408 # iterator
409 d = self._full_mapping({1:3, 2:4})
410 d.update(self._full_mapping({1:2, 3:4, 5:6}).items())
411 self.assertEqual(d, {1:2, 2:4, 3:4, 5:6})
412
413 class ESC[4;38;5;81mSimpleUserDict:
414 def __init__(self):
415 self.d = {1:1, 2:2, 3:3}
416 def keys(self):
417 return self.d.keys()
418 def __getitem__(self, i):
419 return self.d[i]
420 d.clear()
421 d.update(SimpleUserDict())
422 self.assertEqual(d, {1:1, 2:2, 3:3})
423
424 def test_fromkeys(self):
425 self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
426 d = self._empty_mapping()
427 self.assertTrue(not(d.fromkeys('abc') is d))
428 self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
429 self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0})
430 self.assertEqual(d.fromkeys([]), {})
431 def g():
432 yield 1
433 self.assertEqual(d.fromkeys(g()), {1:None})
434 self.assertRaises(TypeError, {}.fromkeys, 3)
435 class ESC[4;38;5;81mdictlike(ESC[4;38;5;149mselfESC[4;38;5;149m.ESC[4;38;5;149mtype2test): pass
436 self.assertEqual(dictlike.fromkeys('a'), {'a':None})
437 self.assertEqual(dictlike().fromkeys('a'), {'a':None})
438 self.assertTrue(dictlike.fromkeys('a').__class__ is dictlike)
439 self.assertTrue(dictlike().fromkeys('a').__class__ is dictlike)
440 self.assertTrue(type(dictlike.fromkeys('a')) is dictlike)
441 class ESC[4;38;5;81mmydict(ESC[4;38;5;149mselfESC[4;38;5;149m.ESC[4;38;5;149mtype2test):
442 def __new__(cls):
443 return collections.UserDict()
444 ud = mydict.fromkeys('ab')
445 self.assertEqual(ud, {'a':None, 'b':None})
446 self.assertIsInstance(ud, collections.UserDict)
447 self.assertRaises(TypeError, dict.fromkeys)
448
449 class ESC[4;38;5;81mExc(ESC[4;38;5;149mException): pass
450
451 class ESC[4;38;5;81mbaddict1(ESC[4;38;5;149mselfESC[4;38;5;149m.ESC[4;38;5;149mtype2test):
452 def __init__(self, *args, **kwargs):
453 raise Exc()
454
455 self.assertRaises(Exc, baddict1.fromkeys, [1])
456
457 class ESC[4;38;5;81mBadSeq(ESC[4;38;5;149mobject):
458 def __iter__(self):
459 return self
460 def __next__(self):
461 raise Exc()
462
463 self.assertRaises(Exc, self.type2test.fromkeys, BadSeq())
464
465 class ESC[4;38;5;81mbaddict2(ESC[4;38;5;149mselfESC[4;38;5;149m.ESC[4;38;5;149mtype2test):
466 def __setitem__(self, key, value):
467 raise Exc()
468
469 self.assertRaises(Exc, baddict2.fromkeys, [1])
470
471 def test_copy(self):
472 d = self._full_mapping({1:1, 2:2, 3:3})
473 self.assertEqual(d.copy(), {1:1, 2:2, 3:3})
474 d = self._empty_mapping()
475 self.assertEqual(d.copy(), d)
476 self.assertIsInstance(d.copy(), d.__class__)
477 self.assertRaises(TypeError, d.copy, None)
478
479 def test_get(self):
480 BasicTestMappingProtocol.test_get(self)
481 d = self._empty_mapping()
482 self.assertTrue(d.get('c') is None)
483 self.assertEqual(d.get('c', 3), 3)
484 d = self._full_mapping({'a' : 1, 'b' : 2})
485 self.assertTrue(d.get('c') is None)
486 self.assertEqual(d.get('c', 3), 3)
487 self.assertEqual(d.get('a'), 1)
488 self.assertEqual(d.get('a', 3), 1)
489
490 def test_setdefault(self):
491 BasicTestMappingProtocol.test_setdefault(self)
492 d = self._empty_mapping()
493 self.assertTrue(d.setdefault('key0') is None)
494 d.setdefault('key0', [])
495 self.assertTrue(d.setdefault('key0') is None)
496 d.setdefault('key', []).append(3)
497 self.assertEqual(d['key'][0], 3)
498 d.setdefault('key', []).append(4)
499 self.assertEqual(len(d['key']), 2)
500
501 def test_popitem(self):
502 BasicTestMappingProtocol.test_popitem(self)
503 for copymode in -1, +1:
504 # -1: b has same structure as a
505 # +1: b is a.copy()
506 for log2size in range(12):
507 size = 2**log2size
508 a = self._empty_mapping()
509 b = self._empty_mapping()
510 for i in range(size):
511 a[repr(i)] = i
512 if copymode < 0:
513 b[repr(i)] = i
514 if copymode > 0:
515 b = a.copy()
516 for i in range(size):
517 ka, va = ta = a.popitem()
518 self.assertEqual(va, int(ka))
519 kb, vb = tb = b.popitem()
520 self.assertEqual(vb, int(kb))
521 self.assertTrue(not(copymode < 0 and ta != tb))
522 self.assertTrue(not a)
523 self.assertTrue(not b)
524
525 def test_pop(self):
526 BasicTestMappingProtocol.test_pop(self)
527
528 # Tests for pop with specified key
529 d = self._empty_mapping()
530 k, v = 'abc', 'def'
531
532 self.assertEqual(d.pop(k, v), v)
533 d[k] = v
534 self.assertEqual(d.pop(k, 1), v)
535
536
537 class ESC[4;38;5;81mTestHashMappingProtocol(ESC[4;38;5;149mTestMappingProtocol):
538
539 def test_getitem(self):
540 TestMappingProtocol.test_getitem(self)
541 class ESC[4;38;5;81mExc(ESC[4;38;5;149mException): pass
542
543 class ESC[4;38;5;81mBadEq(ESC[4;38;5;149mobject):
544 def __eq__(self, other):
545 raise Exc()
546 def __hash__(self):
547 return 24
548
549 d = self._empty_mapping()
550 d[BadEq()] = 42
551 self.assertRaises(KeyError, d.__getitem__, 23)
552
553 class ESC[4;38;5;81mBadHash(ESC[4;38;5;149mobject):
554 fail = False
555 def __hash__(self):
556 if self.fail:
557 raise Exc()
558 else:
559 return 42
560
561 d = self._empty_mapping()
562 x = BadHash()
563 d[x] = 42
564 x.fail = True
565 self.assertRaises(Exc, d.__getitem__, x)
566
567 def test_fromkeys(self):
568 TestMappingProtocol.test_fromkeys(self)
569 class ESC[4;38;5;81mmydict(ESC[4;38;5;149mselfESC[4;38;5;149m.ESC[4;38;5;149mtype2test):
570 def __new__(cls):
571 return collections.UserDict()
572 ud = mydict.fromkeys('ab')
573 self.assertEqual(ud, {'a':None, 'b':None})
574 self.assertIsInstance(ud, collections.UserDict)
575
576 def test_pop(self):
577 TestMappingProtocol.test_pop(self)
578
579 class ESC[4;38;5;81mExc(ESC[4;38;5;149mException): pass
580
581 class ESC[4;38;5;81mBadHash(ESC[4;38;5;149mobject):
582 fail = False
583 def __hash__(self):
584 if self.fail:
585 raise Exc()
586 else:
587 return 42
588
589 d = self._empty_mapping()
590 x = BadHash()
591 d[x] = 42
592 x.fail = True
593 self.assertRaises(Exc, d.pop, x)
594
595 def test_mutatingiteration(self):
596 d = self._empty_mapping()
597 d[1] = 1
598 try:
599 count = 0
600 for i in d:
601 d[i+1] = 1
602 if count >= 1:
603 self.fail("changing dict size during iteration doesn't raise Error")
604 count += 1
605 except RuntimeError:
606 pass
607
608 def test_repr(self):
609 d = self._empty_mapping()
610 self.assertEqual(repr(d), '{}')
611 d[1] = 2
612 self.assertEqual(repr(d), '{1: 2}')
613 d = self._empty_mapping()
614 d[1] = d
615 self.assertEqual(repr(d), '{1: {...}}')
616
617 class ESC[4;38;5;81mExc(ESC[4;38;5;149mException): pass
618
619 class ESC[4;38;5;81mBadRepr(ESC[4;38;5;149mobject):
620 def __repr__(self):
621 raise Exc()
622
623 d = self._full_mapping({1: BadRepr()})
624 self.assertRaises(Exc, repr, d)
625
626 def test_repr_deep(self):
627 d = self._empty_mapping()
628 for i in range(C_RECURSION_LIMIT + 1):
629 d0 = d
630 d = self._empty_mapping()
631 d[1] = d0
632 self.assertRaises(RecursionError, repr, d)
633
634 def test_eq(self):
635 self.assertEqual(self._empty_mapping(), self._empty_mapping())
636 self.assertEqual(self._full_mapping({1: 2}),
637 self._full_mapping({1: 2}))
638
639 class ESC[4;38;5;81mExc(ESC[4;38;5;149mException): pass
640
641 class ESC[4;38;5;81mBadCmp(ESC[4;38;5;149mobject):
642 def __eq__(self, other):
643 raise Exc()
644 def __hash__(self):
645 return 1
646
647 d1 = self._full_mapping({BadCmp(): 1})
648 d2 = self._full_mapping({1: 1})
649 self.assertRaises(Exc, lambda: BadCmp()==1)
650 self.assertRaises(Exc, lambda: d1==d2)
651
652 def test_setdefault(self):
653 TestMappingProtocol.test_setdefault(self)
654
655 class ESC[4;38;5;81mExc(ESC[4;38;5;149mException): pass
656
657 class ESC[4;38;5;81mBadHash(ESC[4;38;5;149mobject):
658 fail = False
659 def __hash__(self):
660 if self.fail:
661 raise Exc()
662 else:
663 return 42
664
665 d = self._empty_mapping()
666 x = BadHash()
667 d[x] = 42
668 x.fail = True
669 self.assertRaises(Exc, d.setdefault, x, [])
Browse
Usage
Versions