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