Debian Codegraph @

Lib/test/test_dictviews.py

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