Merge pull request #2033 from HypothesisWorks/DRMacIver/remove-run-sh…

…rink-pass

Remove the ability to run a single shrink pass

hypothesis-python/RELEASE.rst

@@ -0,0 +1,4 @@
+RELEASE_TYPE: patch
+
+This release removes some defunct internal functionality that was only being used
+for testing. It should have no user visible impact.

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

@@ -101,12 +101,10 @@ def defines_shrink_pass(generate_arguments):
     """A convenient decorator for defining shrink passes."""
 
     def accept(run_step):
-        definition = ShrinkPassDefinition(
-            generate_arguments=generate_arguments, run_step=run_step
-        )
+        ShrinkPassDefinition(generate_arguments=generate_arguments, run_step=run_step)
 
-        def run(self):
-            return self.run_shrink_pass(definition.name)
+        def run(self):  # pragma: no cover
+            assert False, "Shrink passes should not be run directly"
 
         run.__name__ = run_step.__name__
         run.is_shrink_pass = True
@@ -395,27 +393,6 @@ def debug(self, msg):
     def random(self):
         return self.__engine.random
 
-    def run_shrink_pass(self, sp):
-        """Runs the function associated with ShrinkPass sp and updates the
-        relevant metadata.
-
-        Note that sp may or may not be a pass currently associated with
-        this shrinker. This does not handle any requeing that is
-        required.
-        """
-        sp = self.shrink_pass(sp)
-
-        self.debug("Shrink Pass %s" % (sp.name,))
-        try:
-            sp.runs += 1
-
-            steps = sp.generate_steps()
-            self.random.shuffle(steps)
-            for s in steps:
-                sp.run_step(s)
-        finally:
-            self.debug("Shrink Pass %s completed." % (sp.name,))
-
     def shrink(self):
         """Run the full set of shrinks and update shrink_target.
 

hypothesis-python/tests/cover/test_conjecture_engine.py

@@ -482,14 +482,18 @@ def shrinker(data):
     # We normally would have populated this in minimize_individual_blocks
     shrinker.is_shrinking_block = lambda x: True
 
-    fixate(Shrinker.example_deletion_with_block_lowering)(shrinker)
+    shrinker.fixate_shrink_passes(["example_deletion_with_block_lowering"])
 
     assert list(shrinker.shrink_target.buffer) == [1, 1]
 
 
 def test_deletion_and_lowering_fails_to_shrink(monkeypatch):
     monkeypatch.setattr(
-        Shrinker, "shrink", Shrinker.example_deletion_with_block_lowering
+        Shrinker,
+        "shrink",
+        lambda self: self.fixate_shrink_passes(
+            ["example_deletion_with_block_lowering"]
+        ),
     )
     # Would normally be added by minimize_individual_blocks, but we skip
     # that phase in this test.
@@ -763,16 +767,6 @@ def x(data):
     assert x == hbytes(hbytes([1]) * 10)
 
 
-def fixate(f):
-    def accept(self):
-        prev = None
-        while self.shrink_target is not prev:
-            prev = self.shrink_target
-            f(self)
-
-    return accept
-
-
 def test_can_remove_discarded_data():
     @shrinking_from(hbytes([0] * 10) + hbytes([11]))
     def shrinker(data):
@@ -815,13 +809,6 @@ def shrinker(data):
     assert shrinker.shrink_target.has_discards
 
 
-def shrink_pass(name):
-    def run(self):
-        self.run_shrink_pass(name)
-
-    return run
-
-
 def test_discarding_can_fail(monkeypatch):
     @shrinking_from(hbytes([1]))
     def shrinker(data):
@@ -938,11 +925,8 @@ def shrink(buffer, *passes):
     def accept(f):
         shrinker = shrinking_from(buffer)(f)
 
-        prev = None
-        while shrinker.shrink_target is not prev:
-            prev = shrinker.shrink_target
-            for p in passes:
-                shrinker.run_shrink_pass(p)
+        shrinker.fixate_shrink_passes(passes)
+
         return list(shrinker.buffer)
 
     return accept
@@ -956,10 +940,8 @@ def shrinker(data):
         if abs(m - n) <= 1 and max(m, n) > 0:
             data.mark_interesting()
 
-    # Run minimize_individual_blocks twice so we have both blocks show
-    # as changed regardless of which order this happens in.
-    shrinker.minimize_individual_blocks()
-    shrinker.minimize_individual_blocks()
+    shrinker.mark_changed(0)
+    shrinker.mark_changed(1)
     shrinker.lower_common_block_offset()
 
     x = shrinker.shrink_target.buffer
@@ -968,7 +950,11 @@ def shrinker(data):
 
 
 def test_handle_empty_draws(monkeypatch):
-    monkeypatch.setattr(Shrinker, "shrink", Shrinker.adaptive_example_deletion)
+    monkeypatch.setattr(
+        Shrinker,
+        "shrink",
+        lambda self: self.fixate_shrink_passes(["adaptive_example_deletion"]),
+    )
 
     @run_to_buffer
     def x(data):
@@ -1007,17 +993,9 @@ def f(data):
     assert runner.exit_reason == ExitReason.finished
 
 
-def test_can_reorder_examples(monkeypatch):
-    monkeypatch.setattr(
-        ConjectureRunner,
-        "generate_new_examples",
-        lambda runner: runner.cached_test_function([1, 0, 1, 1, 0, 1, 0, 0, 0]),
-    )
-
-    monkeypatch.setattr(Shrinker, "shrink", Shrinker.reorder_examples)
-
-    @run_to_buffer
-    def x(data):
+def test_can_reorder_examples():
+    @shrinking_from([1, 0, 1, 1, 0, 1, 0, 0, 0])
+    def shrinker(data):
         total = 0
         for _ in range(5):
             data.start_example(0)
@@ -1027,7 +1005,9 @@ def x(data):
         if total == 2:
             data.mark_interesting()
 
-    assert list(x) == [0, 0, 0, 1, 0, 1, 1, 0, 1]
+    shrinker.fixate_shrink_passes(["reorder_examples"])
+
+    assert list(shrinker.buffer) == [0, 0, 0, 1, 0, 1, 1, 0, 1]
 
 
 def test_permits_but_ignores_raising_order(monkeypatch):
@@ -1060,8 +1040,7 @@ def shrinker(data):
             if n == 4:
                 data.mark_interesting()
 
-    for i in range(1, 5):
-        shrinker.run_shrink_pass(block_program("X" * i))
+    shrinker.fixate_shrink_passes([block_program("X" * i) for i in range(1, 5)])
     assert list(shrinker.shrink_target.buffer) == [0, 4] * 5
 
 
@@ -1129,7 +1108,7 @@ def shrinker(data):
         if result >= 32768 and cap == 1:
             data.mark_interesting()
 
-    shrinker.minimize_individual_blocks()
+    shrinker.fixate_shrink_passes(["minimize_individual_blocks"])
     assert list(shrinker.shrink_target.buffer) == [1, 1, 0, 1, 0, 0, 1]
 
 
@@ -1264,7 +1243,7 @@ def shrinker(data):
         if n == 1:
             data.mark_interesting()
 
-    shrinker.minimize_individual_blocks()
+    shrinker.fixate_shrink_passes(["minimize_individual_blocks"])
     assert list(shrinker.shrink_target.buffer) == [0, 1]
 
 
@@ -1277,7 +1256,7 @@ def shrinker(data):
         else:
             data.draw_bits(8)
 
-    shrinker.minimize_individual_blocks()
+    shrinker.fixate_shrink_passes(["minimize_individual_blocks"])
 
 
 def test_zero_examples_will_zero_blocks():
@@ -1289,7 +1268,7 @@ def shrinker(data):
         if n == m == 1:
             data.mark_interesting()
 
-    shrinker.run_shrink_pass("zero_examples")
+    shrinker.fixate_shrink_passes(["zero_examples"])
     assert list(shrinker.shrink_target.buffer) == [1, 0, 1]
 
 
@@ -1306,7 +1285,7 @@ def shrinker(data):
             data.draw_bits(16)
         data.mark_interesting()
 
-    shrinker.minimize_individual_blocks()
+    shrinker.fixate_shrink_passes(["minimize_individual_blocks"])
     assert list(shrinker.shrink_target.buffer) == [0, 0, 0]
 
 
@@ -1352,7 +1331,7 @@ def shrinker(data):
         if data.draw_bits(8) == 7:
             data.mark_interesting()
 
-    shrinker.run_shrink_pass(block_program("-XX"))
+    shrinker.fixate_shrink_passes([block_program("-XX")])
     assert list(shrinker.shrink_target.buffer) == [1, 7]
 
 
@@ -1469,7 +1448,7 @@ def shrinker(data):
         if hbytes(data.buffer) == base_buf:
             data.mark_interesting()
 
-    shrinker.minimize_floats()
+    shrinker.fixate_shrink_passes(["minimize_floats"])
 
     assert shrinker.shrink_target.buffer == base_buf
 
@@ -1531,25 +1510,6 @@ def shrinker(data):
     assert shrinker.calls <= 60
 
 
-def test_zero_examples_does_not_try_to_adapt_across_different_sizes():
-    @shrinking_from([1, 0, 0] * 10 + [1])
-    def shrinker(data):
-        for _ in hrange(10):
-            data.draw_bits(1)
-            data.draw_bits(16)
-        if data.draw_bits(1):
-            data.mark_interesting()
-
-    initial = shrinker.calls
-    shrinker.zero_examples()
-    assert shrinker.shrink_target.buffer == hbytes(30) + hbytes([1])
-
-    # Tried each of the 1-bit blocks, plus the whole example, plus the final
-    # single-bit block. Did not try to expand regions into the trivial two-byte
-    # blocks on each side.
-    assert shrinker.calls == initial + 12
-
-
 def test_stable_identifiers_match_their_examples():
     def tree(data):
         data.start_example(1)