Commit | Line | Data |
---|---|---|
86530b38 AT |
1 | # Check every path through every method of UserDict |
2 | ||
3 | import unittest | |
4 | from test import test_support, mapping_tests | |
5 | import UserDict | |
6 | ||
7 | d0 = {} | |
8 | d1 = {"one": 1} | |
9 | d2 = {"one": 1, "two": 2} | |
10 | d3 = {"one": 1, "two": 3, "three": 5} | |
11 | d4 = {"one": None, "two": None} | |
12 | d5 = {"one": 1, "two": 1} | |
13 | ||
14 | class UserDictTest(mapping_tests.TestHashMappingProtocol): | |
15 | type2test = UserDict.IterableUserDict | |
16 | ||
17 | def test_all(self): | |
18 | # Test constructors | |
19 | u = UserDict.UserDict() | |
20 | u0 = UserDict.UserDict(d0) | |
21 | u1 = UserDict.UserDict(d1) | |
22 | u2 = UserDict.IterableUserDict(d2) | |
23 | ||
24 | uu = UserDict.UserDict(u) | |
25 | uu0 = UserDict.UserDict(u0) | |
26 | uu1 = UserDict.UserDict(u1) | |
27 | uu2 = UserDict.UserDict(u2) | |
28 | ||
29 | # keyword arg constructor | |
30 | self.assertEqual(UserDict.UserDict(one=1, two=2), d2) | |
31 | # item sequence constructor | |
32 | self.assertEqual(UserDict.UserDict([('one',1), ('two',2)]), d2) | |
33 | self.assertEqual(UserDict.UserDict(dict=[('one',1), ('two',2)]), d2) | |
34 | # both together | |
35 | self.assertEqual(UserDict.UserDict([('one',1), ('two',2)], two=3, three=5), d3) | |
36 | ||
37 | # alternate constructor | |
38 | self.assertEqual(UserDict.UserDict.fromkeys('one two'.split()), d4) | |
39 | self.assertEqual(UserDict.UserDict().fromkeys('one two'.split()), d4) | |
40 | self.assertEqual(UserDict.UserDict.fromkeys('one two'.split(), 1), d5) | |
41 | self.assertEqual(UserDict.UserDict().fromkeys('one two'.split(), 1), d5) | |
42 | self.assert_(u1.fromkeys('one two'.split()) is not u1) | |
43 | self.assert_(isinstance(u1.fromkeys('one two'.split()), UserDict.UserDict)) | |
44 | self.assert_(isinstance(u2.fromkeys('one two'.split()), UserDict.IterableUserDict)) | |
45 | ||
46 | # Test __repr__ | |
47 | self.assertEqual(str(u0), str(d0)) | |
48 | self.assertEqual(repr(u1), repr(d1)) | |
49 | self.assertEqual(`u2`, `d2`) | |
50 | ||
51 | # Test __cmp__ and __len__ | |
52 | all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2] | |
53 | for a in all: | |
54 | for b in all: | |
55 | self.assertEqual(cmp(a, b), cmp(len(a), len(b))) | |
56 | ||
57 | # Test __getitem__ | |
58 | self.assertEqual(u2["one"], 1) | |
59 | self.assertRaises(KeyError, u1.__getitem__, "two") | |
60 | ||
61 | # Test __setitem__ | |
62 | u3 = UserDict.UserDict(u2) | |
63 | u3["two"] = 2 | |
64 | u3["three"] = 3 | |
65 | ||
66 | # Test __delitem__ | |
67 | del u3["three"] | |
68 | self.assertRaises(KeyError, u3.__delitem__, "three") | |
69 | ||
70 | # Test clear | |
71 | u3.clear() | |
72 | self.assertEqual(u3, {}) | |
73 | ||
74 | # Test copy() | |
75 | u2a = u2.copy() | |
76 | self.assertEqual(u2a, u2) | |
77 | u2b = UserDict.UserDict(x=42, y=23) | |
78 | u2c = u2b.copy() # making a copy of a UserDict is special cased | |
79 | self.assertEqual(u2b, u2c) | |
80 | ||
81 | class MyUserDict(UserDict.UserDict): | |
82 | def display(self): print self | |
83 | ||
84 | m2 = MyUserDict(u2) | |
85 | m2a = m2.copy() | |
86 | self.assertEqual(m2a, m2) | |
87 | ||
88 | # SF bug #476616 -- copy() of UserDict subclass shared data | |
89 | m2['foo'] = 'bar' | |
90 | self.assertNotEqual(m2a, m2) | |
91 | ||
92 | # Test keys, items, values | |
93 | self.assertEqual(u2.keys(), d2.keys()) | |
94 | self.assertEqual(u2.items(), d2.items()) | |
95 | self.assertEqual(u2.values(), d2.values()) | |
96 | ||
97 | # Test has_key and "in". | |
98 | for i in u2.keys(): | |
99 | self.assert_(u2.has_key(i)) | |
100 | self.assert_(i in u2) | |
101 | self.assertEqual(u1.has_key(i), d1.has_key(i)) | |
102 | self.assertEqual(i in u1, i in d1) | |
103 | self.assertEqual(u0.has_key(i), d0.has_key(i)) | |
104 | self.assertEqual(i in u0, i in d0) | |
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.assert_(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 | ########################## | |
152 | # Test Dict Mixin | |
153 | ||
154 | class SeqDict(UserDict.DictMixin): | |
155 | """Dictionary lookalike implemented with lists. | |
156 | ||
157 | Used to test and demonstrate DictMixin | |
158 | """ | |
159 | def __init__(self, other=None, **kwargs): | |
160 | self.keylist = [] | |
161 | self.valuelist = [] | |
162 | if other is not None: | |
163 | for (key, value) in other: | |
164 | self[key] = value | |
165 | for (key, value) in kwargs.iteritems(): | |
166 | self[key] = value | |
167 | def __getitem__(self, key): | |
168 | try: | |
169 | i = self.keylist.index(key) | |
170 | except ValueError: | |
171 | raise KeyError | |
172 | return self.valuelist[i] | |
173 | def __setitem__(self, key, value): | |
174 | try: | |
175 | i = self.keylist.index(key) | |
176 | self.valuelist[i] = value | |
177 | except ValueError: | |
178 | self.keylist.append(key) | |
179 | self.valuelist.append(value) | |
180 | def __delitem__(self, key): | |
181 | try: | |
182 | i = self.keylist.index(key) | |
183 | except ValueError: | |
184 | raise KeyError | |
185 | self.keylist.pop(i) | |
186 | self.valuelist.pop(i) | |
187 | def keys(self): | |
188 | return list(self.keylist) | |
189 | def copy(self): | |
190 | d = self.__class__() | |
191 | for key, value in self.iteritems(): | |
192 | d[key] = value | |
193 | return d | |
194 | def fromkeys(cls, keys, value=None): | |
195 | d = cls() | |
196 | for key in keys: | |
197 | d[key] = value | |
198 | return d | |
199 | fromkeys = classmethod(fromkeys) | |
200 | ||
201 | class UserDictMixinTest(mapping_tests.TestMappingProtocol): | |
202 | type2test = SeqDict | |
203 | ||
204 | def test_all(self): | |
205 | ## Setup test and verify working of the test class | |
206 | ||
207 | # check init | |
208 | s = SeqDict() | |
209 | ||
210 | # exercise setitem | |
211 | s[10] = 'ten' | |
212 | s[20] = 'twenty' | |
213 | s[30] = 'thirty' | |
214 | ||
215 | # exercise delitem | |
216 | del s[20] | |
217 | # check getitem and setitem | |
218 | self.assertEqual(s[10], 'ten') | |
219 | # check keys() and delitem | |
220 | self.assertEqual(s.keys(), [10, 30]) | |
221 | ||
222 | ## Now, test the DictMixin methods one by one | |
223 | # has_key | |
224 | self.assert_(s.has_key(10)) | |
225 | self.assert_(not s.has_key(20)) | |
226 | ||
227 | # __contains__ | |
228 | self.assert_(10 in s) | |
229 | self.assert_(20 not in s) | |
230 | ||
231 | # __iter__ | |
232 | self.assertEqual([k for k in s], [10, 30]) | |
233 | ||
234 | # __len__ | |
235 | self.assertEqual(len(s), 2) | |
236 | ||
237 | # iteritems | |
238 | self.assertEqual(list(s.iteritems()), [(10,'ten'), (30, 'thirty')]) | |
239 | ||
240 | # iterkeys | |
241 | self.assertEqual(list(s.iterkeys()), [10, 30]) | |
242 | ||
243 | # itervalues | |
244 | self.assertEqual(list(s.itervalues()), ['ten', 'thirty']) | |
245 | ||
246 | # values | |
247 | self.assertEqual(s.values(), ['ten', 'thirty']) | |
248 | ||
249 | # items | |
250 | self.assertEqual(s.items(), [(10,'ten'), (30, 'thirty')]) | |
251 | ||
252 | # get | |
253 | self.assertEqual(s.get(10), 'ten') | |
254 | self.assertEqual(s.get(15,'fifteen'), 'fifteen') | |
255 | self.assertEqual(s.get(15), None) | |
256 | ||
257 | # setdefault | |
258 | self.assertEqual(s.setdefault(40, 'forty'), 'forty') | |
259 | self.assertEqual(s.setdefault(10, 'null'), 'ten') | |
260 | del s[40] | |
261 | ||
262 | # pop | |
263 | self.assertEqual(s.pop(10), 'ten') | |
264 | self.assert_(10 not in s) | |
265 | s[10] = 'ten' | |
266 | self.assertEqual(s.pop("x", 1), 1) | |
267 | s["x"] = 42 | |
268 | self.assertEqual(s.pop("x", 1), 42) | |
269 | ||
270 | # popitem | |
271 | k, v = s.popitem() | |
272 | self.assert_(k not in s) | |
273 | s[k] = v | |
274 | ||
275 | # clear | |
276 | s.clear() | |
277 | self.assertEqual(len(s), 0) | |
278 | ||
279 | # empty popitem | |
280 | self.assertRaises(KeyError, s.popitem) | |
281 | ||
282 | # update | |
283 | s.update({10: 'ten', 20:'twenty'}) | |
284 | self.assertEqual(s[10], 'ten') | |
285 | self.assertEqual(s[20], 'twenty') | |
286 | ||
287 | # cmp | |
288 | self.assertEqual(s, {10: 'ten', 20:'twenty'}) | |
289 | t = SeqDict() | |
290 | t[20] = 'twenty' | |
291 | t[10] = 'ten' | |
292 | self.assertEqual(s, t) | |
293 | ||
294 | def test_main(): | |
295 | test_support.run_unittest( | |
296 | UserDictTest, | |
297 | UserDictMixinTest | |
298 | ) | |
299 | ||
300 | if __name__ == "__main__": | |
301 | test_main() |