Skip to content

Commit 3595cf8

Browse files
committed
gh-161524: Simplify sparse dict copy tests
1 parent eea9266 commit 3595cf8

2 files changed

Lines changed: 32 additions & 182 deletions

File tree

‎Lib/test/test_capi/test_watchers.py‎

Lines changed: 10 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -56,31 +56,16 @@ def test_set_existing_item(self):
5656
self.assert_events(["mod:foo:baz"])
5757

5858
def test_clone(self):
59-
d = {}
60-
d2 = {"foo": "bar"}
61-
with self.watcher() as wid:
62-
self.watch(wid, d)
63-
d.update(d2)
64-
self.assert_events(["clone"])
65-
66-
def test_clone_sparse_dict(self):
67-
for keys in (list(range(200)), [f"key{i}" for i in range(200)]):
68-
for remaining in (1, 20):
69-
with self.subTest(key_type=type(keys[0]),
70-
remaining=remaining):
71-
source = {key: key for key in keys}
72-
for key in keys[:200 - remaining]:
73-
del source[key]
74-
75-
target = {}
76-
with self.watcher() as wid:
77-
self.watch(wid, target)
78-
target.update(source)
79-
self.assert_events(["clone"])
80-
81-
self.assertEqual(list(target.items()), list(source.items()))
82-
source.clear()
83-
self.assertEqual(len(target), remaining)
59+
sparse = {str(i): i for i in range(100)}
60+
for i in range(99):
61+
del sparse[str(i)]
62+
for d2 in ({"foo": "bar"}, sparse):
63+
d = {}
64+
with self.watcher() as wid:
65+
self.watch(wid, d)
66+
d.update(d2)
67+
self.assert_events(["clone"])
68+
self.assertEqual(d, d2)
8469

8570
def test_no_event_if_not_watched(self):
8671
d = {}

‎Lib/test/test_dict.py‎

Lines changed: 22 additions & 157 deletions
Original file line numberDiff line numberDiff line change
@@ -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

Comments
 (0)