Allow simultaneously lowering two nearby blocks

Author: DRMacIver

hypothesis-python/RELEASE.rst

@@ -0,0 +1,5 @@
+RELEASE_TYPE: patch
+
+This release improves the quality of shrunk test cases in some special cases.
+Specifically, it should get shrinking unstuck in some scenarios which require
+simultaneously changing two parts of the generated test case.

hypothesis-python/src/hypothesis/internal/conjecture/shrinker.py

@@ -508,6 +508,7 @@ def greedy_shrink(self):
                 "minimize_individual_blocks",
                 block_program("--X"),
                 "redistribute_block_pairs",
+                "lower_blocks_together",
             ]
         )
 
@@ -1222,14 +1223,47 @@ def boost(k):
             attempt[block.start : block.end] = int_to_bytes(m - k, block.length)
             try:
                 attempt[next_block.start : next_block.end] = int_to_bytes(
-                    n + k, block.length
+                    n + k, next_block.length
                 )
             except OverflowError:
                 return False
             return self.consider_new_buffer(attempt)
 
         find_integer(boost)
 
+    @defines_shrink_pass()
+    def lower_blocks_together(self, chooser):
+        block = chooser.choose(self.blocks, lambda b: not b.all_zero)
+
+        # Choose the next block to be up to eight blocks onwards. We don't
+        # want to go too far (to avoid quadratic time) but it's worth a
+        # reasonable amount of lookahead, especially as we expect most
+        # blocks are zero by this point anyway.
+        next_block = self.blocks[
+            chooser.choose(
+                range(block.index + 1, min(len(self.blocks), block.index + 9)),
+                lambda j: not self.blocks[j].all_zero,
+            )
+        ]
+
+        buffer = self.buffer
+
+        m = int_from_bytes(buffer[block.start : block.end])
+        n = int_from_bytes(buffer[next_block.start : next_block.end])
+
+        def lower(k):
+            if k > min(m, n):
+                return False
+            attempt = bytearray(buffer)
+            attempt[block.start : block.end] = int_to_bytes(m - k, block.length)
+            attempt[next_block.start : next_block.end] = int_to_bytes(
+                n - k, next_block.length
+            )
+            assert len(attempt) == len(buffer)
+            return self.consider_new_buffer(attempt)
+
+        find_integer(lower)
+
     @defines_shrink_pass()
     def minimize_individual_blocks(self, chooser):
         """Attempt to minimize each block in sequence.

hypothesis-python/tests/conjecture/test_shrinker.py

@@ -616,3 +616,23 @@ def shrinker(data):
         shrinker.fixate_shrink_passes(passes)
 
     assert shrinker.shrink_pass(passes[-1]).calls > 0
+
+
+@pytest.mark.parametrize("n_gap", [0, 1, 2, 3])
+def test_can_simultaneously_lower_non_duplicated_nearby_blocks(n_gap):
+    @shrinking_from([1, 1] + [0] * n_gap + [0, 2])
+    def shrinker(data):
+        # Block off lowering the whole buffer
+        if data.draw_bits(1) == 0:
+            data.mark_invalid()
+        m = data.draw_bits(8)
+        for _ in range(n_gap):
+            data.draw_bits(8)
+        n = data.draw_bits(16)
+
+        if n == m + 1:
+            data.mark_interesting()
+
+    shrinker.fixate_shrink_passes(["lower_blocks_together"])
+
+    assert list(shrinker.buffer) == [1, 0] + [0] * n_gap + [0, 1]

hypothesis-python/tests/quality/test_shrink_quality.py

@@ -19,6 +19,7 @@
 
 import pytest
 
+import hypothesis.strategies as st
 from hypothesis import assume, settings
 from hypothesis.strategies import (
     booleans,
@@ -337,3 +338,48 @@ def test_sum_of_pair():
     assert minimal(
         tuples(integers(0, 1000), integers(0, 1000)), lambda x: sum(x) > 1000
     ) == (1, 1000)
+
+
+def test_calculator_benchmark():
+    """This test comes from
+    https://github.com/jlink/shrinking-challenge/blob/main/challenges/calculator.md,
+    which is originally from Pike, Lee. "SmartCheck: automatic and efficient
+    counterexample reduction and generalization."
+    Proceedings of the 2014 ACM SIGPLAN symposium on Haskell. 2014.
+    """
+
+    expression = st.deferred(
+        lambda: st.one_of(
+            st.integers(),
+            st.tuples(st.just("+"), expression, expression),
+            st.tuples(st.just("/"), expression, expression),
+        )
+    )
+
+    def div_subterms(e):
+        if isinstance(e, int):
+            return True
+        if e[0] == "/" and e[-1] == 0:
+            return False
+        return div_subterms(e[1]) and div_subterms(e[2])
+
+    def evaluate(e):
+        if isinstance(e, int):
+            return e
+        elif e[0] == "+":
+            return evaluate(e[1]) + evaluate(e[2])
+        else:
+            assert e[0] == "/"
+            return evaluate(e[1]) // evaluate(e[2])
+
+    def is_failing(e):
+        assume(div_subterms(e))
+        try:
+            evaluate(e)
+            return False
+        except ZeroDivisionError:
+            return True
+
+    x = minimal(expression, is_failing)
+
+    assert x == ("/", 0, ("+", 0, 0))