improve node.trivial check and strengthen tests

Author: tybug

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

@@ -987,23 +987,30 @@ def trivial(self):
             return True
 
         if self.ir_type == "integer":
-            return self.value == self.kwargs["min_value"]
+            shrink_towards = self.kwargs["shrink_towards"]
+            min_value = self.kwargs["min_value"]
+            max_value = self.kwargs["max_value"]
+
+            if min_value is not None:
+                shrink_towards = max(min_value, shrink_towards)
+            if max_value is not None:
+                shrink_towards = min(max_value, shrink_towards)
+
+            return self.value == shrink_towards
         if self.ir_type == "float":
-            return float_to_int(self.value) == float_to_int(self.kwargs["min_value"])
+            # floats shrink "like integers" (for now, anyway), except shrink_towards
+            # is not configurable and is always 0.
+            shrink_towards = 0
+            shrink_towards = max(self.kwargs["min_value"], shrink_towards)
+            shrink_towards = min(self.kwargs["max_value"], shrink_towards)
+
+            return ir_value_equal("float", self.value, shrink_towards)
         if self.ir_type == "boolean":
             return self.value is False
         if self.ir_type == "string":
-            # we can do better here with "length is equal to min_size and value is
-            # filled with simplest-in-shrink-order characters". This requires
-            # computing what the simplest character in a given IntervalSet is,
-            # and since we redefine the shrink order for characters, that requires
-            # computing the order for all characters in an IntervalSet. Which
-            # may be expensive for large intervals. (would @cached_property be
-            # good enough here?)
-            #
-            # This naive check is hopefully good enough for now? I'm trying to
-            # avoid doing more work than we save when computing `trivial`.
-            return self.value == ""
+            # smallest size and contains only the smallest-in-shrink-order character.
+            minimal_char = self.kwargs["intervals"].char_in_shrink_order(0)
+            return self.value == (minimal_char * self.kwargs["min_size"])
         if self.ir_type == "bytes":
             # smallest size and all-zero value.
             return len(self.value) == self.kwargs["size"] and not any(self.value)

hypothesis-python/tests/conjecture/test_ir.py

@@ -30,6 +30,7 @@
 from hypothesis.internal.floats import SMALLEST_SUBNORMAL, next_down, next_up
 from hypothesis.internal.intervalsets import IntervalSet
 
+from tests.common.debug import minimal
 from tests.conjecture.common import fresh_data, ir_types_and_kwargs, kwargs_strategy
 
 
@@ -584,6 +585,17 @@ def test_forced_nodes_are_trivial(node):
             },
             was_forced=False,
         ),
+        IRNode(
+            ir_type="float",
+            value=0.0,
+            kwargs={
+                "min_value": -5.0,
+                "max_value": 5.0,
+                "allow_nan": True,
+                "smallest_nonzero_magnitude": SMALLEST_SUBNORMAL,
+            },
+            was_forced=False,
+        ),
         IRNode(
             ir_type="boolean",
             value=False,
@@ -600,6 +612,16 @@ def test_forced_nodes_are_trivial(node):
             },
             was_forced=False,
         ),
+        IRNode(
+            ir_type="string",
+            value="aaaa",
+            kwargs={
+                "intervals": IntervalSet.from_string("bcda"),
+                "min_size": 4,
+                "max_size": None,
+            },
+            was_forced=False,
+        ),
         IRNode(
             ir_type="bytes",
             value=bytes(8),
@@ -617,7 +639,131 @@ def test_forced_nodes_are_trivial(node):
             },
             was_forced=False,
         ),
+        IRNode(
+            ir_type="integer",
+            value=0,
+            kwargs={
+                "min_value": -10,
+                "max_value": 10,
+                "weights": None,
+                "shrink_towards": 0,
+            },
+            was_forced=False,
+        ),
+        IRNode(
+            ir_type="integer",
+            value=2,
+            kwargs={
+                "min_value": -10,
+                "max_value": 10,
+                "weights": None,
+                "shrink_towards": 2,
+            },
+            was_forced=False,
+        ),
+        IRNode(
+            ir_type="integer",
+            value=-10,
+            kwargs={
+                "min_value": -10,
+                "max_value": 10,
+                "weights": None,
+                "shrink_towards": -12,
+            },
+            was_forced=False,
+        ),
+        IRNode(
+            ir_type="integer",
+            value=10,
+            kwargs={
+                "min_value": -10,
+                "max_value": 10,
+                "weights": None,
+                "shrink_towards": 12,
+            },
+            was_forced=False,
+        ),
     ],
 )
 def test_trivial_nodes(node):
     assert node.trivial
+
+    @st.composite
+    def values(draw):
+        data = draw(st.data()).conjecture_data
+        return getattr(data, f"draw_{node.ir_type}")(**node.kwargs)
+
+    # if we're trivial, then shrinking should produce the same value.
+    assert ir_value_equal(node.ir_type, minimal(values()), node.value)
+
+
+@pytest.mark.parametrize(
+    "node",
+    [
+        IRNode(
+            ir_type="float",
+            value=6.0,
+            kwargs={
+                "min_value": 5.0,
+                "max_value": 10.0,
+                "allow_nan": True,
+                "smallest_nonzero_magnitude": SMALLEST_SUBNORMAL,
+            },
+            was_forced=False,
+        ),
+        IRNode(
+            ir_type="float",
+            value=-5.0,
+            kwargs={
+                "min_value": -5.0,
+                "max_value": 5.0,
+                "allow_nan": True,
+                "smallest_nonzero_magnitude": SMALLEST_SUBNORMAL,
+            },
+            was_forced=False,
+        ),
+        IRNode(
+            ir_type="boolean",
+            value=True,
+            kwargs={"p": 0.5},
+            was_forced=False,
+        ),
+        IRNode(
+            ir_type="string",
+            value="d",
+            kwargs={
+                "intervals": IntervalSet.from_string("abcd"),
+                "min_size": 1,
+                "max_size": None,
+            },
+            was_forced=False,
+        ),
+        IRNode(
+            ir_type="bytes",
+            value=b"\x01",
+            kwargs={"size": 1},
+            was_forced=False,
+        ),
+        IRNode(
+            ir_type="integer",
+            value=-10,
+            kwargs={
+                "min_value": -10,
+                "max_value": 10,
+                "weights": None,
+                "shrink_towards": 0,
+            },
+            was_forced=False,
+        ),
+    ],
+)
+def test_nontrivial_nodes(node):
+    assert not node.trivial
+
+    @st.composite
+    def values(draw):
+        data = draw(st.data()).conjecture_data
+        return getattr(data, f"draw_{node.ir_type}")(**node.kwargs)
+
+    # if we're nontrivial, then shrinking should produce something different.
+    assert not ir_value_equal(node.ir_type, minimal(values()), node.value)