Merge pull request #4217 from tybug/short-collection

Add short-circuit for trivial collections

Author: Zac-HD

hypothesis-python/RELEASE.rst

@@ -0,0 +1,3 @@
+RELEASE_TYPE: patch
+
+This patch improves shrinking involving long strings or byte sequences whose value is not relevant to the failure.

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

@@ -69,8 +69,14 @@ def collection_index(choice, *, min_size, alphabet_size, to_order=identity):
     # We then add each element c to the index, starting from the end (so "ab" is
     # simpler than "ba"). Each loop takes c at position i in the sequence and
     # computes the number of sequences of size i which come before it in the ordering.
-    for i, c in enumerate(reversed(choice)):
-        index += (alphabet_size**i) * to_order(c)
+
+    # this running_exp computation is equivalent to doing
+    #   index += (alphabet_size**i) * n
+    # but reuses intermediate exponentiation steps for efficiency.
+    running_exp = 1
+    for c in reversed(choice):
+        index += running_exp * to_order(c)
+        running_exp *= alphabet_size
     return index
 
 

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

@@ -1480,12 +1480,14 @@ def minimize_nodes(self, nodes):
             Bytes.shrink(
                 value,
                 lambda val: self.try_shrinking_nodes(nodes, val),
+                min_size=kwargs["min_size"],
             )
         elif ir_type == "string":
             String.shrink(
                 value,
                 lambda val: self.try_shrinking_nodes(nodes, val),
                 intervals=kwargs["intervals"],
+                min_size=kwargs["min_size"],
             )
         else:
             raise NotImplementedError

hypothesis-python/src/hypothesis/internal/conjecture/shrinking/collection.py

@@ -14,14 +14,23 @@
 
 
 class Collection(Shrinker):
-    def setup(self, *, ElementShrinker, to_order=identity, from_order=identity):
+    def setup(
+        self, *, ElementShrinker, to_order=identity, from_order=identity, min_size
+    ):
         self.ElementShrinker = ElementShrinker
         self.to_order = to_order
         self.from_order = from_order
+        self.min_size = min_size
 
     def make_immutable(self, value):
         return tuple(value)
 
+    def short_circuit(self):
+        zero = self.from_order(0)
+        success = self.consider([zero] * len(self.current))
+        # we could still simplify by deleting elements (unless we're minimal size).
+        return success and len(self.current) == self.min_size
+
     def left_is_better(self, left, right):
         if len(left) < len(right):
             return True

hypothesis-python/src/hypothesis/internal/conjecture/shrinking/common.py

@@ -160,7 +160,7 @@ def short_circuit(self):
         If this returns True, the ``run`` method will terminate early
         without doing any more work.
         """
-        return False
+        return False  # pragma: no cover
 
     def left_is_better(self, left, right):
         """Returns True if the left is strictly simpler than the right

hypothesis-python/tests/conjecture/test_engine.py

@@ -201,13 +201,6 @@ def nodes(data):
 
 
 def test_draw_to_overrun(monkeypatch):
-    # TODO_BETTER_SHRINK: sometimes we can get unlucky and fail to shrink the
-    # initial size draw d to 2 before shrinking the 128 * d bytes, but I'm not
-    # sure why.
-    #
-    # If we do get unlucky in such a way then we need more than 500 shrinks to finish.
-    monkeypatch.setattr(engine_module, "MAX_SHRINKS", 1000)
-
     @run_to_nodes
     def nodes(data):
         d = (data.draw_bytes(1, 1)[0] - 8) & 0xFF

hypothesis-python/tests/conjecture/test_minimizer.py

@@ -72,7 +72,9 @@ def test_can_sort_bytes_by_reordering_partially_not_cross_stationary_element():
     ],
 )
 def test_shrink_strings(initial, predicate, intervals, expected):
-    assert String.shrink(initial, predicate, intervals=intervals) == tuple(expected)
+    assert String.shrink(
+        initial, predicate, intervals=intervals, min_size=len(expected)
+    ) == tuple(expected)
 
 
 @pytest.mark.parametrize(
@@ -85,9 +87,11 @@ def test_shrink_strings(initial, predicate, intervals, expected):
     ],
 )
 def test_shrink_bytes(initial, predicate, expected):
-    assert bytes(Bytes.shrink(initial, predicate)) == expected
+    assert bytes(Bytes.shrink(initial, predicate, min_size=len(expected))) == expected
 
 
 def test_collection_left_is_better():
-    shrinker = Collection([1, 2, 3], lambda v: True, ElementShrinker=Integer)
+    shrinker = Collection(
+        [1, 2, 3], lambda v: True, ElementShrinker=Integer, min_size=3
+    )
     assert not shrinker.left_is_better([1, 2, 3], [1, 2, 3])

hypothesis-python/tests/conjecture/test_shrinker.py

@@ -520,6 +520,19 @@ def shrinker(data: ConjectureData):
     assert shrinker.choices == (15, 10)
 
 
+@pytest.mark.parametrize("n", [10, 50, 100, 200])
+def test_can_quickly_shrink_to_trivial_collection(n):
+    @shrinking_from(ir(b"\x01" * n))
+    def shrinker(data: ConjectureData):
+        b = data.draw_bytes()
+        if len(b) >= n:
+            data.mark_interesting()
+
+    shrinker.fixate_shrink_passes(["minimize_individual_nodes"])
+    assert shrinker.choices == (b"\x00" * n,)
+    assert shrinker.calls < 10
+
+
 def test_alternative_shrinking_will_lower_to_alternate_value():
     # We want to reject the first integer value we see when shrinking
     # this alternative, because it will be the result of transmuting the