test: Hasher tested with Hypothesis

nedbat · nedbat · commit 0a255b8ef1e9 · 2025-12-19T10:19:34.000-05:00
diff --git a/tests/test_misc.py b/tests/test_misc.py
@@ -9,6 +9,7 @@
 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
@@ -17,6 +18,68 @@
 
 from tests.coveragetest import CoverageTest
 
+# Hypothesis for testing Hasher
+
+
+# Leaf types (all hashable, usable in sets)
+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)
+
+
+hashable_types = hashable_leaves + [tuples_of(s) for s in hashable_leaves]
+
+leaf_strategies = st.sampled_from(hashable_types)
+
+
+def recur_dicts(s: st.SearchStrategy) -> st.SearchStrategy:
+    """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
+schema = st.recursive(
+    leaf_strategies,
+    lambda children: st.one_of(
+        children.map(lambda s: st.lists(s, max_size=5)),
+        children.map(lambda s: st.lists(s, max_size=5).map(tuple)),
+        st.sampled_from(hashable_types).map(lambda s: st.sets(s, max_size=10)),
+        st.sampled_from(hashable_types).map(recur_dicts),
+    ),
+    max_leaves=3,
+)
+
+# For ad-hoc testing, you can see data generated like this:
+#
+#    import warnings
+#    from hypothesis.errors import NonInteractiveExampleWarning
+#    from tests.test_misc import schema, recur_dicts
+#
+#    warnings.filterwarnings("ignore", category=NonInteractiveExampleWarning)
+#
+#    for _ in range(50):
+#        print(repr(schema.example().example()))
+
+
+# Two instances with the same schema
+paired_data = schema.flatmap(lambda s: st.tuples(s, s))
+
 
 class HasherTest(CoverageTest):
     """Test our wrapper of fingerprint hashing."""
@@ -87,6 +150,19 @@ def test_set_hashing(self) -> None:
         assert h1.digest() == h2.digest()
         assert h1.digest() != h3.digest()
 
+    @given(paired_data)
+    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."""
