1# -*- coding: utf-8 -*- 2""" 3Tests for the resurrected Py2-like class:`dict` type. 4""" 5 6from __future__ import absolute_import, unicode_literals, print_function 7import os 8import sys 9 10from future.utils import implements_iterator, PY3 11from future.tests.base import unittest, skip26 12from past.builtins import dict 13 14 15class TestOldDict(unittest.TestCase): 16 def setUp(self): 17 self.d1 = dict({'C': 1, 'B': 2, 'A': 3}) 18 self.d2 = dict(key1='value1', key2='value2') 19 20 def test_dict_empty(self): 21 """ 22 dict() -> {} 23 """ 24 self.assertEqual(dict(), {}) 25 26 def test_dict_eq(self): 27 d = self.d1 28 self.assertEqual(dict(d), d) 29 30 def test_dict_keys(self): 31 """ 32 The keys, values and items methods should now return lists on 33 Python 3.x. 34 """ 35 d = self.d1 36 self.assertEqual(set(dict(d)), set(d)) 37 self.assertEqual(set(dict(d).keys()), set(d.keys())) 38 keys = dict(d).keys() 39 assert isinstance(keys, list) 40 key0 = keys[0] 41 42 def test_dict_values(self): 43 d = self.d1 44 self.assertEqual(set(dict(d).values()), set(d.values())) 45 values = dict(d).values() 46 assert isinstance(values, list) 47 val0 = values[0] 48 49 def test_dict_items(self): 50 d = self.d1 51 self.assertEqual(set(dict(d).items()), set(d.items())) 52 items = dict(d).items() 53 assert isinstance(items, list) 54 item0 = items[0] 55 56 def test_isinstance_dict(self): 57 self.assertTrue(isinstance(self.d1, dict)) 58 59 def test_dict_getitem(self): 60 d = dict({'C': 1, 'B': 2, 'A': 3}) 61 self.assertEqual(d['C'], 1) 62 self.assertEqual(d['B'], 2) 63 self.assertEqual(d['A'], 3) 64 with self.assertRaises(KeyError): 65 self.assertEqual(d['D']) 66 67 def test_methods_produce_lists(self): 68 for d in (dict(self.d1), self.d2): 69 assert isinstance(d.keys(), list) 70 assert isinstance(d.values(), list) 71 assert isinstance(d.items(), list) 72 73 @unittest.skipIf(sys.version_info[:2] == (2, 6), 74 'set-like behaviour of dict methods is only available in Py2.7+') 75 def test_set_like_behaviour(self): 76 d1, d2 = self.d1, self.d2 77 self.assertEqual(dict(d1).viewkeys() & dict(d2).viewkeys(), set()) 78 self.assertEqual(dict(d1).viewkeys() | dict(d2).viewkeys(), 79 set(['key1', 'key2', 'C', 'B', 'A'])) 80 self.assertTrue(isinstance(d1.viewvalues() | d2.viewkeys(), set)) 81 self.assertTrue(isinstance(d1.viewitems() | d2.viewitems(), set)) 82 83 with self.assertRaises(TypeError): 84 d1.values() | d2.values() 85 d1.keys() | d2.keys() 86 d1.items() | d2.items() 87 88 def test_braces_create_newdict_object(self): 89 """ 90 It would nice if the {} dict syntax could be coaxed 91 into producing our new dict objects somehow ... 92 """ 93 d = self.d1 94 if False: # This doesn't work ... 95 self.assertTrue(type(d) == dict) 96 97 98# import UserDict 99import random, string 100import gc, weakref 101 102 103class Py2DictTest(unittest.TestCase): 104 """ 105 These are Py2/3-compatible ports of the unit tests from Python 2.7's 106 tests/test_dict.py 107 """ 108 109 def test_constructor(self): 110 # calling built-in types without argument must return empty 111 self.assertEqual(dict(), {}) 112 self.assertIsNot(dict(), {}) 113 114 @skip26 115 def test_literal_constructor(self): 116 # check literal constructor for different sized dicts 117 # (to exercise the BUILD_MAP oparg). 118 for n in (0, 1, 6, 256, 400): 119 items = [(''.join(random.sample(string.ascii_letters, 8)), i) 120 for i in range(n)] 121 random.shuffle(items) 122 formatted_items = ('{!r}: {:d}'.format(k, v) for k, v in items) 123 dictliteral = '{' + ', '.join(formatted_items) + '}' 124 self.assertEqual(eval(dictliteral), dict(items)) 125 126 def test_bool(self): 127 self.assertIs(not dict(), True) 128 self.assertTrue(dict({1: 2})) 129 self.assertIs(bool(dict({})), False) 130 self.assertIs(bool(dict({1: 2})), True) 131 132 def test_keys(self): 133 d = dict() 134 self.assertEqual(d.keys(), []) 135 d = dict({'a': 1, 'b': 2}) 136 k = d.keys() 137 self.assertTrue(d.has_key('a')) 138 self.assertTrue(d.has_key('b')) 139 140 self.assertRaises(TypeError, d.keys, None) 141 142 def test_values(self): 143 d = dict() 144 self.assertEqual(d.values(), []) 145 d = dict({1:2}) 146 self.assertEqual(d.values(), [2]) 147 148 self.assertRaises(TypeError, d.values, None) 149 150 def test_items(self): 151 d = dict() 152 self.assertEqual(d.items(), []) 153 154 d = dict({1:2}) 155 self.assertEqual(d.items(), [(1, 2)]) 156 157 self.assertRaises(TypeError, d.items, None) 158 159 def test_has_key(self): 160 d = dict() 161 self.assertFalse(d.has_key('a')) 162 d = dict({'a': 1, 'b': 2}) 163 k = d.keys() 164 k.sort() 165 self.assertEqual(k, ['a', 'b']) 166 167 self.assertRaises(TypeError, d.has_key) 168 169 def test_contains(self): 170 d = dict() 171 self.assertNotIn('a', d) 172 self.assertFalse('a' in d) 173 self.assertTrue('a' not in d) 174 d = dict({'a': 1, 'b': 2}) 175 self.assertIn('a', d) 176 self.assertIn('b', d) 177 self.assertNotIn('c', d) 178 179 self.assertRaises(TypeError, d.__contains__) 180 181 def test_len(self): 182 d = dict() 183 self.assertEqual(len(d), 0) 184 d = dict({'a': 1, 'b': 2}) 185 self.assertEqual(len(d), 2) 186 187 def test_getitem(self): 188 d = dict({'a': 1, 'b': 2}) 189 self.assertEqual(d['a'], 1) 190 self.assertEqual(d['b'], 2) 191 d['c'] = 3 192 d['a'] = 4 193 self.assertEqual(d['c'], 3) 194 self.assertEqual(d['a'], 4) 195 del d['b'] 196 self.assertEqual(d, dict({'a': 4, 'c': 3})) 197 198 self.assertRaises(TypeError, d.__getitem__) 199 200 class BadEq(object): 201 def __eq__(self, other): 202 raise Exc() 203 def __hash__(self): 204 return 24 205 206 d = dict() 207 d[BadEq()] = 42 208 self.assertRaises(KeyError, d.__getitem__, 23) 209 210 class Exc(Exception): pass 211 212 class BadHash(object): 213 fail = False 214 def __hash__(self): 215 if self.fail: 216 raise Exc() 217 else: 218 return 42 219 220 x = BadHash() 221 d[x] = 42 222 x.fail = True 223 self.assertRaises(Exc, d.__getitem__, x) 224 225 def test_clear(self): 226 d = dict({1:1, 2:2, 3:3}) 227 d.clear() 228 self.assertEqual(d, {}) 229 230 self.assertRaises(TypeError, d.clear, None) 231 232 def test_update(self): 233 d = dict() 234 d.update({1:100}) 235 d.update(dict({2:20})) 236 d.update({1:1, 2:2, 3:3}) 237 self.assertEqual(d, {1:1, 2:2, 3:3}) 238 239 d.update() 240 self.assertEqual(d, {1:1, 2:2, 3:3}) 241 242 self.assertRaises((TypeError, AttributeError), d.update, None) 243 244 class SimpleUserDict: 245 def __init__(self): 246 self.d = dict({1:1, 2:2, 3:3}) 247 def keys(self): 248 return self.d.keys() 249 def __getitem__(self, i): 250 return self.d[i] 251 d.clear() 252 d.update(SimpleUserDict()) 253 self.assertEqual(d, {1:1, 2:2, 3:3}) 254 255 class Exc(Exception): pass 256 257 d.clear() 258 class FailingUserDict: 259 def keys(self): 260 raise Exc 261 self.assertRaises(Exc, d.update, FailingUserDict()) 262 263 class FailingUserDict: 264 def keys(self): 265 @implements_iterator 266 class BogonIter: 267 def __init__(self): 268 self.i = 1 269 def __iter__(self): 270 return self 271 def __next__(self): 272 if self.i: 273 self.i = 0 274 return 'a' 275 raise Exc 276 return BogonIter() 277 def __getitem__(self, key): 278 return key 279 self.assertRaises(Exc, d.update, FailingUserDict()) 280 281 class FailingUserDict: 282 def keys(self): 283 @implements_iterator 284 class BogonIter: 285 def __init__(self): 286 self.i = ord('a') 287 def __iter__(self): 288 return self 289 def __next__(self): 290 if self.i <= ord('z'): 291 rtn = chr(self.i) 292 self.i += 1 293 return rtn 294 raise StopIteration 295 return BogonIter() 296 def __getitem__(self, key): 297 raise Exc 298 self.assertRaises(Exc, d.update, FailingUserDict()) 299 300 @implements_iterator 301 class badseq(object): 302 def __iter__(self): 303 return self 304 def __next__(self): 305 raise Exc() 306 307 self.assertRaises(Exc, {}.update, badseq()) 308 309 self.assertRaises(ValueError, {}.update, [(1, 2, 3)]) 310 311 def test_fromkeys(self): 312 self.assertEqual(dict.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) 313 d = dict() 314 self.assertIsNot(d.fromkeys('abc'), d) 315 self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) 316 self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0}) 317 self.assertEqual(d.fromkeys([]), {}) 318 def g(): 319 yield 1 320 self.assertEqual(d.fromkeys(g()), {1:None}) 321 self.assertRaises(TypeError, dict().fromkeys, 3) 322 class dictlike(dict): pass 323 self.assertEqual(dictlike.fromkeys('a'), {'a':None}) 324 self.assertEqual(dictlike().fromkeys('a'), {'a':None}) 325 self.assertIsInstance(dictlike.fromkeys('a'), dictlike) 326 self.assertIsInstance(dictlike().fromkeys('a'), dictlike) 327 # class mydict(dict): 328 # def __new__(cls): 329 # return UserDict.UserDict() 330 # ud = mydict.fromkeys('ab') 331 # self.assertEqual(ud, {'a':None, 'b':None}) 332 # self.assertIsInstance(ud, UserDict.UserDict) 333 # self.assertRaises(TypeError, dict.fromkeys) 334 335 class Exc(Exception): pass 336 337 class baddict1(dict): 338 def __init__(self): 339 raise Exc() 340 341 self.assertRaises(Exc, baddict1.fromkeys, [1]) 342 343 @implements_iterator 344 class BadSeq(object): 345 def __iter__(self): 346 return self 347 def __next__(self): 348 raise Exc() 349 350 self.assertRaises(Exc, dict.fromkeys, BadSeq()) 351 352 class baddict2(dict): 353 def __setitem__(self, key, value): 354 raise Exc() 355 356 self.assertRaises(Exc, baddict2.fromkeys, [1]) 357 358 # test fast path for dictionary inputs 359 d = dict(zip(range(6), range(6))) 360 self.assertEqual(dict.fromkeys(d, 0), dict(zip(range(6), [0]*6))) 361 362 class baddict3(dict): 363 def __new__(cls): 364 return d 365 d = dict((i, i) for i in range(10)) 366 res = d.copy() 367 res.update(a=None, b=None, c=None) 368 # Was: self.assertEqual(baddict3.fromkeys(set(["a", "b", "c"])), res) 369 # Infinite loop on Python 2.6 and 2.7 ... 370 371 def test_copy(self): 372 d = dict({1:1, 2:2, 3:3}) 373 self.assertEqual(d.copy(), {1:1, 2:2, 3:3}) 374 self.assertEqual({}.copy(), {}) 375 self.assertRaises(TypeError, d.copy, None) 376 377 def test_get(self): 378 d = dict() 379 self.assertIs(d.get('c'), None) 380 self.assertEqual(d.get('c', 3), 3) 381 d = dict({'a': 1, 'b': 2}) 382 self.assertIs(d.get('c'), None) 383 self.assertEqual(d.get('c', 3), 3) 384 self.assertEqual(d.get('a'), 1) 385 self.assertEqual(d.get('a', 3), 1) 386 self.assertRaises(TypeError, d.get) 387 self.assertRaises(TypeError, d.get, None, None, None) 388 389 @skip26 390 def test_setdefault(self): 391 # dict.setdefault() 392 d = dict() 393 self.assertIs(d.setdefault('key0'), None) 394 d.setdefault('key0', []) 395 self.assertIs(d.setdefault('key0'), None) 396 d.setdefault('key', []).append(3) 397 self.assertEqual(d['key'][0], 3) 398 d.setdefault('key', []).append(4) 399 self.assertEqual(len(d['key']), 2) 400 self.assertRaises(TypeError, d.setdefault) 401 402 class Exc(Exception): pass 403 404 class BadHash(object): 405 fail = False 406 def __hash__(self): 407 if self.fail: 408 raise Exc() 409 else: 410 return 42 411 412 x = BadHash() 413 d[x] = 42 414 x.fail = True 415 self.assertRaises(Exc, d.setdefault, x, []) 416 417 @skip26 418 def test_setdefault_atomic(self): 419 # Issue #13521: setdefault() calls __hash__ and __eq__ only once. 420 class Hashed(object): 421 def __init__(self): 422 self.hash_count = 0 423 self.eq_count = 0 424 def __hash__(self): 425 self.hash_count += 1 426 return 42 427 def __eq__(self, other): 428 self.eq_count += 1 429 return id(self) == id(other) 430 hashed1 = Hashed() 431 y = dict({hashed1: 5}) 432 hashed2 = Hashed() 433 y.setdefault(hashed2, []) 434 self.assertEqual(hashed1.hash_count, 1) 435 if PY3: 436 self.assertEqual(hashed2.hash_count, 1) 437 self.assertEqual(hashed1.eq_count + hashed2.eq_count, 1) 438 439 def test_popitem(self): 440 # dict.popitem() 441 for copymode in -1, +1: 442 # -1: b has same structure as a 443 # +1: b is a.copy() 444 for log2size in range(12): 445 size = 2**log2size 446 a = dict() 447 b = dict() 448 for i in range(size): 449 a[repr(i)] = i 450 if copymode < 0: 451 b[repr(i)] = i 452 if copymode > 0: 453 b = a.copy() 454 for i in range(size): 455 ka, va = ta = a.popitem() 456 self.assertEqual(va, int(ka)) 457 kb, vb = tb = b.popitem() 458 self.assertEqual(vb, int(kb)) 459 self.assertFalse(copymode < 0 and ta != tb) 460 self.assertFalse(a) 461 self.assertFalse(b) 462 463 d = dict() 464 self.assertRaises(KeyError, d.popitem) 465 466 def test_pop(self): 467 # Tests for pop with specified key 468 d = dict() 469 k, v = 'abc', 'def' 470 d[k] = v 471 self.assertRaises(KeyError, d.pop, 'ghi') 472 473 self.assertEqual(d.pop(k), v) 474 self.assertEqual(len(d), 0) 475 476 self.assertRaises(KeyError, d.pop, k) 477 478 self.assertEqual(d.pop(k, v), v) 479 d[k] = v 480 self.assertEqual(d.pop(k, 1), v) 481 482 self.assertRaises(TypeError, d.pop) 483 484 class Exc(Exception): pass 485 486 class BadHash(object): 487 fail = False 488 def __hash__(self): 489 if self.fail: 490 raise Exc() 491 else: 492 return 42 493 494 x = BadHash() 495 d[x] = 42 496 x.fail = True 497 self.assertRaises(Exc, d.pop, x) 498 499 def test_mutatingiteration(self): 500 # changing dict size during iteration 501 d = dict() 502 d[1] = 1 503 with self.assertRaises(RuntimeError): 504 for i in d: 505 d[i+1] = 1 506 507 def test_repr(self): 508 d = dict() 509 self.assertEqual(repr(d), '{}') 510 d[1] = 2 511 self.assertEqual(repr(d), '{1: 2}') 512 d = dict() 513 d[1] = d 514 self.assertEqual(repr(d), '{1: {...}}') 515 516 class Exc(Exception): pass 517 518 class BadRepr(object): 519 def __repr__(self): 520 raise Exc() 521 522 d = dict({1: BadRepr()}) 523 self.assertRaises(Exc, repr, d) 524 525 @unittest.skip('Comparing dicts for order has not been forward-ported') 526 def test_le(self): 527 self.assertFalse(dict() < {}) 528 self.assertFalse(dict() < dict()) 529 self.assertFalse(dict({1: 2}) < {1: 2}) 530 531 class Exc(Exception): pass 532 533 class BadCmp(object): 534 def __eq__(self, other): 535 raise Exc() 536 def __hash__(self): 537 return 42 538 539 d1 = dict({BadCmp(): 1}) 540 d2 = dict({1: 1}) 541 542 with self.assertRaises(Exc): 543 d1 < d2 544 545 @skip26 546 def test_missing(self): 547 # Make sure dict doesn't have a __missing__ method 548 self.assertFalse(hasattr(dict, "__missing__")) 549 self.assertFalse(hasattr(dict(), "__missing__")) 550 # Test several cases: 551 # (D) subclass defines __missing__ method returning a value 552 # (E) subclass defines __missing__ method raising RuntimeError 553 # (F) subclass sets __missing__ instance variable (no effect) 554 # (G) subclass doesn't define __missing__ at a all 555 class D(dict): 556 def __missing__(self, key): 557 return 42 558 d = D({1: 2, 3: 4}) 559 self.assertEqual(d[1], 2) 560 self.assertEqual(d[3], 4) 561 self.assertNotIn(2, d) 562 self.assertNotIn(2, d.keys()) 563 self.assertEqual(d[2], 42) 564 565 class E(dict): 566 def __missing__(self, key): 567 raise RuntimeError(key) 568 e = E() 569 with self.assertRaises(RuntimeError) as c: 570 e[42] 571 self.assertEqual(c.exception.args, (42,)) 572 573 class F(dict): 574 def __init__(self): 575 # An instance variable __missing__ should have no effect 576 self.__missing__ = lambda key: None 577 f = F() 578 with self.assertRaises(KeyError) as c: 579 f[42] 580 self.assertEqual(c.exception.args, (42,)) 581 582 class G(dict): 583 pass 584 g = G() 585 with self.assertRaises(KeyError) as c: 586 g[42] 587 self.assertEqual(c.exception.args, (42,)) 588 589 @skip26 590 def test_tuple_keyerror(self): 591 # SF #1576657 592 d = dict() 593 with self.assertRaises(KeyError) as c: 594 d[(1,)] 595 self.assertEqual(c.exception.args, ((1,),)) 596 597 # def test_bad_key(self): 598 # # Dictionary lookups should fail if __cmp__() raises an exception. 599 # class CustomException(Exception): 600 # pass 601 602 # class BadDictKey: 603 # def __hash__(self): 604 # return hash(self.__class__) 605 606 # def __cmp__(self, other): 607 # if isinstance(other, self.__class__): 608 # raise CustomException 609 # return other 610 611 # d = dict() 612 # x1 = BadDictKey() 613 # x2 = BadDictKey() 614 # d[x1] = 1 615 # for stmt in ['d[x2] = 2', 616 # 'z = d[x2]', 617 # 'x2 in d', 618 # 'd.has_key(x2)', 619 # 'd.get(x2)', 620 # 'd.setdefault(x2, 42)', 621 # 'd.pop(x2)', 622 # 'd.update({x2: 2})']: 623 # with self.assertRaises(CustomException): 624 # utils.exec_(stmt, locals()) 625 # 626 # def test_resize1(self): 627 # # Dict resizing bug, found by Jack Jansen in 2.2 CVS development. 628 # # This version got an assert failure in debug build, infinite loop in 629 # # release build. Unfortunately, provoking this kind of stuff requires 630 # # a mix of inserts and deletes hitting exactly the right hash codes in 631 # # exactly the right order, and I can't think of a randomized approach 632 # # that would be *likely* to hit a failing case in reasonable time. 633 634 # d = {} 635 # for i in range(5): 636 # d[i] = i 637 # for i in range(5): 638 # del d[i] 639 # for i in range(5, 9): # i==8 was the problem 640 # d[i] = i 641 642 # def test_resize2(self): 643 # # Another dict resizing bug (SF bug #1456209). 644 # # This caused Segmentation faults or Illegal instructions. 645 646 # class X(object): 647 # def __hash__(self): 648 # return 5 649 # def __eq__(self, other): 650 # if resizing: 651 # d.clear() 652 # return False 653 # d = {} 654 # resizing = False 655 # d[X()] = 1 656 # d[X()] = 2 657 # d[X()] = 3 658 # d[X()] = 4 659 # d[X()] = 5 660 # # now trigger a resize 661 # resizing = True 662 # d[9] = 6 663 664 # def test_empty_presized_dict_in_freelist(self): 665 # # Bug #3537: if an empty but presized dict with a size larger 666 # # than 7 was in the freelist, it triggered an assertion failure 667 # with self.assertRaises(ZeroDivisionError): 668 # d = {'a': 1 // 0, 'b': None, 'c': None, 'd': None, 'e': None, 669 # 'f': None, 'g': None, 'h': None} 670 # d = {} 671 672 # def test_container_iterator(self): 673 # # Bug #3680: tp_traverse was not implemented for dictiter objects 674 # class C(object): 675 # pass 676 # iterators = (dict.iteritems, dict.itervalues, dict.iterkeys) 677 # for i in iterators: 678 # obj = C() 679 # ref = weakref.ref(obj) 680 # container = {obj: 1} 681 # obj.x = i(container) 682 # del obj, container 683 # gc.collect() 684 # self.assertIs(ref(), None, "Cycle was not collected") 685 686 # def _not_tracked(self, t): 687 # # Nested containers can take several collections to untrack 688 # gc.collect() 689 # gc.collect() 690 # self.assertFalse(gc.is_tracked(t), t) 691 692 # def _tracked(self, t): 693 # self.assertTrue(gc.is_tracked(t), t) 694 # gc.collect() 695 # gc.collect() 696 # self.assertTrue(gc.is_tracked(t), t) 697 698 # @test_support.cpython_only 699 # def test_track_literals(self): 700 # # Test GC-optimization of dict literals 701 # x, y, z, w = 1.5, "a", (1, None), [] 702 703 # self._not_tracked({}) 704 # self._not_tracked({x:(), y:x, z:1}) 705 # self._not_tracked({1: "a", "b": 2}) 706 # self._not_tracked({1: 2, (None, True, False, ()): int}) 707 # self._not_tracked({1: object()}) 708 709 # # Dicts with mutable elements are always tracked, even if those 710 # # elements are not tracked right now. 711 # self._tracked({1: []}) 712 # self._tracked({1: ([],)}) 713 # self._tracked({1: {}}) 714 # self._tracked({1: set()}) 715 716 # @test_support.cpython_only 717 # def test_track_dynamic(self): 718 # # Test GC-optimization of dynamically-created dicts 719 # class MyObject(object): 720 # pass 721 # x, y, z, w, o = 1.5, "a", (1, object()), [], MyObject() 722 723 # d = dict() 724 # self._not_tracked(d) 725 # d[1] = "a" 726 # self._not_tracked(d) 727 # d[y] = 2 728 # self._not_tracked(d) 729 # d[z] = 3 730 # self._not_tracked(d) 731 # self._not_tracked(d.copy()) 732 # d[4] = w 733 # self._tracked(d) 734 # self._tracked(d.copy()) 735 # d[4] = None 736 # self._not_tracked(d) 737 # self._not_tracked(d.copy()) 738 739 # # dd isn't tracked right now, but it may mutate and therefore d 740 # # which contains it must be tracked. 741 # d = dict() 742 # dd = dict() 743 # d[1] = dd 744 # self._not_tracked(dd) 745 # self._tracked(d) 746 # dd[1] = d 747 # self._tracked(dd) 748 749 # d = dict.fromkeys([x, y, z]) 750 # self._not_tracked(d) 751 # dd = dict() 752 # dd.update(d) 753 # self._not_tracked(dd) 754 # d = dict.fromkeys([x, y, z, o]) 755 # self._tracked(d) 756 # dd = dict() 757 # dd.update(d) 758 # self._tracked(dd) 759 760 # d = dict(x=x, y=y, z=z) 761 # self._not_tracked(d) 762 # d = dict(x=x, y=y, z=z, w=w) 763 # self._tracked(d) 764 # d = dict() 765 # d.update(x=x, y=y, z=z) 766 # self._not_tracked(d) 767 # d.update(w=w) 768 # self._tracked(d) 769 770 # d = dict([(x, y), (z, 1)]) 771 # self._not_tracked(d) 772 # d = dict([(x, y), (z, w)]) 773 # self._tracked(d) 774 # d = dict() 775 # d.update([(x, y), (z, 1)]) 776 # self._not_tracked(d) 777 # d.update([(x, y), (z, w)]) 778 # self._tracked(d) 779 780 # @test_support.cpython_only 781 # def test_track_subtypes(self): 782 # # Dict subtypes are always tracked 783 # class MyDict(dict): 784 # pass 785 # self._tracked(MyDict()) 786 787 788if __name__ == '__main__': 789 # Only run these tests on Python 3 ... 790 if PY3: 791 unittest.main() 792