Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | # tests common to dict and UserDict |
2 | import unittest | |
3 | import UserDict | |
4 | ||
5 | ||
6 | class BasicTestMappingProtocol(unittest.TestCase): | |
7 | # This base class can be used to check that an object conforms to the | |
8 | # mapping protocol | |
9 | ||
10 | # Functions that can be useful to override to adapt to dictionary | |
11 | # semantics | |
12 | type2test = None # which class is being tested (overwrite in subclasses) | |
13 | ||
14 | def _reference(self): | |
15 | """Return a dictionary of values which are invariant by storage | |
16 | in the object under test.""" | |
17 | return {1:2, "key1":"value1", "key2":(1,2,3)} | |
18 | def _empty_mapping(self): | |
19 | """Return an empty mapping object""" | |
20 | return self.type2test() | |
21 | def _full_mapping(self, data): | |
22 | """Return a mapping object with the value contained in data | |
23 | dictionary""" | |
24 | x = self._empty_mapping() | |
25 | for key, value in data.items(): | |
26 | x[key] = value | |
27 | return x | |
28 | ||
29 | def __init__(self, *args, **kw): | |
30 | unittest.TestCase.__init__(self, *args, **kw) | |
31 | self.reference = self._reference().copy() | |
32 | ||
33 | # A (key, value) pair not in the mapping | |
34 | key, value = self.reference.popitem() | |
35 | self.other = {key:value} | |
36 | ||
37 | # A (key, value) pair in the mapping | |
38 | key, value = self.reference.popitem() | |
39 | self.inmapping = {key:value} | |
40 | self.reference[key] = value | |
41 | ||
42 | def test_read(self): | |
43 | # Test for read only operations on mapping | |
44 | p = self._empty_mapping() | |
45 | p1 = dict(p) #workaround for singleton objects | |
46 | d = self._full_mapping(self.reference) | |
47 | if d is p: | |
48 | p = p1 | |
49 | #Indexing | |
50 | for key, value in self.reference.items(): | |
51 | self.assertEqual(d[key], value) | |
52 | knownkey = self.other.keys()[0] | |
53 | self.failUnlessRaises(KeyError, lambda:d[knownkey]) | |
54 | #len | |
55 | self.assertEqual(len(p), 0) | |
56 | self.assertEqual(len(d), len(self.reference)) | |
57 | #has_key | |
58 | for k in self.reference: | |
59 | self.assert_(d.has_key(k)) | |
60 | self.assert_(k in d) | |
61 | for k in self.other: | |
62 | self.failIf(d.has_key(k)) | |
63 | self.failIf(k in d) | |
64 | #cmp | |
65 | self.assertEqual(cmp(p,p), 0) | |
66 | self.assertEqual(cmp(d,d), 0) | |
67 | self.assertEqual(cmp(p,d), -1) | |
68 | self.assertEqual(cmp(d,p), 1) | |
69 | #__non__zero__ | |
70 | if p: self.fail("Empty mapping must compare to False") | |
71 | if not d: self.fail("Full mapping must compare to True") | |
72 | # keys(), items(), iterkeys() ... | |
73 | def check_iterandlist(iter, lst, ref): | |
74 | self.assert_(hasattr(iter, 'next')) | |
75 | self.assert_(hasattr(iter, '__iter__')) | |
76 | x = list(iter) | |
77 | self.assert_(set(x)==set(lst)==set(ref)) | |
78 | check_iterandlist(d.iterkeys(), d.keys(), self.reference.keys()) | |
79 | check_iterandlist(iter(d), d.keys(), self.reference.keys()) | |
80 | check_iterandlist(d.itervalues(), d.values(), self.reference.values()) | |
81 | check_iterandlist(d.iteritems(), d.items(), self.reference.items()) | |
82 | #get | |
83 | key, value = d.iteritems().next() | |
84 | knownkey, knownvalue = self.other.iteritems().next() | |
85 | self.assertEqual(d.get(key, knownvalue), value) | |
86 | self.assertEqual(d.get(knownkey, knownvalue), knownvalue) | |
87 | self.failIf(knownkey in d) | |
88 | ||
89 | def test_write(self): | |
90 | # Test for write operations on mapping | |
91 | p = self._empty_mapping() | |
92 | #Indexing | |
93 | for key, value in self.reference.items(): | |
94 | p[key] = value | |
95 | self.assertEqual(p[key], value) | |
96 | for key in self.reference.keys(): | |
97 | del p[key] | |
98 | self.failUnlessRaises(KeyError, lambda:p[key]) | |
99 | p = self._empty_mapping() | |
100 | #update | |
101 | p.update(self.reference) | |
102 | self.assertEqual(dict(p), self.reference) | |
103 | items = p.items() | |
104 | p = self._empty_mapping() | |
105 | p.update(items) | |
106 | self.assertEqual(dict(p), self.reference) | |
107 | d = self._full_mapping(self.reference) | |
108 | #setdefault | |
109 | key, value = d.iteritems().next() | |
110 | knownkey, knownvalue = self.other.iteritems().next() | |
111 | self.assertEqual(d.setdefault(key, knownvalue), value) | |
112 | self.assertEqual(d[key], value) | |
113 | self.assertEqual(d.setdefault(knownkey, knownvalue), knownvalue) | |
114 | self.assertEqual(d[knownkey], knownvalue) | |
115 | #pop | |
116 | self.assertEqual(d.pop(knownkey), knownvalue) | |
117 | self.failIf(knownkey in d) | |
118 | self.assertRaises(KeyError, d.pop, knownkey) | |
119 | default = 909 | |
120 | d[knownkey] = knownvalue | |
121 | self.assertEqual(d.pop(knownkey, default), knownvalue) | |
122 | self.failIf(knownkey in d) | |
123 | self.assertEqual(d.pop(knownkey, default), default) | |
124 | #popitem | |
125 | key, value = d.popitem() | |
126 | self.failIf(key in d) | |
127 | self.assertEqual(value, self.reference[key]) | |
128 | p=self._empty_mapping() | |
129 | self.assertRaises(KeyError, p.popitem) | |
130 | ||
131 | def test_constructor(self): | |
132 | self.assertEqual(self._empty_mapping(), self._empty_mapping()) | |
133 | ||
134 | def test_bool(self): | |
135 | self.assert_(not self._empty_mapping()) | |
136 | self.assert_(self.reference) | |
137 | self.assert_(bool(self._empty_mapping()) is False) | |
138 | self.assert_(bool(self.reference) is True) | |
139 | ||
140 | def test_keys(self): | |
141 | d = self._empty_mapping() | |
142 | self.assertEqual(d.keys(), []) | |
143 | d = self.reference | |
144 | self.assert_(self.inmapping.keys()[0] in d.keys()) | |
145 | self.assert_(self.other.keys()[0] not in d.keys()) | |
146 | self.assertRaises(TypeError, d.keys, None) | |
147 | ||
148 | def test_values(self): | |
149 | d = self._empty_mapping() | |
150 | self.assertEqual(d.values(), []) | |
151 | ||
152 | self.assertRaises(TypeError, d.values, None) | |
153 | ||
154 | def test_items(self): | |
155 | d = self._empty_mapping() | |
156 | self.assertEqual(d.items(), []) | |
157 | ||
158 | self.assertRaises(TypeError, d.items, None) | |
159 | ||
160 | def test_len(self): | |
161 | d = self._empty_mapping() | |
162 | self.assertEqual(len(d), 0) | |
163 | ||
164 | def test_getitem(self): | |
165 | d = self.reference | |
166 | self.assertEqual(d[self.inmapping.keys()[0]], self.inmapping.values()[0]) | |
167 | ||
168 | self.assertRaises(TypeError, d.__getitem__) | |
169 | ||
170 | def test_update(self): | |
171 | # mapping argument | |
172 | d = self._empty_mapping() | |
173 | d.update(self.other) | |
174 | self.assertEqual(d.items(), self.other.items()) | |
175 | ||
176 | # No argument | |
177 | d = self._empty_mapping() | |
178 | d.update() | |
179 | self.assertEqual(d, self._empty_mapping()) | |
180 | ||
181 | # item sequence | |
182 | d = self._empty_mapping() | |
183 | d.update(self.other.items()) | |
184 | self.assertEqual(d.items(), self.other.items()) | |
185 | ||
186 | # Iterator | |
187 | d = self._empty_mapping() | |
188 | d.update(self.other.iteritems()) | |
189 | self.assertEqual(d.items(), self.other.items()) | |
190 | ||
191 | # FIXME: Doesn't work with UserDict | |
192 | # self.assertRaises((TypeError, AttributeError), d.update, None) | |
193 | self.assertRaises((TypeError, AttributeError), d.update, 42) | |
194 | ||
195 | outerself = self | |
196 | class SimpleUserDict: | |
197 | def __init__(self): | |
198 | self.d = outerself.reference | |
199 | def keys(self): | |
200 | return self.d.keys() | |
201 | def __getitem__(self, i): | |
202 | return self.d[i] | |
203 | d.clear() | |
204 | d.update(SimpleUserDict()) | |
205 | i1 = d.items() | |
206 | i2 = self.reference.items() | |
207 | i1.sort() | |
208 | i2.sort() | |
209 | self.assertEqual(i1, i2) | |
210 | ||
211 | class Exc(Exception): pass | |
212 | ||
213 | d = self._empty_mapping() | |
214 | class FailingUserDict: | |
215 | def keys(self): | |
216 | raise Exc | |
217 | self.assertRaises(Exc, d.update, FailingUserDict()) | |
218 | ||
219 | d.clear() | |
220 | ||
221 | class FailingUserDict: | |
222 | def keys(self): | |
223 | class BogonIter: | |
224 | def __init__(self): | |
225 | self.i = 1 | |
226 | def __iter__(self): | |
227 | return self | |
228 | def next(self): | |
229 | if self.i: | |
230 | self.i = 0 | |
231 | return 'a' | |
232 | raise Exc | |
233 | return BogonIter() | |
234 | def __getitem__(self, key): | |
235 | return key | |
236 | self.assertRaises(Exc, d.update, FailingUserDict()) | |
237 | ||
238 | class FailingUserDict: | |
239 | def keys(self): | |
240 | class BogonIter: | |
241 | def __init__(self): | |
242 | self.i = ord('a') | |
243 | def __iter__(self): | |
244 | return self | |
245 | def next(self): | |
246 | if self.i <= ord('z'): | |
247 | rtn = chr(self.i) | |
248 | self.i += 1 | |
249 | return rtn | |
250 | raise StopIteration | |
251 | return BogonIter() | |
252 | def __getitem__(self, key): | |
253 | raise Exc | |
254 | self.assertRaises(Exc, d.update, FailingUserDict()) | |
255 | ||
256 | d = self._empty_mapping() | |
257 | class badseq(object): | |
258 | def __iter__(self): | |
259 | return self | |
260 | def next(self): | |
261 | raise Exc() | |
262 | ||
263 | self.assertRaises(Exc, d.update, badseq()) | |
264 | ||
265 | self.assertRaises(ValueError, d.update, [(1, 2, 3)]) | |
266 | ||
267 | # no test_fromkeys or test_copy as both os.environ and selves don't support it | |
268 | ||
269 | def test_get(self): | |
270 | d = self._empty_mapping() | |
271 | self.assert_(d.get(self.other.keys()[0]) is None) | |
272 | self.assertEqual(d.get(self.other.keys()[0], 3), 3) | |
273 | d = self.reference | |
274 | self.assert_(d.get(self.other.keys()[0]) is None) | |
275 | self.assertEqual(d.get(self.other.keys()[0], 3), 3) | |
276 | self.assertEqual(d.get(self.inmapping.keys()[0]), self.inmapping.values()[0]) | |
277 | self.assertEqual(d.get(self.inmapping.keys()[0], 3), self.inmapping.values()[0]) | |
278 | self.assertRaises(TypeError, d.get) | |
279 | self.assertRaises(TypeError, d.get, None, None, None) | |
280 | ||
281 | def test_setdefault(self): | |
282 | d = self._empty_mapping() | |
283 | self.assertRaises(TypeError, d.setdefault) | |
284 | ||
285 | def test_popitem(self): | |
286 | d = self._empty_mapping() | |
287 | self.assertRaises(KeyError, d.popitem) | |
288 | self.assertRaises(TypeError, d.popitem, 42) | |
289 | ||
290 | def test_pop(self): | |
291 | d = self._empty_mapping() | |
292 | k, v = self.inmapping.items()[0] | |
293 | d[k] = v | |
294 | self.assertRaises(KeyError, d.pop, self.other.keys()[0]) | |
295 | ||
296 | self.assertEqual(d.pop(k), v) | |
297 | self.assertEqual(len(d), 0) | |
298 | ||
299 | self.assertRaises(KeyError, d.pop, k) | |
300 | ||
301 | ||
302 | class TestMappingProtocol(BasicTestMappingProtocol): | |
303 | def test_constructor(self): | |
304 | BasicTestMappingProtocol.test_constructor(self) | |
305 | self.assert_(self._empty_mapping() is not self._empty_mapping()) | |
306 | self.assertEqual(self.type2test(x=1, y=2), {"x": 1, "y": 2}) | |
307 | ||
308 | def test_bool(self): | |
309 | BasicTestMappingProtocol.test_bool(self) | |
310 | self.assert_(not self._empty_mapping()) | |
311 | self.assert_(self._full_mapping({"x": "y"})) | |
312 | self.assert_(bool(self._empty_mapping()) is False) | |
313 | self.assert_(bool(self._full_mapping({"x": "y"})) is True) | |
314 | ||
315 | def test_keys(self): | |
316 | BasicTestMappingProtocol.test_keys(self) | |
317 | d = self._empty_mapping() | |
318 | self.assertEqual(d.keys(), []) | |
319 | d = self._full_mapping({'a': 1, 'b': 2}) | |
320 | k = d.keys() | |
321 | self.assert_('a' in k) | |
322 | self.assert_('b' in k) | |
323 | self.assert_('c' not in k) | |
324 | ||
325 | def test_values(self): | |
326 | BasicTestMappingProtocol.test_values(self) | |
327 | d = self._full_mapping({1:2}) | |
328 | self.assertEqual(d.values(), [2]) | |
329 | ||
330 | def test_items(self): | |
331 | BasicTestMappingProtocol.test_items(self) | |
332 | ||
333 | d = self._full_mapping({1:2}) | |
334 | self.assertEqual(d.items(), [(1, 2)]) | |
335 | ||
336 | def test_has_key(self): | |
337 | d = self._empty_mapping() | |
338 | self.assert_(not d.has_key('a')) | |
339 | d = self._full_mapping({'a': 1, 'b': 2}) | |
340 | k = d.keys() | |
341 | k.sort() | |
342 | self.assertEqual(k, ['a', 'b']) | |
343 | ||
344 | self.assertRaises(TypeError, d.has_key) | |
345 | ||
346 | def test_contains(self): | |
347 | d = self._empty_mapping() | |
348 | self.assert_(not ('a' in d)) | |
349 | self.assert_('a' not in d) | |
350 | d = self._full_mapping({'a': 1, 'b': 2}) | |
351 | self.assert_('a' in d) | |
352 | self.assert_('b' in d) | |
353 | self.assert_('c' not in d) | |
354 | ||
355 | self.assertRaises(TypeError, d.__contains__) | |
356 | ||
357 | def test_len(self): | |
358 | BasicTestMappingProtocol.test_len(self) | |
359 | d = self._full_mapping({'a': 1, 'b': 2}) | |
360 | self.assertEqual(len(d), 2) | |
361 | ||
362 | def test_getitem(self): | |
363 | BasicTestMappingProtocol.test_getitem(self) | |
364 | d = self._full_mapping({'a': 1, 'b': 2}) | |
365 | self.assertEqual(d['a'], 1) | |
366 | self.assertEqual(d['b'], 2) | |
367 | d['c'] = 3 | |
368 | d['a'] = 4 | |
369 | self.assertEqual(d['c'], 3) | |
370 | self.assertEqual(d['a'], 4) | |
371 | del d['b'] | |
372 | self.assertEqual(d, {'a': 4, 'c': 3}) | |
373 | ||
374 | self.assertRaises(TypeError, d.__getitem__) | |
375 | ||
376 | def test_clear(self): | |
377 | d = self._full_mapping({1:1, 2:2, 3:3}) | |
378 | d.clear() | |
379 | self.assertEqual(d, {}) | |
380 | ||
381 | self.assertRaises(TypeError, d.clear, None) | |
382 | ||
383 | def test_update(self): | |
384 | BasicTestMappingProtocol.test_update(self) | |
385 | # mapping argument | |
386 | d = self._empty_mapping() | |
387 | d.update({1:100}) | |
388 | d.update({2:20}) | |
389 | d.update({1:1, 2:2, 3:3}) | |
390 | self.assertEqual(d, {1:1, 2:2, 3:3}) | |
391 | ||
392 | # no argument | |
393 | d.update() | |
394 | self.assertEqual(d, {1:1, 2:2, 3:3}) | |
395 | ||
396 | # keyword arguments | |
397 | d = self._empty_mapping() | |
398 | d.update(x=100) | |
399 | d.update(y=20) | |
400 | d.update(x=1, y=2, z=3) | |
401 | self.assertEqual(d, {"x":1, "y":2, "z":3}) | |
402 | ||
403 | # item sequence | |
404 | d = self._empty_mapping() | |
405 | d.update([("x", 100), ("y", 20)]) | |
406 | self.assertEqual(d, {"x":100, "y":20}) | |
407 | ||
408 | # Both item sequence and keyword arguments | |
409 | d = self._empty_mapping() | |
410 | d.update([("x", 100), ("y", 20)], x=1, y=2) | |
411 | self.assertEqual(d, {"x":1, "y":2}) | |
412 | ||
413 | # iterator | |
414 | d = self._full_mapping({1:3, 2:4}) | |
415 | d.update(self._full_mapping({1:2, 3:4, 5:6}).iteritems()) | |
416 | self.assertEqual(d, {1:2, 2:4, 3:4, 5:6}) | |
417 | ||
418 | class SimpleUserDict: | |
419 | def __init__(self): | |
420 | self.d = {1:1, 2:2, 3:3} | |
421 | def keys(self): | |
422 | return self.d.keys() | |
423 | def __getitem__(self, i): | |
424 | return self.d[i] | |
425 | d.clear() | |
426 | d.update(SimpleUserDict()) | |
427 | self.assertEqual(d, {1:1, 2:2, 3:3}) | |
428 | ||
429 | def test_fromkeys(self): | |
430 | self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) | |
431 | d = self._empty_mapping() | |
432 | self.assert_(not(d.fromkeys('abc') is d)) | |
433 | self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) | |
434 | self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0}) | |
435 | self.assertEqual(d.fromkeys([]), {}) | |
436 | def g(): | |
437 | yield 1 | |
438 | self.assertEqual(d.fromkeys(g()), {1:None}) | |
439 | self.assertRaises(TypeError, {}.fromkeys, 3) | |
440 | class dictlike(self.type2test): pass | |
441 | self.assertEqual(dictlike.fromkeys('a'), {'a':None}) | |
442 | self.assertEqual(dictlike().fromkeys('a'), {'a':None}) | |
443 | self.assert_(dictlike.fromkeys('a').__class__ is dictlike) | |
444 | self.assert_(dictlike().fromkeys('a').__class__ is dictlike) | |
445 | # FIXME: the following won't work with UserDict, because it's an old style class | |
446 | # self.assert_(type(dictlike.fromkeys('a')) is dictlike) | |
447 | class mydict(self.type2test): | |
448 | def __new__(cls): | |
449 | return UserDict.UserDict() | |
450 | ud = mydict.fromkeys('ab') | |
451 | self.assertEqual(ud, {'a':None, 'b':None}) | |
452 | # FIXME: the following won't work with UserDict, because it's an old style class | |
453 | # self.assert_(isinstance(ud, UserDict.UserDict)) | |
454 | self.assertRaises(TypeError, dict.fromkeys) | |
455 | ||
456 | class Exc(Exception): pass | |
457 | ||
458 | class baddict1(self.type2test): | |
459 | def __init__(self): | |
460 | raise Exc() | |
461 | ||
462 | self.assertRaises(Exc, baddict1.fromkeys, [1]) | |
463 | ||
464 | class BadSeq(object): | |
465 | def __iter__(self): | |
466 | return self | |
467 | def next(self): | |
468 | raise Exc() | |
469 | ||
470 | self.assertRaises(Exc, self.type2test.fromkeys, BadSeq()) | |
471 | ||
472 | class baddict2(self.type2test): | |
473 | def __setitem__(self, key, value): | |
474 | raise Exc() | |
475 | ||
476 | self.assertRaises(Exc, baddict2.fromkeys, [1]) | |
477 | ||
478 | def test_copy(self): | |
479 | d = self._full_mapping({1:1, 2:2, 3:3}) | |
480 | self.assertEqual(d.copy(), {1:1, 2:2, 3:3}) | |
481 | d = self._empty_mapping() | |
482 | self.assertEqual(d.copy(), d) | |
483 | self.assert_(isinstance(d.copy(), d.__class__)) | |
484 | self.assertRaises(TypeError, d.copy, None) | |
485 | ||
486 | def test_get(self): | |
487 | BasicTestMappingProtocol.test_get(self) | |
488 | d = self._empty_mapping() | |
489 | self.assert_(d.get('c') is None) | |
490 | self.assertEqual(d.get('c', 3), 3) | |
491 | d = self._full_mapping({'a' : 1, 'b' : 2}) | |
492 | self.assert_(d.get('c') is None) | |
493 | self.assertEqual(d.get('c', 3), 3) | |
494 | self.assertEqual(d.get('a'), 1) | |
495 | self.assertEqual(d.get('a', 3), 1) | |
496 | ||
497 | def test_setdefault(self): | |
498 | BasicTestMappingProtocol.test_setdefault(self) | |
499 | d = self._empty_mapping() | |
500 | self.assert_(d.setdefault('key0') is None) | |
501 | d.setdefault('key0', []) | |
502 | self.assert_(d.setdefault('key0') is None) | |
503 | d.setdefault('key', []).append(3) | |
504 | self.assertEqual(d['key'][0], 3) | |
505 | d.setdefault('key', []).append(4) | |
506 | self.assertEqual(len(d['key']), 2) | |
507 | ||
508 | def test_popitem(self): | |
509 | BasicTestMappingProtocol.test_popitem(self) | |
510 | for copymode in -1, +1: | |
511 | # -1: b has same structure as a | |
512 | # +1: b is a.copy() | |
513 | for log2size in range(12): | |
514 | size = 2**log2size | |
515 | a = self._empty_mapping() | |
516 | b = self._empty_mapping() | |
517 | for i in range(size): | |
518 | a[repr(i)] = i | |
519 | if copymode < 0: | |
520 | b[repr(i)] = i | |
521 | if copymode > 0: | |
522 | b = a.copy() | |
523 | for i in range(size): | |
524 | ka, va = ta = a.popitem() | |
525 | self.assertEqual(va, int(ka)) | |
526 | kb, vb = tb = b.popitem() | |
527 | self.assertEqual(vb, int(kb)) | |
528 | self.assert_(not(copymode < 0 and ta != tb)) | |
529 | self.assert_(not a) | |
530 | self.assert_(not b) | |
531 | ||
532 | def test_pop(self): | |
533 | BasicTestMappingProtocol.test_pop(self) | |
534 | ||
535 | # Tests for pop with specified key | |
536 | d = self._empty_mapping() | |
537 | k, v = 'abc', 'def' | |
538 | ||
539 | # verify longs/ints get same value when key > 32 bits (for 64-bit archs) | |
540 | # see SF bug #689659 | |
541 | x = 4503599627370496L | |
542 | y = 4503599627370496 | |
543 | h = self._full_mapping({x: 'anything', y: 'something else'}) | |
544 | self.assertEqual(h[x], h[y]) | |
545 | ||
546 | self.assertEqual(d.pop(k, v), v) | |
547 | d[k] = v | |
548 | self.assertEqual(d.pop(k, 1), v) | |
549 | ||
550 | ||
551 | class TestHashMappingProtocol(TestMappingProtocol): | |
552 | ||
553 | def test_getitem(self): | |
554 | TestMappingProtocol.test_getitem(self) | |
555 | class Exc(Exception): pass | |
556 | ||
557 | class BadEq(object): | |
558 | def __eq__(self, other): | |
559 | raise Exc() | |
560 | ||
561 | d = self._empty_mapping() | |
562 | d[BadEq()] = 42 | |
563 | self.assertRaises(KeyError, d.__getitem__, 23) | |
564 | ||
565 | class BadHash(object): | |
566 | fail = False | |
567 | def __hash__(self): | |
568 | if self.fail: | |
569 | raise Exc() | |
570 | else: | |
571 | return 42 | |
572 | ||
573 | d = self._empty_mapping() | |
574 | x = BadHash() | |
575 | d[x] = 42 | |
576 | x.fail = True | |
577 | self.assertRaises(Exc, d.__getitem__, x) | |
578 | ||
579 | def test_fromkeys(self): | |
580 | TestMappingProtocol.test_fromkeys(self) | |
581 | class mydict(self.type2test): | |
582 | def __new__(cls): | |
583 | return UserDict.UserDict() | |
584 | ud = mydict.fromkeys('ab') | |
585 | self.assertEqual(ud, {'a':None, 'b':None}) | |
586 | self.assert_(isinstance(ud, UserDict.UserDict)) | |
587 | ||
588 | def test_pop(self): | |
589 | TestMappingProtocol.test_pop(self) | |
590 | ||
591 | class Exc(Exception): pass | |
592 | ||
593 | class BadHash(object): | |
594 | fail = False | |
595 | def __hash__(self): | |
596 | if self.fail: | |
597 | raise Exc() | |
598 | else: | |
599 | return 42 | |
600 | ||
601 | d = self._empty_mapping() | |
602 | x = BadHash() | |
603 | d[x] = 42 | |
604 | x.fail = True | |
605 | self.assertRaises(Exc, d.pop, x) | |
606 | ||
607 | def test_mutatingiteration(self): | |
608 | d = self._empty_mapping() | |
609 | d[1] = 1 | |
610 | try: | |
611 | for i in d: | |
612 | d[i+1] = 1 | |
613 | except RuntimeError: | |
614 | pass | |
615 | else: | |
616 | self.fail("changing dict size during iteration doesn't raise Error") | |
617 | ||
618 | def test_repr(self): | |
619 | d = self._empty_mapping() | |
620 | self.assertEqual(repr(d), '{}') | |
621 | d[1] = 2 | |
622 | self.assertEqual(repr(d), '{1: 2}') | |
623 | d = self._empty_mapping() | |
624 | d[1] = d | |
625 | self.assertEqual(repr(d), '{1: {...}}') | |
626 | ||
627 | class Exc(Exception): pass | |
628 | ||
629 | class BadRepr(object): | |
630 | def __repr__(self): | |
631 | raise Exc() | |
632 | ||
633 | d = self._full_mapping({1: BadRepr()}) | |
634 | self.assertRaises(Exc, repr, d) | |
635 | ||
636 | def test_le(self): | |
637 | self.assert_(not (self._empty_mapping() < self._empty_mapping())) | |
638 | self.assert_(not (self._full_mapping({1: 2}) < self._full_mapping({1L: 2L}))) | |
639 | ||
640 | class Exc(Exception): pass | |
641 | ||
642 | class BadCmp(object): | |
643 | def __eq__(self, other): | |
644 | raise Exc() | |
645 | ||
646 | d1 = self._full_mapping({BadCmp(): 1}) | |
647 | d2 = self._full_mapping({1: 1}) | |
648 | try: | |
649 | d1 < d2 | |
650 | except Exc: | |
651 | pass | |
652 | else: | |
653 | self.fail("< didn't raise Exc") | |
654 | ||
655 | def test_setdefault(self): | |
656 | TestMappingProtocol.test_setdefault(self) | |
657 | ||
658 | class Exc(Exception): pass | |
659 | ||
660 | class BadHash(object): | |
661 | fail = False | |
662 | def __hash__(self): | |
663 | if self.fail: | |
664 | raise Exc() | |
665 | else: | |
666 | return 42 | |
667 | ||
668 | d = self._empty_mapping() | |
669 | x = BadHash() | |
670 | d[x] = 42 | |
671 | x.fail = True | |
672 | self.assertRaises(Exc, d.setdefault, x, []) |