@@ -86,7 +86,6 @@ def test_bool(self):
8686 self .assertIs (bool ({}), False )
8787 self .assertIs (bool ({1 : 2 }), True )
8888
89-
9089 def test_keys (self ):
9190 d = {}
9291 self .assertEqual (set (d .keys ()), set ())
@@ -466,153 +465,32 @@ class A:
466465 self .assertEqual (gc .is_tracked (d ), gc .is_tracked (d2 ))
467466
468467 def test_copy_noncompact (self ):
469- # Dicts don't compact themselves on del/pop operations.
470- # Copy used to take a slow merging path when about a third
471- # of the entries were deleted. The compact clone now skips
472- # deleted entries directly, even when very few keys remain.
473- # Check that an almost emptied dict is copied and compacted.
474- d = {k : k for k in range (1000 )}
475- for k in range (999 ):
476- del d [k ]
477- d2 = d .copy ()
478- self .assertEqual (d2 , d )
479-
480- def test_sparse_dict_copy (self ):
481- for keys in ([f'key{ i } ' for i in range (120 )], list (range (120 ))):
482- for remaining in (0 , 1 , 10 , 40 , 80 , 119 , 120 ):
483- with self .subTest (key_type = type (keys [0 ]), remaining = remaining ):
484- source = {key : object () for key in keys }
485- for key in keys [:120 - remaining ]:
486- del source [key ]
487-
488- expected = list (source .items ())
489- for result in (source .copy (), dict (source ), {** source }):
490- self .assertIsNot (result , source )
491- self .assertEqual (list (result .items ()), expected )
492- for (_ , value ), (_ , copied ) in zip (
493- expected , result .items ()):
494- self .assertIs (copied , value )
495- result .clear ()
496- self .assertEqual (list (source .items ()), expected )
497-
498- def test_sparse_dict_copy_deletion_patterns (self ):
499- from random import Random
500-
501- for key_type in (str , int ):
502- keys = [key_type (i ) for i in range (1000 )]
503- for remaining in (1 , 15 , 100 , 500 ):
504- for pattern in ("front" , "back" , "middle" , "random" ):
505- with self .subTest (key_type = key_type , remaining = remaining ,
506- pattern = pattern ):
507- if pattern == "front" :
508- deleted = keys [:1000 - remaining ]
509- elif pattern == "back" :
510- deleted = keys [remaining :]
511- elif pattern == "middle" :
512- start = remaining // 2
513- deleted = keys [start :start + 1000 - remaining ]
514- else :
515- deleted = keys .copy ()
516- Random (161524 ).shuffle (deleted )
517- deleted = deleted [:1000 - remaining ]
518-
519- source = dict .fromkeys (keys , object ())
520- for key in deleted :
521- del source [key ]
522- expected = list (source .items ())
523- for copy in (source .copy (), dict (source ), {** source }):
524- self .assertEqual (list (copy .items ()), expected )
525- self .assertEqual (len (copy ), remaining )
526- copy .clear ()
527- self .assertEqual (list (source .items ()), expected )
528-
529- def test_sparse_dict_copy_reinserted_keys (self ):
530- for keys in ([f'key{ i } ' for i in range (120 )], list (range (120 ))):
531- source = {key : object () for key in keys }
532- for key in keys [:100 ]:
533- del source [key ]
534- for key in keys [:5 ]:
535- source [key ] = object ()
536-
537- expected = list (source .items ())
538- for result in (source .copy (), dict (source ), {** source }):
539- self .assertEqual (list (result .items ()), expected )
540-
541- def test_sparse_dict_copy_does_not_rehash (self ):
542- class Key :
543- def __init__ (self , value ):
544- self .value = value
545- self .hash_calls = 0
468+ # Dicts don't compact themselves on del/pop operations. Check
469+ # copying a sparse table with both unicode and generic keys.
470+ class Key (CustomHash ):
471+ hash_calls = 0
546472
547473 def __hash__ (self ):
548474 self .hash_calls += 1
549- return self .value % 5
550-
551- def __eq__ (self , other ):
552- return self is other
553-
554- keys = [Key (i ) for i in range (90 )]
555- source = {key : key .value for key in keys }
556- for key in keys [:70 ]:
557- del source [key ]
558- calls = [key .hash_calls for key in keys ]
559- expected = list (source .items ())
560- for result in (source .copy (), dict (source ), {** source }):
561- self .assertEqual ([key .hash_calls for key in keys ], calls )
562- for (key , value ), (copy_key , copy_value ) in zip (
563- expected , result .items ()):
564- self .assertIs (copy_key , key )
565- self .assertEqual (copy_value , value )
566-
567- def test_sparse_dict_copy_releases_references (self ):
568- class Key :
569- pass
570-
571- class Value :
572- pass
573-
574- key = Key ()
575- value = Value ()
576- source = {i : None for i in range (150 )}
577- source [key ] = value
578- for i in range (150 ):
579- del source [i ]
580-
581- key_ref = weakref .ref (key )
582- value_ref = weakref .ref (value )
583- copies = [source .copy (), dict (source ), {** source }]
584- del source , key , value
585-
586- self .assertIsNotNone (key_ref ())
587- self .assertIsNotNone (value_ref ())
588- copies .clear ()
589- gc .collect ()
590- self .assertIsNone (key_ref ())
591- self .assertIsNone (value_ref ())
592-
593- def test_sparse_dict_copy_density (self ):
594- for key_type in (str , int ):
595- for remaining in (1 , 10 , 14 , 15 , 16 , 17 , 30 , 31 , 32 , 33 , 500 ):
596- with self .subTest (key_type = key_type , remaining = remaining ):
597- d = {key_type (i ): i for i in range (1000 )}
598- for i in range (1000 - remaining ):
599- del d [key_type (i )]
600- expected = list (d .items ())
601- for copy in (d .copy (), dict (d ), {** d }):
602- self .assertEqual (list (copy .items ()), expected )
603-
604- @support .nomemtest
605- def test_sparse_dict_copy_no_memory (self ):
606- import _testcapi
607-
608- d = dict .fromkeys (range (128 ))
609- for i in range (96 ):
610- del d [i ]
475+ return super ().__hash__ ()
611476
612- for copy in (d .copy , lambda : dict (d ), lambda : {** d }):
613- with self .subTest (copy = copy ):
614- with self .assertRaises (MemoryError ):
615- _testcapi .call_with_nomemory (0 , 0 , copy )
477+ for keys in ([str (i ) for i in range (100 )],
478+ [Key (i % 5 ) for i in range (100 )]):
479+ with self .subTest (key_type = type (keys [0 ])):
480+ d = dict (zip (keys , range (100 )))
481+ for i , key in enumerate (keys ):
482+ if i not in (1 , 50 , 98 ):
483+ del d [key ]
484+ expected = list (d .items ())
485+ if isinstance (keys [0 ], Key ):
486+ calls = [key .hash_calls for key in d ]
487+ copies = (d .copy (), dict (d ), {** d }, frozendict (d ))
488+ if isinstance (keys [0 ], Key ):
489+ self .assertEqual ([key .hash_calls for key in d ], calls )
490+ for copy in copies :
491+ self .assertEqual (list (copy .items ()), expected )
492+ for key , value in expected :
493+ self .assertEqual (copy [key ], value )
616494
617495 @support .nomemtest
618496 def test_copy_empty_no_memory (self ):
@@ -2109,19 +1987,6 @@ def keys(self):
21091987 self .assertEqual (type (d2 ), frozendict )
21101988 self .assertEqual (list (d2 .items ()), pairs [::- 1 ])
21111989
2112- def test_copy_from_sparse_dict (self ):
2113- for keys in ([f'key{ i } ' for i in range (1000 )], list (range (1000 ))):
2114- source = {key : key for key in keys }
2115- for key in keys [:700 ]:
2116- del source [key ]
2117-
2118- expected = list (source .items ())
2119- d = frozendict (source )
2120- self .assertEqual (list (d .items ()), expected )
2121- self .assertEqual (list (d .copy ().items ()), expected )
2122- self .assertEqual (list (dict (d ).items ()), expected )
2123- self .assertEqual (list (FrozenDict (d ).copy ().items ()), expected )
2124-
21251990 def test_merge (self ):
21261991 # test "a | b" operator
21271992 self .assertEqual (frozendict (x = 1 ) | frozendict (y = 2 ),
0 commit comments