Lines Matching refs:self
16 def test_invalid_keyword_arguments(self):
20 with self.assertRaises(TypeError):
22 with self.assertRaises(TypeError):
25 def test_constructor(self):
27 self.assertEqual(dict(), {})
28 self.assertIsNot(dict(), {})
30 def test_literal_constructor(self):
39 self.assertEqual(eval(dictliteral), dict(items))
41 def test_merge_operator(self):
49 self.assertEqual(a | b, {0: 0, 1: 1, 2: 2, 3: 3})
50 self.assertEqual(c, {0: 0, 1: 1, 2: 2, 3: 3})
55 self.assertEqual(b | a, {1: 1, 2: 1, 3: 3, 0: 0})
56 self.assertEqual(c, {1: 1, 2: 1, 3: 3, 0: 0})
61 self.assertEqual(c, {0: 0, 1: 1, 2: 2, 3: 3})
63 self.assertIs(a.__or__(None), NotImplemented)
64 self.assertIs(a.__or__(()), NotImplemented)
65 self.assertIs(a.__or__("BAD"), NotImplemented)
66 self.assertIs(a.__or__(""), NotImplemented)
68 self.assertRaises(TypeError, a.__ior__, None)
69 self.assertEqual(a.__ior__(()), {0: 0, 1: 1, 2: 1})
70 self.assertRaises(ValueError, a.__ior__, "BAD")
71 self.assertEqual(a.__ior__(""), {0: 0, 1: 1, 2: 1})
73 def test_bool(self):
74 self.assertIs(not {}, True)
75 self.assertTrue({1: 2})
76 self.assertIs(bool({}), False)
77 self.assertIs(bool({1: 2}), True)
79 def test_keys(self):
81 self.assertEqual(set(d.keys()), set())
84 self.assertEqual(set(k), {'a', 'b'})
85 self.assertIn('a', k)
86 self.assertIn('b', k)
87 self.assertIn('a', d)
88 self.assertIn('b', d)
89 self.assertRaises(TypeError, d.keys, None)
90 self.assertEqual(repr(dict(a=1).keys()), "dict_keys(['a'])")
92 def test_values(self):
94 self.assertEqual(set(d.values()), set())
96 self.assertEqual(set(d.values()), {2})
97 self.assertRaises(TypeError, d.values, None)
98 self.assertEqual(repr(dict(a=1).values()), "dict_values([1])")
100 def test_items(self):
102 self.assertEqual(set(d.items()), set())
105 self.assertEqual(set(d.items()), {(1, 2)})
106 self.assertRaises(TypeError, d.items, None)
107 self.assertEqual(repr(dict(a=1).items()), "dict_items([('a', 1)])")
109 def test_views_mapping(self):
120 self.assertIsInstance(m, mappingproxy)
121 self.assertEqual(m, d)
126 self.assertIsInstance(m, mappingproxy)
127 self.assertEqual(m, d)
129 def test_contains(self):
131 self.assertNotIn('a', d)
132 self.assertFalse('a' in d)
133 self.assertTrue('a' not in d)
135 self.assertIn('a', d)
136 self.assertIn('b', d)
137 self.assertNotIn('c', d)
139 self.assertRaises(TypeError, d.__contains__)
141 def test_len(self):
143 self.assertEqual(len(d), 0)
145 self.assertEqual(len(d), 2)
147 def test_getitem(self):
149 self.assertEqual(d['a'], 1)
150 self.assertEqual(d['b'], 2)
153 self.assertEqual(d['c'], 3)
154 self.assertEqual(d['a'], 4)
156 self.assertEqual(d, {'a': 4, 'c': 3})
158 self.assertRaises(TypeError, d.__getitem__)
161 def __eq__(self, other):
163 def __hash__(self):
168 self.assertRaises(KeyError, d.__getitem__, 23)
174 def __hash__(self):
175 if self.fail:
183 self.assertRaises(Exc, d.__getitem__, x)
185 def test_clear(self):
188 self.assertEqual(d, {})
190 self.assertRaises(TypeError, d.clear, None)
192 def test_update(self):
197 self.assertEqual(d, {1:1, 2:2, 3:3})
200 self.assertEqual(d, {1:1, 2:2, 3:3})
202 self.assertRaises((TypeError, AttributeError), d.update, None)
205 def __init__(self):
206 self.d = {1:1, 2:2, 3:3}
207 def keys(self):
208 return self.d.keys()
209 def __getitem__(self, i):
210 return self.d[i]
213 self.assertEqual(d, {1:1, 2:2, 3:3})
219 def keys(self):
221 self.assertRaises(Exc, d.update, FailingUserDict())
224 def keys(self):
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
236 def __getitem__(self, key):
238 self.assertRaises(Exc, d.update, FailingUserDict())
241 def keys(self):
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
254 def __getitem__(self, key):
256 self.assertRaises(Exc, d.update, FailingUserDict())
259 def __iter__(self):
260 return self
261 def __next__(self):
264 self.assertRaises(Exc, {}.update, badseq())
266 self.assertRaises(ValueError, {}.update, [(1, 2, 3)])
268 def test_fromkeys(self):
269 self.assertEqual(dict.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
271 self.assertIsNot(d.fromkeys('abc'), d)
272 self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
273 self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0})
274 self.assertEqual(d.fromkeys([]), {})
277 self.assertEqual(d.fromkeys(g()), {1:None})
278 self.assertRaises(TypeError, {}.fromkeys, 3)
280 self.assertEqual(dictlike.fromkeys('a'), {'a':None})
281 self.assertEqual(dictlike().fromkeys('a'), {'a':None})
282 self.assertIsInstance(dictlike.fromkeys('a'), dictlike)
283 self.assertIsInstance(dictlike().fromkeys('a'), dictlike)
288 self.assertEqual(ud, {'a':None, 'b':None})
289 self.assertIsInstance(ud, collections.UserDict)
290 self.assertRaises(TypeError, dict.fromkeys)
295 def __init__(self):
298 self.assertRaises(Exc, baddict1.fromkeys, [1])
301 def __iter__(self):
302 return self
303 def __next__(self):
306 self.assertRaises(Exc, dict.fromkeys, BadSeq())
309 def __setitem__(self, key, value):
312 self.assertRaises(Exc, baddict2.fromkeys, [1])
316 self.assertEqual(dict.fromkeys(d, 0), dict(zip(range(6), [0]*6)))
324 self.assertEqual(baddict3.fromkeys({"a", "b", "c"}), res)
326 def test_copy(self):
328 self.assertIsNot(d.copy(), d)
329 self.assertEqual(d.copy(), d)
330 self.assertEqual(d.copy(), {1: 1, 2: 2, 3: 3})
334 self.assertNotEqual(copy, d)
336 self.assertEqual({}.copy(), {})
337 self.assertRaises(TypeError, d.copy, None)
339 def test_copy_fuzz(self):
343 with self.subTest(dict_size=dict_size):
349 self.assertIsNot(d2, d)
350 self.assertEqual(d, d2)
352 self.assertNotEqual(d, d2)
353 self.assertEqual(len(d2), len(d) + 1)
355 def test_copy_maintains_tracking(self):
363 self.assertEqual(gc.is_tracked(d), gc.is_tracked(d2))
365 def test_copy_noncompact(self):
376 self.assertEqual(d2, d)
378 def test_get(self):
380 self.assertIs(d.get('c'), None)
381 self.assertEqual(d.get('c', 3), 3)
383 self.assertIs(d.get('c'), None)
384 self.assertEqual(d.get('c', 3), 3)
385 self.assertEqual(d.get('a'), 1)
386 self.assertEqual(d.get('a', 3), 1)
387 self.assertRaises(TypeError, d.get)
388 self.assertRaises(TypeError, d.get, None, None, None)
390 def test_setdefault(self):
393 self.assertIs(d.setdefault('key0'), None)
395 self.assertIs(d.setdefault('key0'), None)
397 self.assertEqual(d['key'][0], 3)
399 self.assertEqual(len(d['key']), 2)
400 self.assertRaises(TypeError, d.setdefault)
406 def __hash__(self):
407 if self.fail:
415 self.assertRaises(Exc, d.setdefault, x, [])
417 def test_setdefault_atomic(self):
420 def __init__(self):
421 self.hash_count = 0
422 self.eq_count = 0
423 def __hash__(self):
424 self.hash_count += 1
426 def __eq__(self, other):
427 self.eq_count += 1
428 return id(self) == id(other)
433 self.assertEqual(hashed1.hash_count, 1)
434 self.assertEqual(hashed2.hash_count, 1)
435 self.assertEqual(hashed1.eq_count + hashed2.eq_count, 1)
437 def test_setitem_atomic_at_resize(self):
439 def __init__(self):
440 self.hash_count = 0
441 self.eq_count = 0
442 def __hash__(self):
443 self.hash_count += 1
445 def __eq__(self, other):
446 self.eq_count += 1
447 return id(self) == id(other)
454 self.assertEqual(hashed1.hash_count, 1)
455 self.assertEqual(hashed2.hash_count, 1)
456 self.assertEqual(hashed1.eq_count + hashed2.eq_count, 1)
458 def test_popitem(self):
475 self.assertEqual(va, int(ka))
477 self.assertEqual(vb, int(kb))
478 self.assertFalse(copymode < 0 and ta != tb)
479 self.assertFalse(a)
480 self.assertFalse(b)
483 self.assertRaises(KeyError, d.popitem)
485 def test_pop(self):
490 self.assertRaises(KeyError, d.pop, 'ghi')
492 self.assertEqual(d.pop(k), v)
493 self.assertEqual(len(d), 0)
495 self.assertRaises(KeyError, d.pop, k)
497 self.assertEqual(d.pop(k, v), v)
499 self.assertEqual(d.pop(k, 1), v)
501 self.assertRaises(TypeError, d.pop)
507 def __hash__(self):
508 if self.fail:
516 self.assertRaises(Exc, d.pop, x)
518 def test_mutating_iteration(self):
522 with self.assertRaises(RuntimeError):
526 def test_mutating_iteration_delete(self):
530 with self.assertRaises(RuntimeError):
535 def test_mutating_iteration_delete_over_values(self):
539 with self.assertRaises(RuntimeError):
544 def test_mutating_iteration_delete_over_items(self):
548 with self.assertRaises(RuntimeError):
553 def test_mutating_lookup(self):
558 def __init__(self, value):
559 self.value = value
561 def __hash__(self):
565 def __eq__(self, other):
570 return self.value == other.value
577 self.assertEqual(d, {key2: 2})
579 def test_repr(self):
581 self.assertEqual(repr(d), '{}')
583 self.assertEqual(repr(d), '{1: 2}')
586 self.assertEqual(repr(d), '{1: {...}}')
591 def __repr__(self):
595 self.assertRaises(Exc, repr, d)
597 def test_repr_deep(self):
601 self.assertRaises(RecursionError, repr, d)
603 def test_eq(self):
604 self.assertEqual({}, {})
605 self.assertEqual({1: 2}, {1: 2})
610 def __eq__(self, other):
612 def __hash__(self):
618 with self.assertRaises(Exc):
621 def test_keys_contained(self):
622 self.helper_keys_contained(lambda x: x.keys())
623 self.helper_keys_contained(lambda x: x.items())
625 def helper_keys_contained(self, fn):
635 self.assertTrue(smaller < larger)
636 self.assertTrue(smaller <= larger)
637 self.assertTrue(larger > smaller)
638 self.assertTrue(larger >= smaller)
640 self.assertFalse(smaller >= larger)
641 self.assertFalse(smaller > larger)
642 self.assertFalse(larger <= smaller)
643 self.assertFalse(larger < smaller)
645 self.assertFalse(smaller < larger3)
646 self.assertFalse(smaller <= larger3)
647 self.assertFalse(larger3 > smaller)
648 self.assertFalse(larger3 >= smaller)
651 self.assertTrue(larger2 >= larger)
652 self.assertTrue(larger2 <= larger)
653 self.assertFalse(larger2 > larger)
654 self.assertFalse(larger2 < larger)
656 self.assertTrue(larger == larger2)
657 self.assertTrue(smaller != larger)
660 self.assertTrue(empty == empty2)
661 self.assertFalse(empty != empty2)
662 self.assertFalse(empty == smaller)
663 self.assertTrue(empty != smaller)
666 self.assertTrue(larger != larger3)
667 self.assertFalse(larger == larger3)
669 def test_errors_in_view_containment_check(self):
671 def __eq__(self, other):
676 with self.assertRaises(RuntimeError):
678 with self.assertRaises(RuntimeError):
680 with self.assertRaises(RuntimeError):
682 with self.assertRaises(RuntimeError):
686 with self.assertRaises(RuntimeError):
688 with self.assertRaises(RuntimeError):
691 def test_dictview_set_operations_on_keys(self):
696 self.assertEqual(k1 - k2, set())
697 self.assertEqual(k1 - k3, {1,2})
698 self.assertEqual(k2 - k1, {3})
699 self.assertEqual(k3 - k1, {4})
700 self.assertEqual(k1 & k2, {1,2})
701 self.assertEqual(k1 & k3, set())
702 self.assertEqual(k1 | k2, {1,2,3})
703 self.assertEqual(k1 ^ k2, {3})
704 self.assertEqual(k1 ^ k3, {1,2,4})
706 def test_dictview_set_operations_on_items(self):
711 self.assertEqual(k1 - k2, set())
712 self.assertEqual(k1 - k3, {(1,1), (2,2)})
713 self.assertEqual(k2 - k1, {(3,3)})
714 self.assertEqual(k3 - k1, {(4,4)})
715 self.assertEqual(k1 & k2, {(1,1), (2,2)})
716 self.assertEqual(k1 & k3, set())
717 self.assertEqual(k1 | k2, {(1,1), (2,2), (3,3)})
718 self.assertEqual(k1 ^ k2, {(3,3)})
719 self.assertEqual(k1 ^ k3, {(1,1), (2,2), (4,4)})
721 def test_items_symmetric_difference(self):
726 with self.subTest(left=left, right=right):
729 self.assertEqual(actual, expected)
731 def test_dictview_mixed_set_operations(self):
733 self.assertTrue({1:1}.keys() == {1})
734 self.assertTrue({1} == {1:1}.keys())
735 self.assertEqual({1:1}.keys() | {2}, {1, 2})
736 self.assertEqual({2} | {1:1}.keys(), {1, 2})
738 self.assertTrue({1:1}.items() == {(1,1)})
739 self.assertTrue({(1,1)} == {1:1}.items())
740 self.assertEqual({1:1}.items() | {2}, {(1,1), 2})
741 self.assertEqual({2} | {1:1}.items(), {(1,1), 2})
743 def test_missing(self):
745 self.assertFalse(hasattr(dict, "__missing__"))
746 self.assertFalse(hasattr({}, "__missing__"))
753 def __missing__(self, key):
756 self.assertEqual(d[1], 2)
757 self.assertEqual(d[3], 4)
758 self.assertNotIn(2, d)
759 self.assertNotIn(2, d.keys())
760 self.assertEqual(d[2], 42)
763 def __missing__(self, key):
766 with self.assertRaises(RuntimeError) as c:
768 self.assertEqual(c.exception.args, (42,))
771 def __init__(self):
773 self.__missing__ = lambda key: None
775 with self.assertRaises(KeyError) as c:
777 self.assertEqual(c.exception.args, (42,))
782 with self.assertRaises(KeyError) as c:
784 self.assertEqual(c.exception.args, (42,))
786 def test_tuple_keyerror(self):
789 with self.assertRaises(KeyError) as c:
791 self.assertEqual(c.exception.args, ((1,),))
793 def test_bad_key(self):
799 def __hash__(self):
800 return hash(self.__class__)
802 def __eq__(self, other):
803 if isinstance(other, self.__class__):
818 with self.assertRaises(CustomException):
821 def test_resize1(self):
837 def test_resize2(self):
842 def __hash__(self):
844 def __eq__(self, other):
859 def test_empty_presized_dict_in_freelist(self):
862 with self.assertRaises(ZeroDivisionError):
867 def test_container_iterator(self):
881 self.assertIs(ref(), None, "Cycle was not collected")
883 def _not_tracked(self, t):
887 self.assertFalse(gc.is_tracked(t), t)
889 def _tracked(self, t):
890 self.assertTrue(gc.is_tracked(t), t)
893 self.assertTrue(gc.is_tracked(t), t)
895 def test_string_keys_can_track_values(self):
904 def test_track_literals(self):
908 self._not_tracked({})
909 self._not_tracked({x:(), y:x, z:1})
910 self._not_tracked({1: "a", "b": 2})
911 self._not_tracked({1: 2, (None, True, False, ()): int})
912 self._not_tracked({1: object()})
916 self._tracked({1: []})
917 self._tracked({1: ([],)})
918 self._tracked({1: {}})
919 self._tracked({1: set()})
922 def test_track_dynamic(self):
929 self._not_tracked(d)
931 self._not_tracked(d)
933 self._not_tracked(d)
935 self._not_tracked(d)
936 self._not_tracked(d.copy())
938 self._tracked(d)
939 self._tracked(d.copy())
941 self._not_tracked(d)
942 self._not_tracked(d.copy())
949 self._not_tracked(dd)
950 self._tracked(d)
952 self._tracked(dd)
955 self._not_tracked(d)
958 self._not_tracked(dd)
960 self._tracked(d)
963 self._tracked(dd)
966 self._not_tracked(d)
968 self._tracked(d)
971 self._not_tracked(d)
973 self._tracked(d)
976 self._not_tracked(d)
978 self._tracked(d)
981 self._not_tracked(d)
983 self._tracked(d)
986 def test_track_subtypes(self):
990 self._tracked(MyDict())
992 def make_shared_key_dict(self, n):
1005 def test_splittable_setdefault(self):
1008 a, b = self.make_shared_key_dict(2)
1017 self.assertEqual(list(a), ['x', 'y', 'z', 'a', 'b'])
1018 self.assertEqual(list(b), ['x', 'y', 'z', 'b', 'a'])
1021 def test_splittable_del(self):
1023 a, b = self.make_shared_key_dict(2)
1028 with self.assertRaises(KeyError):
1031 self.assertEqual(list(a), ['x', 'z'])
1032 self.assertEqual(list(b), ['x', 'y', 'z'])
1036 self.assertEqual(list(a), ['x', 'z', 'y'])
1037 self.assertEqual(list(b), ['x', 'y', 'z'])
1040 def test_splittable_pop(self):
1041 a, b = self.make_shared_key_dict(2)
1044 with self.assertRaises(KeyError):
1047 self.assertEqual(list(a), ['x', 'z'])
1048 self.assertEqual(list(b), ['x', 'y', 'z'])
1052 self.assertEqual(list(a), ['x', 'z', 'y'])
1053 self.assertEqual(list(b), ['x', 'y', 'z'])
1056 def test_splittable_pop_pending(self):
1058 a, b = self.make_shared_key_dict(2)
1061 with self.assertRaises(KeyError):
1065 def test_splittable_popitem(self):
1067 a, b = self.make_shared_key_dict(2)
1072 self.assertEqual(item, ('z', 3))
1073 with self.assertRaises(KeyError):
1076 self.assertGreater(sys.getsizeof(a), orig_size)
1077 self.assertEqual(list(a), ['x', 'y'])
1078 self.assertEqual(list(b), ['x', 'y', 'z'])
1081 def test_splittable_update(self):
1084 def __init__(self, order):
1086 self.a, self.b, self.c = 1, 2, 3
1088 self.c, self.b, self.a = 1, 2, 3
1091 self.assertEqual(list(o.__dict__), ["c", "b", "a"])
1095 self.assertEqual(list(d), ["c", "b", "a"])
1097 def test_iterator_pickling(self):
1103 self.assertEqual(list(it), list(data))
1113 self.assertEqual(list(it), list(data))
1115 def test_itemiterator_pickling(self):
1126 # self.assertEqual(type(itorg), type(it))
1127 self.assertIsInstance(it, collections.abc.Iterator)
1128 self.assertEqual(dict(it), data)
1135 self.assertEqual(dict(it), data)
1137 def test_valuesiterator_pickling(self):
1144 self.assertEqual(list(it), list(data.values()))
1151 self.assertEqual(sorted(values), sorted(list(data.values())))
1153 def test_reverseiterator_pickling(self):
1159 self.assertEqual(list(it), list(reversed(data)))
1169 self.assertEqual(list(it), list(reversed(data)))
1171 def test_reverseitemiterator_pickling(self):
1182 # self.assertEqual(type(itorg), type(it))
1183 self.assertIsInstance(it, collections.abc.Iterator)
1184 self.assertEqual(dict(it), data)
1191 self.assertEqual(dict(it), data)
1193 def test_reversevaluesiterator_pickling(self):
1200 self.assertEqual(list(it), list(reversed(data.values())))
1207 self.assertEqual(sorted(values), sorted(data.values()))
1209 def test_instance_dict_getattr_str_subclass(self):
1211 def __init__(self, msg):
1212 self.msg = msg
1216 self.assertEqual(f.msg, getattr(f, _str('msg')))
1217 self.assertEqual(f.msg, f.__dict__[_str('msg')])
1219 def test_object_set_item_single_instance_non_str_key(self):
1224 self.assertEqual(f.__dict__, {1:1, 'a':'a'})
1226 def check_reentrant_insertion(self, mutate):
1231 def __del__(self):
1238 def test_reentrant_insertion(self):
1242 self.check_reentrant_insertion(mutate)
1245 d.update(self.__dict__)
1247 self.check_reentrant_insertion(mutate)
1252 self.check_reentrant_insertion(mutate)
1254 def test_merge_and_mutate(self):
1256 def __hash__(self):
1259 def __eq__(self, o):
1267 self.assertRaises(RuntimeError, d.update, other)
1269 def test_free_after_iterating(self):
1270 support.check_free_after_iterating(self, iter, dict)
1271 support.check_free_after_iterating(self, lambda d: iter(d.keys()), dict)
1272 support.check_free_after_iterating(self, lambda d: iter(d.values()), dict)
1273 support.check_free_after_iterating(self, lambda d: iter(d.items()), dict)
1275 def test_equal_operator_modifying_operand(self):
1278 def __del__(self):
1281 def __eq__(self, other):
1285 def __hash__(self):
1290 self.assertTrue(dict_a == dict_b)
1294 def __eq__(self, other):
1300 self.assertTrue(dict_c == dict_d)
1302 def test_fromkeys_operator_modifying_dict_operand(self):
1305 def __hash__(self):
1308 def __eq__(self, other):
1320 def test_fromkeys_operator_modifying_set_operand(self):
1323 def __hash__(self):
1326 def __eq__(self, other):
1338 def test_dictitems_contains_use_after_free(self):
1340 def __eq__(self, other):
1347 def test_dict_contain_use_after_free(self):
1350 def __eq__(self, other):
1354 def __hash__(self):
1358 self.assertFalse('test' in d)
1360 def test_init_use_after_free(self):
1362 def __hash__(self):
1369 def test_oob_indexing_dictiter_iternextitem(self):
1371 def __del__(self):
1381 self.assertRaises(RuntimeError, iter_and_mutate)
1383 def test_reversed(self):
1387 self.assertEqual(list(r), list('dcba'))
1388 self.assertRaises(StopIteration, next, r)
1390 def test_reverse_iterator_for_empty_dict(self):
1394 self.assertEqual(list(reversed({})), [])
1395 self.assertEqual(list(reversed({}.items())), [])
1396 self.assertEqual(list(reversed({}.values())), [])
1397 self.assertEqual(list(reversed({}.keys())), [])
1400 self.assertEqual(list(reversed(dict())), [])
1401 self.assertEqual(list(reversed(dict().items())), [])
1402 self.assertEqual(list(reversed(dict().values())), [])
1403 self.assertEqual(list(reversed(dict().keys())), [])
1405 def test_reverse_iterator_for_shared_shared_dicts(self):
1407 def __init__(self, x, y):
1408 if x: self.x = x
1409 if y: self.y = y
1411 self.assertEqual(list(reversed(A(1, 2).__dict__)), ['y', 'x'])
1412 self.assertEqual(list(reversed(A(1, 0).__dict__)), ['x'])
1413 self.assertEqual(list(reversed(A(0, 1).__dict__)), ['y'])
1415 def test_dict_copy_order(self):
1422 self.assertEqual(list(copy.items()), expected)
1431 self.assertEqual(pairs, list(dict(d).items()))
1434 def keys(self):
1435 return reversed(list(dict.keys(self)))
1439 def items(self):
1440 return reversed(dict.items(self))
1443 self.assertEqual(pairs[::-1], list(dict(d).items()))
1446 def test_dict_items_result_gc(self):
1455 self.assertTrue(gc.is_tracked(next(it)))
1458 def test_dict_items_result_gc_reversed(self):
1462 self.assertTrue(gc.is_tracked(next(it)))
1464 def test_str_nonstr(self):
1475 def __hash__(self):
1478 def __eq__(self, other):
1506 self.assertEqual(d.setdefault(key3, 44), 44)
1536 with self.subTest(d=d):
1537 self.assertEqual(d.get('key1'), 42)
1546 self.assertFalse(noninterned_key1 is interned_key1)
1547 self.assertEqual(d.get(noninterned_key1), 42)
1549 self.assertEqual(d.get('key3'), 44)
1550 self.assertEqual(d.get(key3_1), 44)
1551 self.assertEqual(d.get(key3_2), 44)
1561 self.assertEqual(d.get(key3_3), 44)
1562 self.assertGreaterEqual(eq_count, 1)
1569 def test_getitem_knownhash(self):
1574 self.assertEqual(dict_getitem_knownhash(d, 'x', hash('x')), 1)
1575 self.assertEqual(dict_getitem_knownhash(d, 'y', hash('y')), 2)
1576 self.assertEqual(dict_getitem_knownhash(d, 'z', hash('z')), 3)
1579 self.assertRaises(SystemError, dict_getitem_knownhash, [], 1, hash(1))
1581 self.assertRaises(KeyError, dict_getitem_knownhash, {}, 1, hash(1))
1585 def __eq__(self, other):
1587 def __hash__(self):
1592 self.assertEqual(dict_getitem_knownhash(d, k1, hash(k1)), 1)
1593 self.assertRaises(Exc, dict_getitem_knownhash, d, k2, hash(k2))