Lines Matching refs:self
15 def _reference(self):
19 def _empty_mapping(self):
21 return self.type2test()
22 def _full_mapping(self, data):
25 x = self._empty_mapping()
30 def __init__(self, *args, **kw):
31 unittest.TestCase.__init__(self, *args, **kw)
32 self.reference = self._reference().copy()
35 key, value = self.reference.popitem()
36 self.other = {key:value}
39 key, value = self.reference.popitem()
40 self.inmapping = {key:value}
41 self.reference[key] = value
43 def test_read(self):
45 p = self._empty_mapping()
47 d = self._full_mapping(self.reference)
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])
56 self.assertEqual(len(p), 0)
57 self.assertEqual(len(d), len(self.reference))
59 for k in self.reference:
60 self.assertIn(k, d)
61 for k in self.other:
62 self.assertNotIn(k, d)
64 self.assertEqual(p, p)
65 self.assertEqual(d, d)
66 self.assertNotEqual(p, d)
67 self.assertNotEqual(d, p)
69 if p: self.fail("Empty mapping must compare to False")
70 if not d: self.fail("Full mapping must compare to True")
73 self.assertTrue(hasattr(iter, '__next__'))
74 self.assertTrue(hasattr(iter, '__iter__'))
76 self.assertTrue(set(x)==set(lst)==set(ref))
78 self.reference.keys())
79 check_iterandlist(iter(d), list(d.keys()), self.reference.keys())
81 self.reference.values())
83 self.reference.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)
91 def test_write(self):
93 p = self._empty_mapping()
95 for key, value in self.reference.items():
97 self.assertEqual(p[key], value)
98 for key in self.reference.keys():
100 self.assertRaises(KeyError, lambda:p[key])
101 p = self._empty_mapping()
103 p.update(self.reference)
104 self.assertEqual(dict(p), self.reference)
106 p = self._empty_mapping()
108 self.assertEqual(dict(p), self.reference)
109 d = self._full_mapping(self.reference)
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)
118 self.assertEqual(d.pop(knownkey), knownvalue)
119 self.assertNotIn(knownkey, d)
120 self.assertRaises(KeyError, d.pop, knownkey)
123 self.assertEqual(d.pop(knownkey, default), knownvalue)
124 self.assertNotIn(knownkey, d)
125 self.assertEqual(d.pop(knownkey, default), default)
128 self.assertNotIn(key, d)
129 self.assertEqual(value, self.reference[key])
130 p=self._empty_mapping()
131 self.assertRaises(KeyError, p.popitem)
133 def test_constructor(self):
134 self.assertEqual(self._empty_mapping(), self._empty_mapping())
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)
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)
150 def test_values(self):
151 d = self._empty_mapping()
152 self.assertEqual(list(d.values()), [])
154 self.assertRaises(TypeError, d.values, None)
156 def test_items(self):
157 d = self._empty_mapping()
158 self.assertEqual(list(d.items()), [])
160 self.assertRaises(TypeError, d.items, None)
162 def test_len(self):
163 d = self._empty_mapping()
164 self.assertEqual(len(d), 0)
166 def test_getitem(self):
167 d = self.reference
168 self.assertEqual(d[list(self.inmapping.keys())[0]],
169 list(self.inmapping.values())[0])
171 self.assertRaises(TypeError, d.__getitem__)
173 def test_update(self):
175 d = self._empty_mapping()
176 d.update(self.other)
177 self.assertEqual(list(d.items()), list(self.other.items()))
180 d = self._empty_mapping()
182 self.assertEqual(d, self._empty_mapping())
185 d = self._empty_mapping()
186 d.update(self.other.items())
187 self.assertEqual(list(d.items()), list(self.other.items()))
190 d = self._empty_mapping()
191 d.update(self.other.items())
192 self.assertEqual(list(d.items()), list(self.other.items()))
195 # self.assertRaises((TypeError, AttributeError), d.update, None)
196 self.assertRaises((TypeError, AttributeError), d.update, 42)
198 outerself = self
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]
209 i2 = sorted(self.reference.items())
210 self.assertEqual(i1, i2)
214 d = self._empty_mapping()
216 def keys(self):
218 self.assertRaises(Exc, d.update, FailingUserDict())
223 def keys(self):
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
235 def __getitem__(self, key):
237 self.assertRaises(Exc, d.update, FailingUserDict())
240 def keys(self):
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
253 def __getitem__(self, key):
255 self.assertRaises(Exc, d.update, FailingUserDict())
257 d = self._empty_mapping()
259 def __iter__(self):
260 return self
261 def __next__(self):
264 self.assertRaises(Exc, d.update, badseq())
266 self.assertRaises(ValueError, d.update, [(1, 2, 3)])
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)
284 def test_setdefault(self):
285 d = self._empty_mapping()
286 self.assertRaises(TypeError, d.setdefault)
288 def test_popitem(self):
289 d = self._empty_mapping()
290 self.assertRaises(KeyError, d.popitem)
291 self.assertRaises(TypeError, d.popitem, 42)
293 def test_pop(self):
294 d = self._empty_mapping()
295 k, v = list(self.inmapping.items())[0]
297 self.assertRaises(KeyError, d.pop, list(self.other.keys())[0])
299 self.assertEqual(d.pop(k), v)
300 self.assertEqual(len(d), 0)
302 self.assertRaises(KeyError, d.pop, k)
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})
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)
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})
324 self.assertIn('a', k)
325 self.assertIn('b', k)
326 self.assertNotIn('c', k)
328 def test_values(self):
329 BasicTestMappingProtocol.test_values(self)
330 d = self._full_mapping({1:2})
331 self.assertEqual(list(d.values()), [2])
333 def test_items(self):
334 BasicTestMappingProtocol.test_items(self)
336 d = self._full_mapping({1:2})
337 self.assertEqual(list(d.items()), [(1, 2)])
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)
349 self.assertRaises(TypeError, d.__contains__)
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)
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)
363 self.assertEqual(d['c'], 3)
364 self.assertEqual(d['a'], 4)
366 self.assertEqual(d, {'a': 4, 'c': 3})
368 self.assertRaises(TypeError, d.__getitem__)
370 def test_clear(self):
371 d = self._full_mapping({1:1, 2:2, 3:3})
373 self.assertEqual(d, {})
375 self.assertRaises(TypeError, d.clear, None)
377 def test_update(self):
378 BasicTestMappingProtocol.test_update(self)
380 d = self._empty_mapping()
384 self.assertEqual(d, {1:1, 2:2, 3:3})
388 self.assertEqual(d, {1:1, 2:2, 3:3})
391 d = self._empty_mapping()
395 self.assertEqual(d, {"x":1, "y":2, "z":3})
398 d = self._empty_mapping()
400 self.assertEqual(d, {"x":100, "y":20})
403 d = self._empty_mapping()
405 self.assertEqual(d, {"x":1, "y":2})
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})
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]
421 self.assertEqual(d, {1:1, 2:2, 3:3})
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([]), {})
432 self.assertEqual(d.fromkeys(g()), {1:None})
433 self.assertRaises(TypeError, {}.fromkeys, 3)
434 class dictlike(self.type2test): 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 mydict(self.type2test):
444 self.assertEqual(ud, {'a':None, 'b':None})
445 self.assertIsInstance(ud, collections.UserDict)
446 self.assertRaises(TypeError, dict.fromkeys)
450 class baddict1(self.type2test):
451 def __init__(self, *args, **kwargs):
454 self.assertRaises(Exc, baddict1.fromkeys, [1])
457 def __iter__(self):
458 return self
459 def __next__(self):
462 self.assertRaises(Exc, self.type2test.fromkeys, BadSeq())
464 class baddict2(self.type2test):
465 def __setitem__(self, key, value):
468 self.assertRaises(Exc, baddict2.fromkeys, [1])
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)
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)
489 def test_setdefault(self):
490 BasicTestMappingProtocol.test_setdefault(self)
491 d = self._empty_mapping()
492 self.assertTrue(d.setdefault('key0') is None)
494 self.assertTrue(d.setdefault('key0') is None)
496 self.assertEqual(d['key'][0], 3)
498 self.assertEqual(len(d['key']), 2)
500 def test_popitem(self):
501 BasicTestMappingProtocol.test_popitem(self)
507 a = self._empty_mapping()
508 b = self._empty_mapping()
517 self.assertEqual(va, int(ka))
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)
524 def test_pop(self):
525 BasicTestMappingProtocol.test_pop(self)
528 d = self._empty_mapping()
531 self.assertEqual(d.pop(k, v), v)
533 self.assertEqual(d.pop(k, 1), v)
538 def test_getitem(self):
539 TestMappingProtocol.test_getitem(self)
543 def __eq__(self, other):
545 def __hash__(self):
548 d = self._empty_mapping()
550 self.assertRaises(KeyError, d.__getitem__, 23)
554 def __hash__(self):
555 if self.fail:
560 d = self._empty_mapping()
564 self.assertRaises(Exc, d.__getitem__, x)
566 def test_fromkeys(self):
567 TestMappingProtocol.test_fromkeys(self)
568 class mydict(self.type2test):
572 self.assertEqual(ud, {'a':None, 'b':None})
573 self.assertIsInstance(ud, collections.UserDict)
575 def test_pop(self):
576 TestMappingProtocol.test_pop(self)
582 def __hash__(self):
583 if self.fail:
588 d = self._empty_mapping()
592 self.assertRaises(Exc, d.pop, x)
594 def test_mutatingiteration(self):
595 d = self._empty_mapping()
602 self.fail("changing dict size during iteration doesn't raise Error")
607 def test_repr(self):
608 d = self._empty_mapping()
609 self.assertEqual(repr(d), '{}')
611 self.assertEqual(repr(d), '{1: 2}')
612 d = self._empty_mapping()
614 self.assertEqual(repr(d), '{1: {...}}')
619 def __repr__(self):
622 d = self._full_mapping({1: BadRepr()})
623 self.assertRaises(Exc, repr, d)
625 def test_repr_deep(self):
626 d = self._empty_mapping()
629 d = self._empty_mapping()
631 self.assertRaises(RecursionError, repr, d)
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}))
641 def __eq__(self, other):
643 def __hash__(self):
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)
651 def test_setdefault(self):
652 TestMappingProtocol.test_setdefault(self)
658 def __hash__(self):
659 if self.fail:
664 d = self._empty_mapping()
668 self.assertRaises(Exc, d.setdefault, x, [])