test: Hasher tested with Hypothesis

nedbat · nedbat · commit fc7361fe4b67 · 2025-12-20T09:52:57.000-05:00
diff --git a/metacov.ini b/metacov.ini
@@ -78,6 +78,9 @@ exclude_lines =
     # Exclude an entire file.
     \A(?s:.*# pragma: exclude file from coverage.*)\Z
 
+    # Ad-hoc running code.
+    ^if __name__ == "__main__":
+
 partial_branches =
     pragma: part covered
     # A for-loop that always hits its break statement
diff --git a/tests/strategies.py b/tests/strategies.py
@@ -0,0 +1,62 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://github.com/coveragepy/coveragepy/blob/main/NOTICE.txt
+
+"""Hypothesis strategies for use in tests."""
+
+from __future__ import annotations
+
+from hypothesis import strategies as st
+
+
+# Leaf types, all hashable. Some are limited to the kinds of values coverage
+# deals with, to focus Hypothesis.
+hashable_leaves = [
+    st.none(),
+    st.booleans(),
+    st.integers(min_value=-1000, max_value=10_000_000),
+    st.floats(min_value=-100, max_value=100, allow_nan=False, allow_infinity=False).map(
+        lambda x: 0.0 if x == 0.0 else x
+    ),
+    st.text(max_size=10),
+    st.binary(max_size=10),
+]
+
+
+def tuples_of(strat: st.SearchStrategy) -> st.SearchStrategy:
+    """Make a strategy for tuples of some other strategy."""
+    return st.lists(strat, max_size=3).map(tuple)
+
+
+# List of strategies that produce hashable data.
+hashable = hashable_leaves + [tuples_of(s) for s in hashable_leaves]
+
+
+def nested_dicts_of(s: st.SearchStrategy) -> st.SearchStrategy:
+    """Make a strategy to produce recursive dicts with leaves from the `s` strategy."""
+    return st.recursive(
+        s,
+        lambda children: st.dictionaries(st.text(max_size=10), children, max_size=3),
+        max_leaves=10,
+    )
+
+
+# Schema: a strategy that generates strategies for nested data.
+nested_data_schemas = st.recursive(
+    st.sampled_from(hashable),
+    lambda children: st.one_of(
+        children.map(lambda s: st.lists(s, max_size=5)),
+        children.map(tuples_of),
+        st.sampled_from(hashable).map(lambda s: st.sets(s, max_size=10)),
+        children.map(nested_dicts_of),
+    ),
+    max_leaves=3,
+)
+
+if __name__ == "__main__":
+    import warnings
+    from hypothesis.errors import NonInteractiveExampleWarning
+
+    warnings.filterwarnings("ignore", category=NonInteractiveExampleWarning)
+
+    for _ in range(50):
+        print(repr(nested_data_schemas.example().example()))
diff --git a/tests/test_misc.py b/tests/test_misc.py
@@ -9,13 +9,15 @@
 from unittest import mock
 
 import pytest
+from hypothesis import given, strategies as st
 
 from coverage.exceptions import CoverageException
 from coverage.misc import file_be_gone
 from coverage.misc import Hasher, substitute_variables, import_third_party
 from coverage.misc import human_sorted, human_sorted_items, stdout_link
 
 from tests.coveragetest import CoverageTest
+from tests.strategies import nested_data_schemas
 
 
 class HasherTest(CoverageTest):
@@ -87,6 +89,22 @@ def test_set_hashing(self) -> None:
         assert h1.digest() == h2.digest()
         assert h1.digest() != h3.digest()
 
+    # Use nested_data_schema to generate data schemas, then use it twice in
+    # the test to get two chunks of data with the "same shape" but different
+    # data.
+    @given(nested_data_schemas.flatmap(lambda s: st.tuples(s, s)))
+    def test_same_schema(self, pair: tuple[st.SearchStrategy, st.SearchStrategy]) -> None:
+        data1, data2 = pair
+        h1, h2 = Hasher(), Hasher()
+        h1.update(data1)
+        h2.update(data2)
+        if data1 == data2:
+            assert h1.hexdigest() == h2.hexdigest()
+            assert h1.digest() == h2.digest()
+        else:
+            assert h1.hexdigest() != h2.hexdigest()
+            assert h1.digest() != h2.digest()
+
 
 class RemoveFileTest(CoverageTest):
     """Tests of misc.file_be_gone."""
