Debian Codegraph @

Lib/test/test_userdict.py

raw
1 # Check every path through every method of UserDict
2
3 from collections import UserDict
4 from test import mapping_tests
5 import unittest
6 import collections
7 import types
8
9
10 class UserDictSubclass(UserDict):
11 pass
12
13 class UserDictSubclass2(UserDict):
14 pass
15
16
17 d0 = {}
18 d1 = {"one": 1}
19 d2 = {"one": 1, "two": 2}
20 d3 = {"one": 1, "two": 3, "three": 5}
21 d4 = {"one": None, "two": None}
22 d5 = {"one": 1, "two": 1}
23
24 class UserDictTest(mapping_tests.TestHashMappingProtocol):
25 type2test = collections.UserDict
26
27 def test_all(self):
28 # Test constructors
29 u = collections.UserDict()
30 u0 = collections.UserDict(d0)
31 u1 = collections.UserDict(d1)
32 u2 = collections.UserDict(d2)
33
34 uu = collections.UserDict(u)
35 uu0 = collections.UserDict(u0)
36 uu1 = collections.UserDict(u1)
37 uu2 = collections.UserDict(u2)
38
39 # keyword arg constructor
40 self.assertEqual(collections.UserDict(one=1, two=2), d2)
41 # item sequence constructor
42 self.assertEqual(collections.UserDict([('one',1), ('two',2)]), d2)
43 self.assertEqual(collections.UserDict(dict=[('one',1), ('two',2)]),
44 {'dict': [('one', 1), ('two', 2)]})
45 # both together
46 self.assertEqual(collections.UserDict([('one',1), ('two',2)], two=3, three=5), d3)
47
48 # alternate constructor
49 self.assertEqual(collections.UserDict.fromkeys('one two'.split()), d4)
50 self.assertEqual(collections.UserDict().fromkeys('one two'.split()), d4)
51 self.assertEqual(collections.UserDict.fromkeys('one two'.split(), 1), d5)
52 self.assertEqual(collections.UserDict().fromkeys('one two'.split(), 1), d5)
53 self.assertTrue(u1.fromkeys('one two'.split()) is not u1)
54 self.assertIsInstance(u1.fromkeys('one two'.split()), collections.UserDict)
55 self.assertIsInstance(u2.fromkeys('one two'.split()), collections.UserDict)
56
57 # Test __repr__
58 self.assertEqual(str(u0), str(d0))
59 self.assertEqual(repr(u1), repr(d1))
60 self.assertIn(repr(u2), ("{'one': 1, 'two': 2}",
61 "{'two': 2, 'one': 1}"))
62
63 # Test rich comparison and __len__
64 all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
65 for a in all:
66 for b in all:
67 self.assertEqual(a == b, len(a) == len(b))
68
69 # Test __getitem__
70 self.assertEqual(u2["one"], 1)
71 self.assertRaises(KeyError, u1.__getitem__, "two")
72
73 # Test __setitem__
74 u3 = collections.UserDict(u2)
75 u3["two"] = 2
76 u3["three"] = 3
77
78 # Test __delitem__
79 del u3["three"]
80 self.assertRaises(KeyError, u3.__delitem__, "three")
81
82 # Test clear
83 u3.clear()
84 self.assertEqual(u3, {})
85
86 # Test copy()
87 u2a = u2.copy()
88 self.assertEqual(u2a, u2)
89 u2b = collections.UserDict(x=42, y=23)
90 u2c = u2b.copy() # making a copy of a UserDict is special cased
91 self.assertEqual(u2b, u2c)
92
93 class MyUserDict(collections.UserDict):
94 def display(self): print(self)
95
96 m2 = MyUserDict(u2)
97 m2a = m2.copy()
98 self.assertEqual(m2a, m2)
99
100 # SF bug #476616 -- copy() of UserDict subclass shared data
101 m2['foo'] = 'bar'
102 self.assertNotEqual(m2a, m2)
103
104 # Test keys, items, values
105 self.assertEqual(sorted(u2.keys()), sorted(d2.keys()))
106 self.assertEqual(sorted(u2.items()), sorted(d2.items()))
107 self.assertEqual(sorted(u2.values()), sorted(d2.values()))
108
109 # Test "in".
110 for i in u2.keys():
111 self.assertIn(i, u2)
112 self.assertEqual(i in u1, i in d1)
113 self.assertEqual(i in u0, i in d0)
114
115 # Test update
116 t = collections.UserDict()
117 t.update(u2)
118 self.assertEqual(t, u2)
119
120 # Test get
121 for i in u2.keys():
122 self.assertEqual(u2.get(i), u2[i])
123 self.assertEqual(u1.get(i), d1.get(i))
124 self.assertEqual(u0.get(i), d0.get(i))
125
126 # Test "in" iteration.
127 for i in range(20):
128 u2[i] = str(i)
129 ikeys = []
130 for k in u2:
131 ikeys.append(k)
132 keys = u2.keys()
133 self.assertEqual(set(ikeys), set(keys))
134
135 # Test setdefault
136 t = collections.UserDict()
137 self.assertEqual(t.setdefault("x", 42), 42)
138 self.assertIn("x", t)
139 self.assertEqual(t.setdefault("x", 23), 42)
140
141 # Test pop
142 t = collections.UserDict(x=42)
143 self.assertEqual(t.pop("x"), 42)
144 self.assertRaises(KeyError, t.pop, "x")
145 self.assertEqual(t.pop("x", 1), 1)
146 t["x"] = 42
147 self.assertEqual(t.pop("x", 1), 42)
148
149 # Test popitem
150 t = collections.UserDict(x=42)
151 self.assertEqual(t.popitem(), ("x", 42))
152 self.assertRaises(KeyError, t.popitem)
153
154 def test_init(self):
155 for kw in 'self', 'other', 'iterable':
156 self.assertEqual(list(collections.UserDict(**{kw: 42}).items()),
157 [(kw, 42)])
158 self.assertEqual(list(collections.UserDict({}, dict=42).items()),
159 [('dict', 42)])
160 self.assertEqual(list(collections.UserDict({}, dict=None).items()),
161 [('dict', None)])
162 self.assertEqual(list(collections.UserDict(dict={'a': 42}).items()),
163 [('dict', {'a': 42})])
164 self.assertRaises(TypeError, collections.UserDict, 42)
165 self.assertRaises(TypeError, collections.UserDict, (), ())
166 self.assertRaises(TypeError, collections.UserDict.__init__)
167
168 def test_data(self):
169 u = UserDict()
170 self.assertEqual(u.data, {})
171 self.assertIs(type(u.data), dict)
172 d = {'a': 1, 'b': 2}
173 u = UserDict(d)
174 self.assertEqual(u.data, d)
175 self.assertIsNot(u.data, d)
176 self.assertIs(type(u.data), dict)
177 u = UserDict(u)
178 self.assertEqual(u.data, d)
179 self.assertIs(type(u.data), dict)
180 u = UserDict([('a', 1), ('b', 2)])
181 self.assertEqual(u.data, d)
182 self.assertIs(type(u.data), dict)
183 u = UserDict(a=1, b=2)
184 self.assertEqual(u.data, d)
185 self.assertIs(type(u.data), dict)
186
187 def test_update(self):
188 for kw in 'self', 'dict', 'other', 'iterable':
189 d = collections.UserDict()
190 d.update(**{kw: 42})
191 self.assertEqual(list(d.items()), [(kw, 42)])
192 self.assertRaises(TypeError, collections.UserDict().update, 42)
193 self.assertRaises(TypeError, collections.UserDict().update, {}, {})
194 self.assertRaises(TypeError, collections.UserDict.update)
195
196 def test_missing(self):
197 # Make sure UserDict doesn't have a __missing__ method
198 self.assertNotHasAttr(collections.UserDict, "__missing__")
199 # Test several cases:
200 # (D) subclass defines __missing__ method returning a value
201 # (E) subclass defines __missing__ method raising RuntimeError
202 # (F) subclass sets __missing__ instance variable (no effect)
203 # (G) subclass doesn't define __missing__ at all
204 class D(collections.UserDict):
205 def __missing__(self, key):
206 return 42
207 d = D({1: 2, 3: 4})
208 self.assertEqual(d[1], 2)
209 self.assertEqual(d[3], 4)
210 self.assertNotIn(2, d)
211 self.assertNotIn(2, d.keys())
212 self.assertEqual(d[2], 42)
213 class E(collections.UserDict):
214 def __missing__(self, key):
215 raise RuntimeError(key)
216 e = E()
217 try:
218 e[42]
219 except RuntimeError as err:
220 self.assertEqual(err.args, (42,))
221 else:
222 self.fail("e[42] didn't raise RuntimeError")
223 class F(collections.UserDict):
224 def __init__(self):
225 # An instance variable __missing__ should have no effect
226 self.__missing__ = lambda key: None
227 collections.UserDict.__init__(self)
228 f = F()
229 try:
230 f[42]
231 except KeyError as err:
232 self.assertEqual(err.args, (42,))
233 else:
234 self.fail("f[42] didn't raise KeyError")
235 class G(collections.UserDict):
236 pass
237 g = G()
238 try:
239 g[42]
240 except KeyError as err:
241 self.assertEqual(err.args, (42,))
242 else:
243 self.fail("g[42] didn't raise KeyError")
244
245 test_repr_deep = mapping_tests.TestHashMappingProtocol.test_repr_deep
246
247 def test_mixed_or(self):
248 for t in UserDict, dict, types.MappingProxyType:
249 with self.subTest(t.__name__):
250 u = UserDict({0: 'a', 1: 'b'}) | t({1: 'c', 2: 'd'})
251 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
252 self.assertIs(type(u), UserDict)
253
254 u = t({0: 'a', 1: 'b'}) | UserDict({1: 'c', 2: 'd'})
255 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
256 self.assertIs(type(u), UserDict)
257
258 u = UserDict({0: 'a', 1: 'b'}) | UserDictSubclass({1: 'c', 2: 'd'})
259 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
260 self.assertIs(type(u), UserDict)
261
262 u = UserDictSubclass({0: 'a', 1: 'b'}) | UserDict({1: 'c', 2: 'd'})
263 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
264 self.assertIs(type(u), UserDictSubclass)
265
266 u = UserDictSubclass({0: 'a', 1: 'b'}) | UserDictSubclass2({1: 'c', 2: 'd'})
267 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
268 self.assertIs(type(u), UserDictSubclass)
269
270 u = UserDict({1: 'c', 2: 'd'}).__ror__(UserDict({0: 'a', 1: 'b'}))
271 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
272 self.assertIs(type(u), UserDict)
273
274 u = UserDictSubclass({1: 'c', 2: 'd'}).__ror__(UserDictSubclass2({0: 'a', 1: 'b'}))
275 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
276 self.assertIs(type(u), UserDictSubclass)
277
278 def test_mixed_ior(self):
279 for t in UserDict, dict, types.MappingProxyType:
280 with self.subTest(t.__name__):
281 u = u2 = UserDict({0: 'a', 1: 'b'})
282 u |= t({1: 'c', 2: 'd'})
283 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
284 self.assertIs(type(u), UserDict)
285 self.assertIs(u, u2)
286
287 u = dict({0: 'a', 1: 'b'})
288 u |= UserDict({1: 'c', 2: 'd'})
289 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
290 self.assertIs(type(u), dict)
291
292 u = u2 = UserDict({0: 'a', 1: 'b'})
293 u |= UserDictSubclass({1: 'c', 2: 'd'})
294 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
295 self.assertIs(type(u), UserDict)
296 self.assertIs(u, u2)
297
298 u = u2 = UserDictSubclass({0: 'a', 1: 'b'})
299 u |= UserDict({1: 'c', 2: 'd'})
300 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
301 self.assertIs(type(u), UserDictSubclass)
302 self.assertIs(u, u2)
303
304 u = u2 = UserDictSubclass({0: 'a', 1: 'b'})
305 u |= UserDictSubclass2({1: 'c', 2: 'd'})
306 self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
307 self.assertIs(type(u), UserDictSubclass)
308 self.assertIs(u, u2)
309
310
311 if __name__ == "__main__":
312 unittest.main()