source: python/trunk/Lib/test/test_userdict.py

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 10.4 KB
Line 
1# Check every path through every method of UserDict
2
3from test import test_support, mapping_tests
4import UserDict
5
6d0 = {}
7d1 = {"one": 1}
8d2 = {"one": 1, "two": 2}
9d3 = {"one": 1, "two": 3, "three": 5}
10d4 = {"one": None, "two": None}
11d5 = {"one": 1, "two": 1}
12
13class UserDictTest(mapping_tests.TestHashMappingProtocol):
14 type2test = UserDict.IterableUserDict
15
16 def test_all(self):
17 # Test constructors
18 u = UserDict.UserDict()
19 u0 = UserDict.UserDict(d0)
20 u1 = UserDict.UserDict(d1)
21 u2 = UserDict.IterableUserDict(d2)
22
23 uu = UserDict.UserDict(u)
24 uu0 = UserDict.UserDict(u0)
25 uu1 = UserDict.UserDict(u1)
26 uu2 = UserDict.UserDict(u2)
27
28 # keyword arg constructor
29 self.assertEqual(UserDict.UserDict(one=1, two=2), d2)
30 # item sequence constructor
31 self.assertEqual(UserDict.UserDict([('one',1), ('two',2)]), d2)
32 self.assertEqual(UserDict.UserDict(dict=[('one',1), ('two',2)]), d2)
33 # both together
34 self.assertEqual(UserDict.UserDict([('one',1), ('two',2)], two=3, three=5), d3)
35
36 # alternate constructor
37 self.assertEqual(UserDict.UserDict.fromkeys('one two'.split()), d4)
38 self.assertEqual(UserDict.UserDict().fromkeys('one two'.split()), d4)
39 self.assertEqual(UserDict.UserDict.fromkeys('one two'.split(), 1), d5)
40 self.assertEqual(UserDict.UserDict().fromkeys('one two'.split(), 1), d5)
41 self.assertTrue(u1.fromkeys('one two'.split()) is not u1)
42 self.assertIsInstance(u1.fromkeys('one two'.split()), UserDict.UserDict)
43 self.assertIsInstance(u2.fromkeys('one two'.split()), UserDict.IterableUserDict)
44
45 # Test __repr__
46 self.assertEqual(str(u0), str(d0))
47 self.assertEqual(repr(u1), repr(d1))
48 self.assertEqual(repr(u2), repr(d2))
49
50 # Test __cmp__ and __len__
51 all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
52 for a in all:
53 for b in all:
54 self.assertEqual(cmp(a, b), cmp(len(a), len(b)))
55
56 # Test __getitem__
57 self.assertEqual(u2["one"], 1)
58 self.assertRaises(KeyError, u1.__getitem__, "two")
59
60 # Test __setitem__
61 u3 = UserDict.UserDict(u2)
62 u3["two"] = 2
63 u3["three"] = 3
64
65 # Test __delitem__
66 del u3["three"]
67 self.assertRaises(KeyError, u3.__delitem__, "three")
68
69 # Test clear
70 u3.clear()
71 self.assertEqual(u3, {})
72
73 # Test copy()
74 u2a = u2.copy()
75 self.assertEqual(u2a, u2)
76 u2b = UserDict.UserDict(x=42, y=23)
77 u2c = u2b.copy() # making a copy of a UserDict is special cased
78 self.assertEqual(u2b, u2c)
79
80 class MyUserDict(UserDict.UserDict):
81 def display(self): print self
82
83 m2 = MyUserDict(u2)
84 m2a = m2.copy()
85 self.assertEqual(m2a, m2)
86
87 # SF bug #476616 -- copy() of UserDict subclass shared data
88 m2['foo'] = 'bar'
89 self.assertNotEqual(m2a, m2)
90
91 # Test keys, items, values
92 self.assertEqual(u2.keys(), d2.keys())
93 self.assertEqual(u2.items(), d2.items())
94 self.assertEqual(u2.values(), d2.values())
95
96 # Test has_key and "in".
97 for i in u2.keys():
98 self.assertIn(i, u2)
99 self.assertEqual(i in u1, i in d1)
100 self.assertEqual(i in u0, i in d0)
101 with test_support.check_py3k_warnings():
102 self.assertTrue(u2.has_key(i))
103 self.assertEqual(u1.has_key(i), d1.has_key(i))
104 self.assertEqual(u0.has_key(i), d0.has_key(i))
105
106 # Test update
107 t = UserDict.UserDict()
108 t.update(u2)
109 self.assertEqual(t, u2)
110 class Items:
111 def items(self):
112 return (("x", 42), ("y", 23))
113 t = UserDict.UserDict()
114 t.update(Items())
115 self.assertEqual(t, {"x": 42, "y": 23})
116
117 # Test get
118 for i in u2.keys():
119 self.assertEqual(u2.get(i), u2[i])
120 self.assertEqual(u1.get(i), d1.get(i))
121 self.assertEqual(u0.get(i), d0.get(i))
122
123 # Test "in" iteration.
124 for i in xrange(20):
125 u2[i] = str(i)
126 ikeys = []
127 for k in u2:
128 ikeys.append(k)
129 keys = u2.keys()
130 self.assertEqual(set(ikeys), set(keys))
131
132 # Test setdefault
133 t = UserDict.UserDict()
134 self.assertEqual(t.setdefault("x", 42), 42)
135 self.assertTrue(t.has_key("x"))
136 self.assertEqual(t.setdefault("x", 23), 42)
137
138 # Test pop
139 t = UserDict.UserDict(x=42)
140 self.assertEqual(t.pop("x"), 42)
141 self.assertRaises(KeyError, t.pop, "x")
142 self.assertEqual(t.pop("x", 1), 1)
143 t["x"] = 42
144 self.assertEqual(t.pop("x", 1), 42)
145
146 # Test popitem
147 t = UserDict.UserDict(x=42)
148 self.assertEqual(t.popitem(), ("x", 42))
149 self.assertRaises(KeyError, t.popitem)
150
151 def test_missing(self):
152 # Make sure UserDict doesn't have a __missing__ method
153 self.assertEqual(hasattr(UserDict, "__missing__"), False)
154 # Test several cases:
155 # (D) subclass defines __missing__ method returning a value
156 # (E) subclass defines __missing__ method raising RuntimeError
157 # (F) subclass sets __missing__ instance variable (no effect)
158 # (G) subclass doesn't define __missing__ at a all
159 class D(UserDict.UserDict):
160 def __missing__(self, key):
161 return 42
162 d = D({1: 2, 3: 4})
163 self.assertEqual(d[1], 2)
164 self.assertEqual(d[3], 4)
165 self.assertNotIn(2, d)
166 self.assertNotIn(2, d.keys())
167 self.assertEqual(d[2], 42)
168 class E(UserDict.UserDict):
169 def __missing__(self, key):
170 raise RuntimeError(key)
171 e = E()
172 try:
173 e[42]
174 except RuntimeError, err:
175 self.assertEqual(err.args, (42,))
176 else:
177 self.fail("e[42] didn't raise RuntimeError")
178 class F(UserDict.UserDict):
179 def __init__(self):
180 # An instance variable __missing__ should have no effect
181 self.__missing__ = lambda key: None
182 UserDict.UserDict.__init__(self)
183 f = F()
184 try:
185 f[42]
186 except KeyError, err:
187 self.assertEqual(err.args, (42,))
188 else:
189 self.fail("f[42] didn't raise KeyError")
190 class G(UserDict.UserDict):
191 pass
192 g = G()
193 try:
194 g[42]
195 except KeyError, err:
196 self.assertEqual(err.args, (42,))
197 else:
198 self.fail("g[42] didn't raise KeyError")
199
200##########################
201# Test Dict Mixin
202
203class SeqDict(UserDict.DictMixin):
204 """Dictionary lookalike implemented with lists.
205
206 Used to test and demonstrate DictMixin
207 """
208 def __init__(self, other=None, **kwargs):
209 self.keylist = []
210 self.valuelist = []
211 if other is not None:
212 for (key, value) in other:
213 self[key] = value
214 for (key, value) in kwargs.iteritems():
215 self[key] = value
216 def __getitem__(self, key):
217 try:
218 i = self.keylist.index(key)
219 except ValueError:
220 raise KeyError
221 return self.valuelist[i]
222 def __setitem__(self, key, value):
223 try:
224 i = self.keylist.index(key)
225 self.valuelist[i] = value
226 except ValueError:
227 self.keylist.append(key)
228 self.valuelist.append(value)
229 def __delitem__(self, key):
230 try:
231 i = self.keylist.index(key)
232 except ValueError:
233 raise KeyError
234 self.keylist.pop(i)
235 self.valuelist.pop(i)
236 def keys(self):
237 return list(self.keylist)
238 def copy(self):
239 d = self.__class__()
240 for key, value in self.iteritems():
241 d[key] = value
242 return d
243 @classmethod
244 def fromkeys(cls, keys, value=None):
245 d = cls()
246 for key in keys:
247 d[key] = value
248 return d
249
250class UserDictMixinTest(mapping_tests.TestMappingProtocol):
251 type2test = SeqDict
252
253 def test_all(self):
254 ## Setup test and verify working of the test class
255
256 # check init
257 s = SeqDict()
258
259 # exercise setitem
260 s[10] = 'ten'
261 s[20] = 'twenty'
262 s[30] = 'thirty'
263
264 # exercise delitem
265 del s[20]
266 # check getitem and setitem
267 self.assertEqual(s[10], 'ten')
268 # check keys() and delitem
269 self.assertEqual(s.keys(), [10, 30])
270
271 ## Now, test the DictMixin methods one by one
272 # has_key
273 self.assertTrue(s.has_key(10))
274 self.assertTrue(not s.has_key(20))
275
276 # __contains__
277 self.assertIn(10, s)
278 self.assertNotIn(20, s)
279
280 # __iter__
281 self.assertEqual([k for k in s], [10, 30])
282
283 # __len__
284 self.assertEqual(len(s), 2)
285
286 # iteritems
287 self.assertEqual(list(s.iteritems()), [(10,'ten'), (30, 'thirty')])
288
289 # iterkeys
290 self.assertEqual(list(s.iterkeys()), [10, 30])
291
292 # itervalues
293 self.assertEqual(list(s.itervalues()), ['ten', 'thirty'])
294
295 # values
296 self.assertEqual(s.values(), ['ten', 'thirty'])
297
298 # items
299 self.assertEqual(s.items(), [(10,'ten'), (30, 'thirty')])
300
301 # get
302 self.assertEqual(s.get(10), 'ten')
303 self.assertEqual(s.get(15,'fifteen'), 'fifteen')
304 self.assertEqual(s.get(15), None)
305
306 # setdefault
307 self.assertEqual(s.setdefault(40, 'forty'), 'forty')
308 self.assertEqual(s.setdefault(10, 'null'), 'ten')
309 del s[40]
310
311 # pop
312 self.assertEqual(s.pop(10), 'ten')
313 self.assertNotIn(10, s)
314 s[10] = 'ten'
315 self.assertEqual(s.pop("x", 1), 1)
316 s["x"] = 42
317 self.assertEqual(s.pop("x", 1), 42)
318
319 # popitem
320 k, v = s.popitem()
321 self.assertNotIn(k, s)
322 s[k] = v
323
324 # clear
325 s.clear()
326 self.assertEqual(len(s), 0)
327
328 # empty popitem
329 self.assertRaises(KeyError, s.popitem)
330
331 # update
332 s.update({10: 'ten', 20:'twenty'})
333 self.assertEqual(s[10], 'ten')
334 self.assertEqual(s[20], 'twenty')
335
336 # cmp
337 self.assertEqual(s, {10: 'ten', 20:'twenty'})
338 t = SeqDict()
339 t[20] = 'twenty'
340 t[10] = 'ten'
341 self.assertEqual(s, t)
342
343def test_main():
344 test_support.run_unittest(
345 UserDictTest,
346 UserDictMixinTest
347 )
348
349if __name__ == "__main__":
350 test_main()
Note: See TracBrowser for help on using the repository browser.