@@ -86,6 +86,7 @@ def test_bool(self):
8686 self .assertIs (bool ({}), False )
8787 self .assertIs (bool ({1 : 2 }), True )
8888
89+
8990 def test_keys (self ):
9091 d = {}
9192 self .assertEqual (set (d .keys ()), set ())
@@ -466,17 +467,153 @@ class A:
466467
467468 def test_copy_noncompact (self ):
468469 # Dicts don't compact themselves on del/pop operations.
469- # Copy will use a slow merging strategy that produces
470- # a compacted copy when roughly 33% of dict is a non-used
471- # keys-space (to optimize memory footprint).
472- # In this test we want to hit the slow/compacting
473- # branch of dict.copy() and make sure it works OK.
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.
474474 d = {k : k for k in range (1000 )}
475- for k in range (950 ):
475+ for k in range (999 ):
476476 del d [k ]
477477 d2 = d .copy ()
478478 self .assertEqual (d2 , d )
479479
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
546+
547+ def __hash__ (self ):
548+ 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 ]
611+
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 )
616+
480617 @support .nomemtest
481618 def test_copy_empty_no_memory (self ):
482619 import _testcapi
@@ -1972,6 +2109,19 @@ def keys(self):
19722109 self .assertEqual (type (d2 ), frozendict )
19732110 self .assertEqual (list (d2 .items ()), pairs [::- 1 ])
19742111
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+
19752125 def test_merge (self ):
19762126 # test "a | b" operator
19772127 self .assertEqual (frozendict (x = 1 ) | frozendict (y = 2 ),
0 commit comments