Add fuzz tests for stroke input modeling

`StrokeInputModeler` should be able to model any inputs, with any valid input model, and not crash.

Right now, the spring-based modeler (which we are moving away from) rejects some large-value inputs to avoid float overflow, and previously, we were CHECK-failing if that happened. This change removes that CHECK, since we shouldn't be crashing on inputs that pass `StrokeInputBatch` validation.

PiperOrigin-RevId: 827562618

Author: Ink Open Source

ink/brush/fuzz_domains.cc

@@ -626,7 +626,7 @@ Domain<BrushPaint::TextureKeyframe> ValidBrushPaintTextureKeyframe() {
       OptionalOf(FiniteAngle()), OptionalOf(InRange(0.f, 1.f)));
 }
 
-fuzztest::Domain<BrushPaint::TextureLayer>
+Domain<BrushPaint::TextureLayer>
 ValidBrushPaintTextureLayerWithMappingAndAnimationFrames(
     BrushPaint::TextureMapping mapping, int animation_frames,
     int animation_rows, int animation_columns,
@@ -680,7 +680,7 @@ Domain<BrushPaint::SelfOverlap> ArbitraryBrushPaintSelfOverlap() {
 }
 // LINT.ThenChange(brush_paint.h:self_overlap)
 
-fuzztest::Domain<BrushPaint> ValidBrushPaint(DomainVariant variant) {
+Domain<BrushPaint> ValidBrushPaint(DomainVariant variant) {
   return FlatMap(
       [=](BrushPaint::TextureMapping mapping,
           std::tuple<int, int, int> animation_frames_rows_columns,
@@ -721,11 +721,9 @@ Domain<BrushTip> ValidBrushTip(DomainVariant variant) {
 
 }  // namespace
 
-fuzztest::Domain<Brush> ValidBrush() {
-  return ValidBrush(DomainVariant::kValid);
-}
+Domain<Brush> ValidBrush() { return ValidBrush(DomainVariant::kValid); }
 
-fuzztest::Domain<Brush> SerializableBrush() {
+Domain<Brush> SerializableBrush() {
   return ValidBrush(DomainVariant::kValidAndSerializable);
 }
 
@@ -753,19 +751,21 @@ Domain<BrushCoat> SerializableBrushCoat() {
   return ValidBrushCoat(DomainVariant::kValidAndSerializable);
 }
 
-fuzztest::Domain<BrushFamily> ValidBrushFamily() {
+Domain<float> ValidBrushEpsilon() { return FinitePositiveFloat(); }
+
+Domain<BrushFamily> ValidBrushFamily() {
   return ValidBrushFamily(DomainVariant::kValid);
 }
 
-fuzztest::Domain<BrushFamily> SerializableBrushFamily() {
+Domain<BrushFamily> SerializableBrushFamily() {
   return ValidBrushFamily(DomainVariant::kValidAndSerializable);
 }
 
-fuzztest::Domain<BrushPaint> ValidBrushPaint() {
+Domain<BrushPaint> ValidBrushPaint() {
   return ValidBrushPaint(DomainVariant::kValid);
 }
 
-fuzztest::Domain<BrushPaint> SerializableBrushPaint() {
+Domain<BrushPaint> SerializableBrushPaint() {
   return ValidBrushPaint(DomainVariant::kValidAndSerializable);
 }
 

ink/brush/fuzz_domains.h

@@ -47,6 +47,9 @@ fuzztest::Domain<BrushCoat> ValidBrushCoat();
 // The domain of all valid brush coats that can be serialized to proto.
 fuzztest::Domain<BrushCoat> SerializableBrushCoat();
 
+// The domain of all valid brush epsilon values.
+fuzztest::Domain<float> ValidBrushEpsilon();
+
 // The domain of all valid brush families.
 fuzztest::Domain<BrushFamily> ValidBrushFamily();
 // The domain of all valid brush families that can be serialized to proto.

ink/strokes/internal/BUILD.bazel

@@ -112,15 +112,19 @@ cc_test(
     deps = [
         ":stroke_input_modeler",
         "//ink/brush:brush_family",
+        "//ink/brush:fuzz_domains",
         "//ink/geometry:angle",
         "//ink/geometry:type_matchers",
+        "//ink/strokes/input:fuzz_domains",
         "//ink/strokes/input:stroke_input",
         "//ink/strokes/input:stroke_input_batch",
         "//ink/types:duration",
+        "//ink/types:fuzz_domains",
         "//ink/types:physical_distance",
         "//ink/types:type_matchers",
         "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/status:status_matchers",
+        "@com_google_fuzztest//fuzztest",
         "@com_google_googletest//:gtest_main",
     ],
 )

ink/strokes/internal/stroke_input_modeler/spring_based_input_modeler.cc

@@ -232,15 +232,18 @@ void SpringBasedInputModeler::ModelInput(
   result_buffer_.clear();
 
   // `StrokeInputBatch` and `InProgressStroke` are designed to perform all the
-  // necessary validation so that this operation should not fail.
-  ABSL_CHECK_OK(stroke_modeler_.Update(
-      {.event_type = event_type,
-       .position = {input.position.x, input.position.y},
-       .time = stroke_model::Time(input.elapsed_time.ToSeconds()),
-       .pressure = input.pressure,
-       .tilt = input.tilt.ValueInRadians(),
-       .orientation = input.orientation.ValueInRadians()},
-      result_buffer_));
+  // necessary validation so that this operation should mostly not
+  // fail. However, the spring-based modeler will still fail on very large input
+  // values. If that happens, just ignore the error rather than crashing.
+  stroke_modeler_
+      .Update({.event_type = event_type,
+               .position = {input.position.x, input.position.y},
+               .time = stroke_model::Time(input.elapsed_time.ToSeconds()),
+               .pressure = input.pressure,
+               .tilt = input.tilt.ValueInRadians(),
+               .orientation = input.orientation.ValueInRadians()},
+              result_buffer_)
+      .IgnoreError();
 
   std::optional<Point> previous_position;
   float traveled_distance = 0;

ink/strokes/internal/stroke_input_modeler_test.cc

@@ -21,14 +21,18 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "fuzztest/fuzztest.h"
 #include "absl/log/absl_check.h"
 #include "absl/status/status_matchers.h"
 #include "ink/brush/brush_family.h"
+#include "ink/brush/fuzz_domains.h"
 #include "ink/geometry/angle.h"
 #include "ink/geometry/type_matchers.h"
+#include "ink/strokes/input/fuzz_domains.h"
 #include "ink/strokes/input/stroke_input.h"
 #include "ink/strokes/input/stroke_input_batch.h"
 #include "ink/types/duration.h"
+#include "ink/types/fuzz_domains.h"
 #include "ink/types/physical_distance.h"
 #include "ink/types/type_matchers.h"
 
@@ -437,5 +441,21 @@ INSTANTIATE_TEST_SUITE_P(
       return info.param.test_name;
     });
 
+void CanModelAnyStrokeInputBatch(const BrushFamily::InputModel& input_model,
+                                 float brush_epsilon,
+                                 const StrokeInputBatch& input_batch,
+                                 Duration32 elapsed_time) {
+  StrokeInputModeler modeler;
+  modeler.StartStroke(input_model, brush_epsilon);
+  modeler.ExtendStroke(input_batch, StrokeInputBatch(), elapsed_time);
+  EXPECT_LE(modeler.GetState().stable_input_count,
+            modeler.GetState().real_input_count);
+  EXPECT_LE(modeler.GetState().real_input_count,
+            modeler.GetModeledInputs().size());
+}
+FUZZ_TEST(StrokeInputModelerFuzzTest, CanModelAnyStrokeInputBatch)
+    .WithDomains(ValidBrushFamilyInputModel(), ValidBrushEpsilon(),
+                 ArbitraryStrokeInputBatch(), FiniteNonNegativeDuration32());
+
 }  // namespace
 }  // namespace ink::strokes_internal