Lib/test/mapping_tests.py

   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             def __hash__(self):
 561                 return 24
 562
 563         d = self._empty_mapping()
 564         d[BadEq()] = 42
 565         self.assertRaises(KeyError, d.__getitem__, 23)
 566
 567         class BadHash(object):
 568             fail = False
 569             def __hash__(self):
 570                 if self.fail:
 571                     raise Exc()
 572                 else:
 573                     return 42
 574
 575         d = self._empty_mapping()
 576         x = BadHash()
 577         d[x] = 42
 578         x.fail = True
 579         self.assertRaises(Exc, d.__getitem__, x)
 580
 581     def test_fromkeys(self):
 582         TestMappingProtocol.test_fromkeys(self)
 583         class mydict(self.type2test):
 584             def __new__(cls):
 585                 return UserDict.UserDict()
 586         ud = mydict.fromkeys('ab')
 587         self.assertEqual(ud, {'a':None, 'b':None})
 588         self.assert_(isinstance(ud, UserDict.UserDict))
 589
 590     def test_pop(self):
 591         TestMappingProtocol.test_pop(self)
 592
 593         class Exc(Exception): pass
 594
 595         class BadHash(object):
 596             fail = False
 597             def __hash__(self):
 598                 if self.fail:
 599                     raise Exc()
 600                 else:
 601                     return 42
 602
 603         d = self._empty_mapping()
 604         x = BadHash()
 605         d[x] = 42
 606         x.fail = True
 607         self.assertRaises(Exc, d.pop, x)
 608
 609     def test_mutatingiteration(self):
 610         d = self._empty_mapping()
 611         d[1] = 1
 612         try:
 613             for i in d:
 614                 d[i+1] = 1
 615         except RuntimeError:
 616             pass
 617         else:
 618             self.fail("changing dict size during iteration doesn't raise Error")
 619
 620     def test_repr(self):
 621         d = self._empty_mapping()
 622         self.assertEqual(repr(d), '{}')
 623         d[1] = 2
 624         self.assertEqual(repr(d), '{1: 2}')
 625         d = self._empty_mapping()
 626         d[1] = d
 627         self.assertEqual(repr(d), '{1: {...}}')
 628
 629         class Exc(Exception): pass
 630
 631         class BadRepr(object):
 632             def __repr__(self):
 633                 raise Exc()
 634
 635         d = self._full_mapping({1: BadRepr()})
 636         self.assertRaises(Exc, repr, d)
 637
 638     def test_le(self):
 639         self.assert_(not (self._empty_mapping() < self._empty_mapping()))
 640         self.assert_(not (self._full_mapping({1: 2}) < self._full_mapping({1L: 2L})))
 641
 642         class Exc(Exception): pass
 643
 644         class BadCmp(object):
 645             def __eq__(self, other):
 646                 raise Exc()
 647             def __hash__(self):
 648                 return 42
 649
 650         d1 = self._full_mapping({BadCmp(): 1})
 651         d2 = self._full_mapping({1: 1})
 652         try:
 653             d1 < d2
 654         except Exc:
 655             pass
 656         else:
 657             self.fail("< didn't raise Exc")
 658
 659     def test_setdefault(self):
 660         TestMappingProtocol.test_setdefault(self)
 661
 662         class Exc(Exception): pass
 663
 664         class BadHash(object):
 665             fail = False
 666             def __hash__(self):
 667                 if self.fail:
 668                     raise Exc()
 669                 else:
 670                     return 42
 671
 672         d = self._empty_mapping()
 673         x = BadHash()
 674         d[x] = 42
 675         x.fail = True
 676         self.assertRaises(Exc, d.setdefault, x, [])