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