update test for LineChartCubicMonotoneCurve.monotone

Author: huanghui1998hhh

test/chart/line_chart/line_chart_curve_test.dart

@@ -4,7 +4,7 @@ import 'package:fl_chart/fl_chart.dart';
 import 'package:fl_chart/src/chart/line_chart/line_chart_curve.dart';
 import 'package:flutter_test/flutter_test.dart';
 
-const samplePoints1 = [
+const testPoints1 = [
   Offset(10, 10),
   Offset(20, 20),
   Offset(30, 40),
@@ -157,29 +157,29 @@ void main() {
 
       test('draw curved line if distance > tinyThreshold', () {
         final path = _buildPathWithCurve(
-          samplePoints1,
+          testPoints1,
           const LineChartCubicMonotoneCurve(tinyThresholdSquared: 0),
         );
 
         final metrics = path.computeMetrics().toList();
 
         expect(
           metrics.single.length,
-          greaterThan(samplePoints1.straightDistance),
+          greaterThan(testPoints1.straightDistance),
         );
       });
     });
 
     group('smooth parameter behavior', () {
       test('the effect of smooth increases monotonically', () {
         var smoothCount = 1;
-        var lastCurveLength = samplePoints1.straightDistance;
+        var lastCurveLength = testPoints1.straightDistance;
 
         while (smoothCount < 11) {
           final smooth = 0.1 * smoothCount;
 
           final path = _buildPathWithCurve(
-            samplePoints1,
+            testPoints1,
             LineChartCubicMonotoneCurve(
               smooth: smooth,
               tinyThresholdSquared: 0,
@@ -192,12 +192,143 @@ void main() {
         }
       });
     });
+
+    group('monotone constraint behavior', () {
+      test('SmoothMonotone.x prevents Y-direction overshoot with zigzag data',
+          () {
+        final points = [
+          const Offset(0, 15),
+          const Offset(10, -50),
+          const Offset(20, -56.5),
+          const Offset(30, -46.5),
+          const Offset(40, -22.1),
+          const Offset(50, -2.5),
+        ];
+
+        const curve = LineChartCubicMonotoneCurve(
+          monotone: SmoothMonotone.x,
+          smooth: 0.3,
+          tinyThresholdSquared: 0,
+        );
+
+        final path = _buildPathWithCurve(points, curve);
+        final samples = _samplePath(path, 100);
+
+        // Verify that Y coordinates of each curve segment stay within
+        // the Y range of its two endpoints
+        for (var i = 0; i < points.length - 1; i++) {
+          final minY =
+              points[i].dy < points[i + 1].dy ? points[i].dy : points[i + 1].dy;
+          final maxY =
+              points[i].dy > points[i + 1].dy ? points[i].dy : points[i + 1].dy;
+
+          final segmentSamples = samples
+              .where((s) => s.dx >= points[i].dx && s.dx <= points[i + 1].dx);
+
+          for (final sample in segmentSamples) {
+            expect(
+              sample.dy,
+              inRange(minY - 1.0, maxY + 1.0),
+              reason: 'Segment $i: Y=${sample.dy} out of range [$minY, $maxY]',
+            );
+          }
+        }
+      });
+
+      test(
+          'SmoothMonotone.y prevents X-direction overshoot with horizontal zigzag',
+          () {
+        final points = [
+          const Offset(50, 0),
+          const Offset(10, 10),
+          const Offset(90, 20),
+          const Offset(20, 30),
+          const Offset(80, 40),
+        ];
+
+        const curve = LineChartCubicMonotoneCurve(
+          monotone: SmoothMonotone.y,
+          smooth: 0.3,
+          tinyThresholdSquared: 0,
+        );
+
+        final path = _buildPathWithCurve(points, curve);
+        final samples = _samplePath(path, 100);
+
+        // Verify that X coordinates of each curve segment stay within
+        // the X range of its two endpoints
+        for (var i = 0; i < points.length - 1; i++) {
+          final minX =
+              points[i].dx < points[i + 1].dx ? points[i].dx : points[i + 1].dx;
+          final maxX =
+              points[i].dx > points[i + 1].dx ? points[i].dx : points[i + 1].dx;
+
+          final segmentSamples = samples
+              .where((s) => s.dy >= points[i].dy && s.dy <= points[i + 1].dy);
+
+          for (final sample in segmentSamples) {
+            expect(
+              sample.dx,
+              inRange(minX - 1.0, maxX + 1.0),
+              reason: 'Segment $i: X=${sample.dx} out of range [$minX, $maxX]',
+            );
+          }
+        }
+      });
+    });
   });
 }
 
+/// Sample points uniformly along the path
+List<Offset> _samplePath(Path path, int sampleCount) {
+  final samples = <Offset>[];
+  final metrics = path.computeMetrics().first;
+
+  for (var i = 0; i <= sampleCount; i++) {
+    final distance = metrics.length * i / sampleCount;
+    final tangent = metrics.getTangentForOffset(distance);
+    if (tangent != null) {
+      samples.add(tangent.position);
+    }
+  }
+
+  return samples;
+}
+
+/// Custom range matcher
+Matcher inRange(num min, num max) => _InRangeMatcher(min, max);
+
+class _InRangeMatcher extends Matcher {
+  const _InRangeMatcher(this.min, this.max);
+
+  final num min;
+  final num max;
+
+  @override
+  bool matches(dynamic item, Map<dynamic, dynamic> matchState) {
+    if (item is! num) return false;
+    return item >= min && item <= max;
+  }
+
+  @override
+  Description describe(Description description) {
+    return description.add('in range [$min, $max]');
+  }
+
+  @override
+  Description describeMismatch(
+    dynamic item,
+    Description mismatchDescription,
+    Map<dynamic, dynamic> matchState,
+    bool verbose,
+  ) {
+    return mismatchDescription.add('was $item, outside range [$min, $max]');
+  }
+}
+
 void expectLikeStraightLine(
   LineChartCurve curve, {
-  List<Offset> points = samplePoints1,
+  List<Offset> points = testPoints1,
 }) {
   final path = _buildPathWithCurve(points, curve);