python (3.12.0)
1 import collections.abc
2 import copy
3 import pickle
4 import sys
5 import unittest
6 from test.support import C_RECURSION_LIMIT
7
8 class ESC[4;38;5;81mDictSetTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
9
10 def test_constructors_not_callable(self):
11 kt = type({}.keys())
12 self.assertRaises(TypeError, kt, {})
13 self.assertRaises(TypeError, kt)
14 it = type({}.items())
15 self.assertRaises(TypeError, it, {})
16 self.assertRaises(TypeError, it)
17 vt = type({}.values())
18 self.assertRaises(TypeError, vt, {})
19 self.assertRaises(TypeError, vt)
20
21 def test_dict_keys(self):
22 d = {1: 10, "a": "ABC"}
23 keys = d.keys()
24 self.assertEqual(len(keys), 2)
25 self.assertEqual(set(keys), {1, "a"})
26 self.assertEqual(keys, {1, "a"})
27 self.assertNotEqual(keys, {1, "a", "b"})
28 self.assertNotEqual(keys, {1, "b"})
29 self.assertNotEqual(keys, {1})
30 self.assertNotEqual(keys, 42)
31 self.assertIn(1, keys)
32 self.assertIn("a", keys)
33 self.assertNotIn(10, keys)
34 self.assertNotIn("Z", keys)
35 self.assertEqual(d.keys(), d.keys())
36 e = {1: 11, "a": "def"}
37 self.assertEqual(d.keys(), e.keys())
38 del e["a"]
39 self.assertNotEqual(d.keys(), e.keys())
40
41 def test_dict_items(self):
42 d = {1: 10, "a": "ABC"}
43 items = d.items()
44 self.assertEqual(len(items), 2)
45 self.assertEqual(set(items), {(1, 10), ("a", "ABC")})
46 self.assertEqual(items, {(1, 10), ("a", "ABC")})
47 self.assertNotEqual(items, {(1, 10), ("a", "ABC"), "junk"})
48 self.assertNotEqual(items, {(1, 10), ("a", "def")})
49 self.assertNotEqual(items, {(1, 10)})
50 self.assertNotEqual(items, 42)
51 self.assertIn((1, 10), items)
52 self.assertIn(("a", "ABC"), items)
53 self.assertNotIn((1, 11), items)
54 self.assertNotIn(1, items)
55 self.assertNotIn((), items)
56 self.assertNotIn((1,), items)
57 self.assertNotIn((1, 2, 3), items)
58 self.assertEqual(d.items(), d.items())
59 e = d.copy()
60 self.assertEqual(d.items(), e.items())
61 e["a"] = "def"
62 self.assertNotEqual(d.items(), e.items())
63
64 def test_dict_mixed_keys_items(self):
65 d = {(1, 1): 11, (2, 2): 22}
66 e = {1: 1, 2: 2}
67 self.assertEqual(d.keys(), e.items())
68 self.assertNotEqual(d.items(), e.keys())
69
70 def test_dict_values(self):
71 d = {1: 10, "a": "ABC"}
72 values = d.values()
73 self.assertEqual(set(values), {10, "ABC"})
74 self.assertEqual(len(values), 2)
75
76 def test_dict_repr(self):
77 d = {1: 10, "a": "ABC"}
78 self.assertIsInstance(repr(d), str)
79 r = repr(d.items())
80 self.assertIsInstance(r, str)
81 self.assertTrue(r == "dict_items([('a', 'ABC'), (1, 10)])" or
82 r == "dict_items([(1, 10), ('a', 'ABC')])")
83 r = repr(d.keys())
84 self.assertIsInstance(r, str)
85 self.assertTrue(r == "dict_keys(['a', 1])" or
86 r == "dict_keys([1, 'a'])")
87 r = repr(d.values())
88 self.assertIsInstance(r, str)
89 self.assertTrue(r == "dict_values(['ABC', 10])" or
90 r == "dict_values([10, 'ABC'])")
91
92 def test_keys_set_operations(self):
93 d1 = {'a': 1, 'b': 2}
94 d2 = {'b': 3, 'c': 2}
95 d3 = {'d': 4, 'e': 5}
96 d4 = {'d': 4}
97
98 class ESC[4;38;5;81mCustomSet(ESC[4;38;5;149mset):
99 def intersection(self, other):
100 return CustomSet(super().intersection(other))
101
102 self.assertEqual(d1.keys() & d1.keys(), {'a', 'b'})
103 self.assertEqual(d1.keys() & d2.keys(), {'b'})
104 self.assertEqual(d1.keys() & d3.keys(), set())
105 self.assertEqual(d1.keys() & set(d1.keys()), {'a', 'b'})
106 self.assertEqual(d1.keys() & set(d2.keys()), {'b'})
107 self.assertEqual(d1.keys() & set(d3.keys()), set())
108 self.assertEqual(d1.keys() & tuple(d1.keys()), {'a', 'b'})
109 self.assertEqual(d3.keys() & d4.keys(), {'d'})
110 self.assertEqual(d4.keys() & d3.keys(), {'d'})
111 self.assertEqual(d4.keys() & set(d3.keys()), {'d'})
112 self.assertIsInstance(d4.keys() & frozenset(d3.keys()), set)
113 self.assertIsInstance(frozenset(d3.keys()) & d4.keys(), set)
114 self.assertIs(type(d4.keys() & CustomSet(d3.keys())), set)
115 self.assertIs(type(d1.keys() & []), set)
116 self.assertIs(type([] & d1.keys()), set)
117
118 self.assertEqual(d1.keys() | d1.keys(), {'a', 'b'})
119 self.assertEqual(d1.keys() | d2.keys(), {'a', 'b', 'c'})
120 self.assertEqual(d1.keys() | d3.keys(), {'a', 'b', 'd', 'e'})
121 self.assertEqual(d1.keys() | set(d1.keys()), {'a', 'b'})
122 self.assertEqual(d1.keys() | set(d2.keys()), {'a', 'b', 'c'})
123 self.assertEqual(d1.keys() | set(d3.keys()),
124 {'a', 'b', 'd', 'e'})
125 self.assertEqual(d1.keys() | (1, 2), {'a', 'b', 1, 2})
126
127 self.assertEqual(d1.keys() ^ d1.keys(), set())
128 self.assertEqual(d1.keys() ^ d2.keys(), {'a', 'c'})
129 self.assertEqual(d1.keys() ^ d3.keys(), {'a', 'b', 'd', 'e'})
130 self.assertEqual(d1.keys() ^ set(d1.keys()), set())
131 self.assertEqual(d1.keys() ^ set(d2.keys()), {'a', 'c'})
132 self.assertEqual(d1.keys() ^ set(d3.keys()),
133 {'a', 'b', 'd', 'e'})
134 self.assertEqual(d1.keys() ^ tuple(d2.keys()), {'a', 'c'})
135
136 self.assertEqual(d1.keys() - d1.keys(), set())
137 self.assertEqual(d1.keys() - d2.keys(), {'a'})
138 self.assertEqual(d1.keys() - d3.keys(), {'a', 'b'})
139 self.assertEqual(d1.keys() - set(d1.keys()), set())
140 self.assertEqual(d1.keys() - set(d2.keys()), {'a'})
141 self.assertEqual(d1.keys() - set(d3.keys()), {'a', 'b'})
142 self.assertEqual(d1.keys() - (0, 1), {'a', 'b'})
143
144 self.assertFalse(d1.keys().isdisjoint(d1.keys()))
145 self.assertFalse(d1.keys().isdisjoint(d2.keys()))
146 self.assertFalse(d1.keys().isdisjoint(list(d2.keys())))
147 self.assertFalse(d1.keys().isdisjoint(set(d2.keys())))
148 self.assertTrue(d1.keys().isdisjoint({'x', 'y', 'z'}))
149 self.assertTrue(d1.keys().isdisjoint(['x', 'y', 'z']))
150 self.assertTrue(d1.keys().isdisjoint(set(['x', 'y', 'z'])))
151 self.assertTrue(d1.keys().isdisjoint(set(['x', 'y'])))
152 self.assertTrue(d1.keys().isdisjoint(['x', 'y']))
153 self.assertTrue(d1.keys().isdisjoint({}))
154 self.assertTrue(d1.keys().isdisjoint(d3.keys()))
155
156 de = {}
157 self.assertTrue(de.keys().isdisjoint(set()))
158 self.assertTrue(de.keys().isdisjoint([]))
159 self.assertTrue(de.keys().isdisjoint(de.keys()))
160 self.assertTrue(de.keys().isdisjoint([1]))
161
162 def test_items_set_operations(self):
163 d1 = {'a': 1, 'b': 2}
164 d2 = {'a': 2, 'b': 2}
165 d3 = {'d': 4, 'e': 5}
166 self.assertEqual(
167 d1.items() & d1.items(), {('a', 1), ('b', 2)})
168 self.assertEqual(d1.items() & d2.items(), {('b', 2)})
169 self.assertEqual(d1.items() & d3.items(), set())
170 self.assertEqual(d1.items() & set(d1.items()),
171 {('a', 1), ('b', 2)})
172 self.assertEqual(d1.items() & set(d2.items()), {('b', 2)})
173 self.assertEqual(d1.items() & set(d3.items()), set())
174 self.assertEqual(d1.items() & (("a", 1), ("b", 2)),
175 {('a', 1), ('b', 2)})
176 self.assertEqual(d1.items() & (("a", 2), ("b", 2)), {('b', 2)})
177 self.assertEqual(d1.items() & (("d", 4), ("e", 5)), set())
178
179 self.assertEqual(d1.items() | d1.items(),
180 {('a', 1), ('b', 2)})
181 self.assertEqual(d1.items() | d2.items(),
182 {('a', 1), ('a', 2), ('b', 2)})
183 self.assertEqual(d1.items() | d3.items(),
184 {('a', 1), ('b', 2), ('d', 4), ('e', 5)})
185 self.assertEqual(d1.items() | set(d1.items()),
186 {('a', 1), ('b', 2)})
187 self.assertEqual(d1.items() | set(d2.items()),
188 {('a', 1), ('a', 2), ('b', 2)})
189 self.assertEqual(d1.items() | set(d3.items()),
190 {('a', 1), ('b', 2), ('d', 4), ('e', 5)})
191 self.assertEqual(d1.items() | (('a', 1), ('b', 2)),
192 {('a', 1), ('b', 2)})
193 self.assertEqual(d1.items() | (('a', 2), ('b', 2)),
194 {('a', 1), ('a', 2), ('b', 2)})
195 self.assertEqual(d1.items() | (('d', 4), ('e', 5)),
196 {('a', 1), ('b', 2), ('d', 4), ('e', 5)})
197
198 self.assertEqual(d1.items() ^ d1.items(), set())
199 self.assertEqual(d1.items() ^ d2.items(),
200 {('a', 1), ('a', 2)})
201 self.assertEqual(d1.items() ^ d3.items(),
202 {('a', 1), ('b', 2), ('d', 4), ('e', 5)})
203 self.assertEqual(d1.items() ^ (('a', 1), ('b', 2)), set())
204 self.assertEqual(d1.items() ^ (("a", 2), ("b", 2)),
205 {('a', 1), ('a', 2)})
206 self.assertEqual(d1.items() ^ (("d", 4), ("e", 5)),
207 {('a', 1), ('b', 2), ('d', 4), ('e', 5)})
208
209 self.assertEqual(d1.items() - d1.items(), set())
210 self.assertEqual(d1.items() - d2.items(), {('a', 1)})
211 self.assertEqual(d1.items() - d3.items(), {('a', 1), ('b', 2)})
212 self.assertEqual(d1.items() - set(d1.items()), set())
213 self.assertEqual(d1.items() - set(d2.items()), {('a', 1)})
214 self.assertEqual(d1.items() - set(d3.items()), {('a', 1), ('b', 2)})
215 self.assertEqual(d1.items() - (('a', 1), ('b', 2)), set())
216 self.assertEqual(d1.items() - (("a", 2), ("b", 2)), {('a', 1)})
217 self.assertEqual(d1.items() - (("d", 4), ("e", 5)), {('a', 1), ('b', 2)})
218
219 self.assertFalse(d1.items().isdisjoint(d1.items()))
220 self.assertFalse(d1.items().isdisjoint(d2.items()))
221 self.assertFalse(d1.items().isdisjoint(list(d2.items())))
222 self.assertFalse(d1.items().isdisjoint(set(d2.items())))
223 self.assertTrue(d1.items().isdisjoint({'x', 'y', 'z'}))
224 self.assertTrue(d1.items().isdisjoint(['x', 'y', 'z']))
225 self.assertTrue(d1.items().isdisjoint(set(['x', 'y', 'z'])))
226 self.assertTrue(d1.items().isdisjoint(set(['x', 'y'])))
227 self.assertTrue(d1.items().isdisjoint({}))
228 self.assertTrue(d1.items().isdisjoint(d3.items()))
229
230 de = {}
231 self.assertTrue(de.items().isdisjoint(set()))
232 self.assertTrue(de.items().isdisjoint([]))
233 self.assertTrue(de.items().isdisjoint(de.items()))
234 self.assertTrue(de.items().isdisjoint([1]))
235
236 def test_set_operations_with_iterator(self):
237 origin = {1: 2, 3: 4}
238 self.assertEqual(origin.keys() & iter([1, 2]), {1})
239 self.assertEqual(origin.keys() | iter([1, 2]), {1, 2, 3})
240 self.assertEqual(origin.keys() ^ iter([1, 2]), {2, 3})
241 self.assertEqual(origin.keys() - iter([1, 2]), {3})
242
243 items = origin.items()
244 self.assertEqual(items & iter([(1, 2)]), {(1, 2)})
245 self.assertEqual(items ^ iter([(1, 2)]), {(3, 4)})
246 self.assertEqual(items | iter([(1, 2)]), {(1, 2), (3, 4)})
247 self.assertEqual(items - iter([(1, 2)]), {(3, 4)})
248
249 def test_set_operations_with_noniterable(self):
250 with self.assertRaises(TypeError):
251 {}.keys() & 1
252 with self.assertRaises(TypeError):
253 {}.keys() | 1
254 with self.assertRaises(TypeError):
255 {}.keys() ^ 1
256 with self.assertRaises(TypeError):
257 {}.keys() - 1
258
259 with self.assertRaises(TypeError):
260 {}.items() & 1
261 with self.assertRaises(TypeError):
262 {}.items() | 1
263 with self.assertRaises(TypeError):
264 {}.items() ^ 1
265 with self.assertRaises(TypeError):
266 {}.items() - 1
267
268 def test_recursive_repr(self):
269 d = {}
270 d[42] = d.values()
271 r = repr(d)
272 # Cannot perform a stronger test, as the contents of the repr
273 # are implementation-dependent. All we can say is that we
274 # want a str result, not an exception of any sort.
275 self.assertIsInstance(r, str)
276 d[42] = d.items()
277 r = repr(d)
278 # Again.
279 self.assertIsInstance(r, str)
280
281 def test_deeply_nested_repr(self):
282 d = {}
283 for i in range(C_RECURSION_LIMIT//2 + 100):
284 d = {42: d.values()}
285 self.assertRaises(RecursionError, repr, d)
286
287 def test_copy(self):
288 d = {1: 10, "a": "ABC"}
289 self.assertRaises(TypeError, copy.copy, d.keys())
290 self.assertRaises(TypeError, copy.copy, d.values())
291 self.assertRaises(TypeError, copy.copy, d.items())
292
293 def test_compare_error(self):
294 class ESC[4;38;5;81mExc(ESC[4;38;5;149mException):
295 pass
296
297 class ESC[4;38;5;81mBadEq:
298 def __hash__(self):
299 return 7
300 def __eq__(self, other):
301 raise Exc
302
303 k1, k2 = BadEq(), BadEq()
304 v1, v2 = BadEq(), BadEq()
305 d = {k1: v1}
306
307 self.assertIn(k1, d)
308 self.assertIn(k1, d.keys())
309 self.assertIn(v1, d.values())
310 self.assertIn((k1, v1), d.items())
311
312 self.assertRaises(Exc, d.__contains__, k2)
313 self.assertRaises(Exc, d.keys().__contains__, k2)
314 self.assertRaises(Exc, d.items().__contains__, (k2, v1))
315 self.assertRaises(Exc, d.items().__contains__, (k1, v2))
316 with self.assertRaises(Exc):
317 v2 in d.values()
318
319 def test_pickle(self):
320 d = {1: 10, "a": "ABC"}
321 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
322 self.assertRaises((TypeError, pickle.PicklingError),
323 pickle.dumps, d.keys(), proto)
324 self.assertRaises((TypeError, pickle.PicklingError),
325 pickle.dumps, d.values(), proto)
326 self.assertRaises((TypeError, pickle.PicklingError),
327 pickle.dumps, d.items(), proto)
328
329 def test_abc_registry(self):
330 d = dict(a=1)
331
332 self.assertIsInstance(d.keys(), collections.abc.KeysView)
333 self.assertIsInstance(d.keys(), collections.abc.MappingView)
334 self.assertIsInstance(d.keys(), collections.abc.Set)
335 self.assertIsInstance(d.keys(), collections.abc.Sized)
336 self.assertIsInstance(d.keys(), collections.abc.Iterable)
337 self.assertIsInstance(d.keys(), collections.abc.Container)
338
339 self.assertIsInstance(d.values(), collections.abc.ValuesView)
340 self.assertIsInstance(d.values(), collections.abc.MappingView)
341 self.assertIsInstance(d.values(), collections.abc.Sized)
342 self.assertIsInstance(d.values(), collections.abc.Collection)
343 self.assertIsInstance(d.values(), collections.abc.Iterable)
344 self.assertIsInstance(d.values(), collections.abc.Container)
345
346 self.assertIsInstance(d.items(), collections.abc.ItemsView)
347 self.assertIsInstance(d.items(), collections.abc.MappingView)
348 self.assertIsInstance(d.items(), collections.abc.Set)
349 self.assertIsInstance(d.items(), collections.abc.Sized)
350 self.assertIsInstance(d.items(), collections.abc.Iterable)
351 self.assertIsInstance(d.items(), collections.abc.Container)
352
353
354 if __name__ == "__main__":
355 unittest.main()
Browse
Usage
Versions