mathtool2/test/widget_test.dart

// Dart 侧验证：把 Symja 通道 mock 掉，检查外壳、计算器按键、控制台命令、工具页。
// 真机端到端验证另做（本构建机没有 KVM，跑不了模拟器）。
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';

import 'package:cal/calculator_page.dart';
import 'package:cal/console_page.dart';
import 'package:cal/curve_plot.dart';
import 'package:cal/expr_editor.dart';
import 'package:cal/main.dart';
import 'package:cal/settings.dart';
import 'package:cal/tools/cuo_wei_xiang_jian.dart';
import 'package:cal/tools/cycle_coloring.dart';
import 'package:cal/tools/function_plotter.dart';
import 'package:cal/tools/group_allocation.dart';
import 'package:cal/tools_page.dart';

void main() {
  const symja = MethodChannel('com.nonvioce.cal/symja');
  const mcp = MethodChannel('com.nonvioce.cal/mcp');
  final calls = <MethodCall>[];

  setUp(() {
    calls.clear();
    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
        .setMockMethodCallHandler(symja, (call) async {
      calls.add(call);
      switch (call.method) {
        case 'evaluate':
          final expr = call.arguments['expr'] as String;
          if (expr == 'boom') {
            return <String, dynamic>{'ok': false, 'error': '模拟的失败'};
          }
          return <String, dynamic>{
            'ok': true,
            'text': 'x^3/3',
            'tex': r'\frac{{x}^{3}}{3}',
            'ms': 12,
          };
        case 'variables':
          return <String, dynamic>{
            'ok': true,
            'vars': [
              {'name': 'a', 'value': '42'},
            ],
          };
        case 'exportSession':
          return <String, dynamic>{'ok': true, 'defs': ['a=42']};
        case 'importSession':
          return <String, dynamic>{'ok': true, 'applied': 1, 'failed': []};
        case 'clearVariable':
        case 'clearAll':
          return <String, dynamic>{'ok': true};
        case 'sample':
          return <String, dynamic>{
            'ok': true,
            'ys': [0.0, 1.0, 0.0],
            'ms': 5,
          };
        case 'cancel':
          return null;
        default:
          return null;
      }
    });
    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
        .setMockMethodCallHandler(mcp, (call) async {
      calls.add(call);
      switch (call.method) {
        case 'status':
          return <String, dynamic>{
            'running': false,
            'port': 8734,
            'tools': ['evaluate', 'solve'],
          };
        default:
          return null;
      }
    });
  });

  tearDown(() {
    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
        .setMockMethodCallHandler(symja, null);
    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
        .setMockMethodCallHandler(mcp, null);
  });

  Future<void> pumpApp(WidgetTester tester) async {
    await tester.pumpWidget(const CalApp());
    await tester.pumpAndSettle();
  }

  Future<void> goTo(WidgetTester tester, String tab) async {
    await tester.tap(find.text(tab));
    await tester.pumpAndSettle();
  }

  /// IndexedStack 会让三个页面同时存在，所以查找必须限定在某一页里。
  Finder inPage(Type page, Finder matching) =>
      find.descendant(of: find.byType(page), matching: matching);

  Future<void> submit(WidgetTester tester, String text) async {
    await tester.enterText(inPage(ConsolePage, find.byType(TextField)), text);
    await tester.testTextInput.receiveAction(TextInputAction.done);
    await tester.pumpAndSettle();
  }

  /// 按计算器上的某个键。按键带 ValueKey，避免和编辑器里的字面量撞车。
  Future<void> press(WidgetTester tester, String label) async {
    await tester.tap(find.byKey(ValueKey('key-$label')));
    await tester.pumpAndSettle();
  }

  /// 按一个**在 shift 层里**的键：先按 ⇧ 再按它。
  Future<void> pressShift(WidgetTester tester, String label) async {
    await press(tester, '⇧');
    await press(tester, label);
  }

  /// 打开工具页里的某个工具（会连带把 App 起起来）。
  ///
  /// 先用搜索框把它筛出来：网格是懒加载的，靠后的卡片在测试视口外根本不在树里。
  /// 卡片用 `widgetWithText(InkWell, ...)` 定位 —— 搜索框里也有同样的字。
  Future<void> openTool(WidgetTester tester, String name) async {
    await pumpApp(tester);
    await goTo(tester, '工具');
    await tester.enterText(inPage(ToolsPage, find.byType(TextField)), name);
    await tester.pumpAndSettle();
    await tester.tap(find.widgetWithText(InkWell, name).last);
    await tester.pumpAndSettle();
  }

  /// 给某个工具的输入框依次填值（按界面上的先后顺序）。
  Future<void> fillTool(
    WidgetTester tester,
    Type page,
    List<String> values,
  ) async {
    final fields = find.descendant(
      of: find.byType(page),
      matching: find.byType(TextField),
    );
    for (var i = 0; i < values.length; i++) {
      await tester.enterText(fields.at(i), values[i]);
    }
    await tester.pumpAndSettle();
  }

  Future<void> runTool(WidgetTester tester) async {
    await tester.tap(find.widgetWithText(FilledButton, '计算'));
    await tester.pumpAndSettle();
  }

  /// 等防抖走完，取出真正送到通道的那条表达式。
  ///
  /// 显示区那行"原文"是按需出现的（没信息量就不显示），所以断言文档内容
  /// 不能靠它 —— 看通道里实际发出去的东西才可靠。
  Future<String> lastExpr(WidgetTester tester) async {
    await tester.pump(const Duration(milliseconds: 700));
    await tester.pumpAndSettle();
    return calls.lastWhere((c) => c.method == 'evaluate').arguments['expr']
        as String;
  }

  group('外壳', () {
    testWidgets('三个界面：计算器 / 工具 / 控制台', (tester) async {
      await pumpApp(tester);
      expect(find.text('计算器'), findsWidgets);
      expect(find.text('工具'), findsWidgets);
      expect(find.text('控制台'), findsWidgets);
      // 默认进计算器
      expect(find.byType(CalculatorPage), findsOneWidget);
    });
  });

  group('计算器（结构化输入）', () {
    testWidgets('按 ∫ 插出 Integrate 模板，并在显示区露出序列化结果', (tester) async {
      await pumpApp(tester);
      await pressShift(tester, '∫');

      // 空槽序列化成 Null，用户一眼能看出还没填
      expect(find.text('Integrate[Null, x]'), findsOneWidget);
    });

    testWidgets('模板槽里能接着打字（光标落在第一个参数）', (tester) async {
      await pumpApp(tester);
      await pressShift(tester, '∫');
      await press(tester, 'x');

      expect(await lastExpr(tester), 'Integrate[x, x]');
    });

    testWidgets('^ 把左边的节点收成底，光标落到指数', (tester) async {
      await pumpApp(tester);
      await press(tester, 'x');
      await press(tester, '^');
      await press(tester, '2');

      expect(await lastExpr(tester), 'x^2');
    });

    testWidgets('数字键并入同一个字面量', (tester) async {
      await pumpApp(tester);
      await press(tester, '4');
      await press(tester, '2');

      // 编辑器里的字面量 42 和下面那行序列化结果都是 '42'，所以是 findsWidgets
      expect(find.text('42'), findsWidgets);
    });

    testWidgets('实时预览走 preview 标志，不污染 %', (tester) async {
      await pumpApp(tester);
      await press(tester, 'sin');
      await press(tester, 'x');
      // 等防抖
      await tester.pump(const Duration(milliseconds: 700));
      await tester.pumpAndSettle();

      // 按 sin 的那次也会触发预览（expr = Sin[Null]），所以取最后一次
      final c = calls.lastWhere((c) => c.method == 'evaluate');
      expect(c.arguments['preview'], true);
      expect(c.arguments['expr'], 'Sin[x]');
    });

    testWidgets('按 = 提交时把 preview 置 false（正式求值要更新 %）', (tester) async {
      await pumpApp(tester);
      await press(tester, 'sin');
      await press(tester, 'x');
      await press(tester, '✓');

      final evals = calls.where((c) => c.method == 'evaluate').toList();
      final committed = evals.where((c) => c.arguments['preview'] == false);
      expect(committed, isNotEmpty);
      expect(committed.last.arguments['expr'], 'Sin[x]');
    });

    testWidgets('打完字光标仍在（回归：光标槽判定不能比槽内位置）', (tester) async {
      await pumpApp(tester);
      expect(find.byKey(const ValueKey('expr-caret')), findsOneWidget);

      await press(tester, 'x');
      // 以前这里会消失：offset 从 0 变成 1，而它错误地参与了对"槽"的相等判断
      expect(find.byKey(const ValueKey('expr-caret')), findsOneWidget);

      await press(tester, '2');
      expect(find.byKey(const ValueKey('expr-caret')), findsOneWidget);
    });

    testWidgets('点节点左半边能把光标放回最前面', (tester) async {
      await pumpApp(tester);
      await press(tester, 'x');
      await press(tester, '+');
      await press(tester, '1');
      expect(await lastExpr(tester), 'x+1');

      // 点 x 的左半边 → 光标应当落到 x 前面
      final xRect = tester.getRect(
        find.descendant(of: find.byType(ExprEditor), matching: find.text('x')),
      );
      await tester.tapAt(Offset(xRect.left + 1, xRect.center.dy));
      await tester.pumpAndSettle();

      // 再打一个 2：插到最前面才是 2x+1；若光标落在 x 之后就成 x2+1
      await press(tester, '2');
      expect(await lastExpr(tester), '2x+1');
    });

    testWidgets('点节点右半边把光标放到它后面', (tester) async {
      await pumpApp(tester);
      await press(tester, 'x');
      await press(tester, '+');

      final xRect = tester.getRect(
        find.descendant(of: find.byType(ExprEditor), matching: find.text('x')),
      );
      await tester.tapAt(Offset(xRect.right - 1, xRect.center.dy));
      await tester.pumpAndSettle();

      await press(tester, '2');
      // 字母后面接数字要补乘号（否则 x2 会被当成"叫 x2 的变量"）
      expect(await lastExpr(tester), 'x*2+');
    });

    testWidgets('i 键：编辑框显示小写 i，送进引擎的是大写 I', (tester) async {
      await pumpApp(tester);
      await press(tester, 'i');

      // 小写 i 在 Symja 里只是"叫 i 的未定义符号"，虚数单位必须是大写 I
      expect(await lastExpr(tester), 'I');
      expect(
        find.descendant(of: find.byType(ExprEditor), matching: find.text('i')),
        findsOneWidget,
      );
    });

    testWidgets('窄字形的点击区不会只剩字形那么宽（回归：i 点不中）', (tester) async {
      await pumpApp(tester);
      await press(tester, '2');
      await press(tester, 'i');
      expect(await lastExpr(tester), '2I');

      final iRect = tester.getRect(
        find.descendant(of: find.byType(ExprEditor), matching: find.text('i')),
      );
      // 以前就只有字形宽（5~6px），手指点不中；现在至少 12
      expect(iRect.width, greaterThanOrEqualTo(12));

      // 点左半边 → 光标落到 i 前面，接着打的 x 插在 2 和 i 之间
      await tester.tapAt(Offset(iRect.left + 1, iRect.center.dy));
      await tester.pumpAndSettle();
      await press(tester, 'x');
      expect(await lastExpr(tester), '2x*I');
    });

    testWidgets('/.→ 一个键给出代入骨架（原来 /. 和 -> 是两个键）', (tester) async {
      await pumpApp(tester);
      await press(tester, 'x');
      await pressShift(tester, '/.→');
      await press(tester, '3');

      // 骨架自带变量 x 和箭头，用户只要接着打要代进去的值
      expect(await lastExpr(tester), 'x/. x -> 3');
    });

    testWidgets('用新加的运算符键敲出一个可解的方程', (tester) async {
      await pumpApp(tester);
      await press(tester, 'solve'); // Solve[□, x]，光标在第一个参数
      await press(tester, 'x');
      await press(tester, '−');
      await press(tester, '1');
      await pressShift(tester, '==');
      await press(tester, '0');

      // 说明：这里刻意不用 ^。按了 ^ 之后光标在**指数槽**里，
      // 要回到主层得点一下幂节点（点定位），不是靠按键。
      expect(await lastExpr(tester), 'Solve[x-1==0, x]');
    });

    testWidgets('拼一个行列式 Det[{{1,2},{3,4}}]', (tester) async {
      await pumpApp(tester);
      // 函数面板取 Det
      await tester.tap(find.byIcon(Icons.functions));
      await tester.pumpAndSettle();
      await tester.enterText(find.byType(TextField).last, 'Det');
      await tester.pumpAndSettle();
      // 用 ListTile 限定，否则会同时命中搜索框里刚输入的 "Det"
      await tester.tap(find.widgetWithText(ListTile, 'Det'));
      await tester.pumpAndSettle();

      // 拼一行矩阵：{{1,2}}
      // （没有"换行键"了，多行矩阵要把光标点回外层花括号再加逗号和 `{`）
      await pressShift(tester, '{');
      await pressShift(tester, '{');
      await press(tester, '1');
      await pressShift(tester, ',');
      await press(tester, '2');

      expect(await lastExpr(tester), 'Det[{{1,2}}]');
    });

    testWidgets('shift 层：C 是组合数、P 是排列数', (tester) async {
      await pumpApp(tester);

      await press(tester, 'C'); // 组合数直接显示：Binomial[□, □]
      await press(tester, '5');
      await pressShift(tester, ',');
      await press(tester, '2');
      expect(await lastExpr(tester), 'Binomial[5, 2]');

      await press(tester, 'CLR');
      await press(tester, '⇧');
      await press(tester, 'P'); // 排列数是 C 的 shift：FactorialPower[□, □]
      await press(tester, '5');
      await pressShift(tester, ',');
      await press(tester, '2');
      expect(await lastExpr(tester), 'FactorialPower[5, 2]');
    });

    testWidgets('阶乘收在括号的 shift 里', (tester) async {
      await pumpApp(tester);
      await press(tester, '5');
      await pressShift(tester, '!'); // `(` 的 shift
      expect(await lastExpr(tester), '5!');
    });

    testWidgets('shift 只吃一次：按完一个键就复位', (tester) async {
      await pumpApp(tester);

      await press(tester, '⇧');
      await press(tester, 'asin'); // shift 层里的 sin
      await press(tester, 'sin'); // 已经复位了，这一下是普通的 Sin
      expect(await lastExpr(tester), 'ArcSin[Sin[Null]]');
    });

    testWidgets('函数面板能按中文说明搜（不用记得住 Variance）', (tester) async {
      await pumpApp(tester);
      await tester.tap(find.byIcon(Icons.functions));
      await tester.pumpAndSettle();

      await tester.enterText(find.byType(TextField).last, '方差');
      await tester.pumpAndSettle();

      expect(find.widgetWithText(ListTile, 'Variance'), findsOneWidget);
      expect(find.widgetWithText(ListTile, 'Sin'), findsNothing);
    });

    testWidgets('赋值：x = 1', (tester) async {
      await pumpApp(tester);
      await press(tester, 'x');
      await pressShift(tester, '=');
      await press(tester, '1');
      expect(await lastExpr(tester), 'x=1');
    });

    testWidgets('ANS 键在编辑框显示 ANS，送进引擎的仍是 %', (tester) async {
      await pumpApp(tester);
      await press(tester, '2');
      await press(tester, '+');
      await press(tester, 'ANS');

      // 编辑框里显示的是人看的 ANS
      expect(
        find.descendant(
            of: find.byType(ExprEditor), matching: find.text('ANS')),
        findsOneWidget,
      );
      // 小字（真正送出去的那串）还是 %
      expect(find.text('2+%'), findsOneWidget);
      expect(await lastExpr(tester), '2+%');
    });

    testWidgets('默认精确：求值原样送出去', (tester) async {
      await pumpApp(tester);
      await press(tester, 'sin');
      await press(tester, 'x');
      await press(tester, '✓');

      final committed = calls.where(
          (c) => c.method == 'evaluate' && c.arguments['preview'] == false);
      expect(committed.last.arguments['expr'], 'Sin[x]');
    });

    testWidgets('切到近似后，求值套上 N[...]', (tester) async {
      await pumpApp(tester);
      await press(tester, 'sin');
      await press(tester, 'x');

      await tester.tap(find.text('精确'));
      await tester.pumpAndSettle();
      expect(find.text('≈ 近似'), findsOneWidget);

      await press(tester, '✓');
      final committed = calls.where(
          (c) => c.method == 'evaluate' && c.arguments['preview'] == false);
      expect(committed.last.arguments['expr'], 'N[Round[Sin[x], 1/10^10]]');
    });

    testWidgets('近似模式不碰赋值表达式（否则赋值会被变成求值）', (tester) async {
      await pumpApp(tester);
      // 先在计算器里打开近似
      await tester.tap(find.text('精确'));
      await tester.pumpAndSettle();

      // 到控制台提交一个赋值
      await goTo(tester, '控制台');
      await submit(tester, 'a = 1/3');

      final committed = calls.where(
          (c) => c.method == 'evaluate' && c.arguments['preview'] == false);
      expect(committed.last.arguments['expr'], 'a = 1/3');
    });

    testWidgets('CLR 清空', (tester) async {
      await pumpApp(tester);
      await press(tester, 'sin');
      expect(find.text('Sin[Null]'), findsOneWidget);

      await press(tester, 'CLR');
      expect(find.text('Null'), findsOneWidget);
    });
  });

  group('复制粘贴', () {
    /// 把系统通道的剪贴板换成内存版，并记录写入。
    List<String> mockClipboard(WidgetTester tester) {
      final copied = <String>[];
      String? available;
      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
          .setMockMethodCallHandler(SystemChannels.platform, (call) async {
        switch (call.method) {
          case 'Clipboard.setData':
            final t = (call.arguments as Map)['text'] as String;
            copied.add(t);
            available = t; // 有写有读，跟真剪贴板一样
            return null;
          case 'Clipboard.getData':
            return available == null
                ? null
                : <String, dynamic>{'text': available};
          default:
            return null;
        }
      });
      addTearDown(() => TestDefaultBinaryMessengerBinding
          .instance.defaultBinaryMessenger
          .setMockMethodCallHandler(SystemChannels.platform, null));
      return copied;
    }

    Finder inEditor(String text) => find.descendant(
        of: find.byType(ExprEditor), matching: find.text(text));

    /// 长按 [from] 再点 [to]，选中两者之间（含）的一段。
    Future<void> selectRange(
        WidgetTester tester, String from, String to) async {
      await tester.longPress(inEditor(from));
      await tester.pumpAndSettle();
      await tester.tap(inEditor(to));
      await tester.pumpAndSettle();
    }

    /// 点"光标已经所在的地方"，弹出粘贴入口。
    ///
    /// 直接点光标那根竖线最稳 —— 光标在哪，就点到哪。按节点坐标算的话，
    /// 光标在某个参数槽里时点节点边界其实落不到同一个位置。
    Future<void> tapCaret(WidgetTester tester) async {
      await tester
          .tapAt(tester.getCenter(find.byKey(const ValueKey('expr-caret'))));
      await tester.pumpAndSettle();
    }

    testWidgets('选中一段 → 操作栏自动出现 → 复制', (tester) async {
      final copied = mockClipboard(tester);
      await pumpApp(tester);
      for (final k in ['2', 'x', '+', '1']) {
        await press(tester, k);
      }

      await selectRange(tester, '2', '1');
      expect(find.textContaining('已选中  2x+1'), findsOneWidget);

      await tester.tap(find.byTooltip('复制'));
      await tester.pumpAndSettle();
      expect(copied, ['2x+1']);
    });

    testWidgets('剪切后粘到 Log 的括号里', (tester) async {
      mockClipboard(tester);
      await pumpApp(tester);
      for (final k in ['2', 'x', '+', '1']) {
        await press(tester, k);
      }
      await selectRange(tester, '2', '1');
      await tester.tap(find.byTooltip('剪切'));
      await tester.pumpAndSettle();
      expect(find.text('Null'), findsOneWidget); // 全剪掉了

      await press(tester, 'ln'); // Log[Null]，光标在参数槽里
      expect(find.text('Log[Null]'), findsOneWidget);

      await tapCaret(tester);
      expect(find.text('粘贴到光标处'), findsOneWidget);

      await tester.tap(find.byTooltip('粘贴'));
      await tester.pumpAndSettle();
      expect(await lastExpr(tester), 'Log[2x+1]');
    });

    testWidgets('粘贴解析不了的东西会明确报错，不会乱猜', (tester) async {
      mockClipboard(tester);
      await pumpApp(tester);
      await press(tester, 'x');

      // 往剪贴板里塞一段解析不了的，再粘
      await Clipboard.setData(const ClipboardData(text: 'x@y'));
      await tapCaret(tester);
      await tester.tap(find.byTooltip('粘贴'));
      await tester.pumpAndSettle();

      expect(find.textContaining('没法转成按钮式输入'), findsOneWidget);
    });

    testWidgets('点结果直接复制结果', (tester) async {
      final copied = mockClipboard(tester);
      await pumpApp(tester);
      await press(tester, '2');
      await press(tester, '+');
      await press(tester, '3');
      await press(tester, '✓');

      // 结果区渲染的是 LaTeX，纯文本那份不在，所以点整个结果条
      await tester.tap(find.byKey(const ValueKey('calc-result')));
      await tester.pumpAndSettle();
      expect(copied, contains('x^3/3'));
      expect(find.textContaining('已复制结果'), findsOneWidget);
    });
  });

  group('控制台', () {
    testWidgets('提交表达式会送到通道并渲染结果', (tester) async {
      await pumpApp(tester);
      await goTo(tester, '控制台');
      await submit(tester, 'Integrate[x^2, x]');

      final eval = calls.lastWhere((c) => c.method == 'evaluate');
      expect(eval.arguments['expr'], 'Integrate[x^2, x]');
      expect(eval.arguments['preview'], false);
      expect(find.text('x^3/3'), findsWidgets);
    });

    testWidgets('help 是本地命令，不求值', (tester) async {
      await pumpApp(tester);
      await goTo(tester, '控制台');
      await submit(tester, 'help');

      expect(calls.where((c) => c.method == 'evaluate' && c.arguments['preview'] == false),
          isEmpty);
      expect(find.textContaining('命令（小写'), findsOneWidget);
    });

    testWidgets('vars 命令列出变量', (tester) async {
      await pumpApp(tester);
      await goTo(tester, '控制台');
      await submit(tester, 'vars');
      expect(find.text('a = 42'), findsOneWidget);
    });

    testWidgets('失败时显示错误', (tester) async {
      await pumpApp(tester);
      await goTo(tester, '控制台');
      await submit(tester, 'boom');
      expect(find.text('模拟的失败'), findsOneWidget);
    });
  });

  group('工具页', () {
    testWidgets('列出插件，并能按名字过滤', (tester) async {
      await pumpApp(tester);
      await goTo(tester, '工具');

      // 网格是懒加载的，靠后的卡片在测试视口外，所以只断言前几个
      expect(find.text('错位相减法'), findsOneWidget);
      expect(find.text('二项分布'), findsOneWidget);

      await tester.enterText(inPage(ToolsPage, find.byType(TextField)), '回归');
      await tester.pumpAndSettle();

      expect(find.text('线性回归'), findsOneWidget);
      expect(find.text('二项分布'), findsNothing);
    });

    testWidgets('拼音首字母也能搜到', (tester) async {
      await pumpApp(tester);
      await goTo(tester, '工具');

      await tester.enterText(inPage(ToolsPage, find.byType(TextField)), 'xxhg');
      await tester.pumpAndSettle();
      expect(find.text('线性回归'), findsOneWidget);
    });

    testWidgets('搜索框让开状态栏（回归：这页是唯一没有 AppBar 的 tab）', (tester) async {
      // 真机上搜索框和状态栏的时钟叠在一起 —— 计算器/控制台都有自己的
      // Scaffold 扛状态栏，工具页直接返回一个 Column，得自己让开安全区
      tester.view.padding = const FakeViewPadding(top: 120);
      addTearDown(tester.view.resetPadding);

      await pumpApp(tester);
      await goTo(tester, '工具');

      final top = tester.getRect(inPage(ToolsPage, find.byType(TextField))).top;
      expect(
        top,
        greaterThanOrEqualTo(120 / tester.view.devicePixelRatio),
        reason: '搜索框钻到状态栏底下了',
      );
    });

    testWidgets('卷积：每组的增删按钮贴着自己那组', (tester) async {
      await openTool(tester, '卷积分布列');

      final buttons = find.widgetWithText(TextButton, '添加一行');
      expect(buttons, findsNWidgets(2)); // X 一组、Y 一组
      final xBtn = tester.getRect(buttons.first).center.dy;
      final yBtn = tester.getRect(buttons.last).center.dy;
      final xFirst = tester.getRect(find.text('X 取值 1')).center.dy;
      final yFirst = tester.getRect(find.text('Y 取值 1')).center.dy;

      // X 的按钮在 X 那组上面；Y 的按钮在 X 那组**下面**、Y 那组上面
      expect(xBtn, lessThan(xFirst));
      expect(yBtn, greaterThan(xFirst));
      expect(yBtn, lessThan(yFirst));
    });

    testWidgets('函数图像能同时画多条曲线', (tester) async {
      await openTool(tester, '函数图像绘制');
      await tester.tap(find.widgetWithText(OutlinedButton, '添加函数'));
      await tester.pumpAndSettle();

      final fields = find.descendant(
        of: find.byType(FunctionPlotterPage),
        matching: find.byType(TextField),
      );
      await tester.enterText(fields.at(1), 'Sin[x]');
      await runTool(tester);

      // 回归：图表原来是个有状态的 widget，只在第一帧拿了 series，
      // 后来加的函数根本进不去
      final plot = tester.widget<CurvePlot>(find.byType(CurvePlot));
      expect(plot.series.map((s) => s.label), containsAll(['x^2', 'Sin[x]']));
      expect(plot.series.length, 2);
    });

    testWidgets('输出点一下就复制（图表除外）', (tester) async {
      final copied = <String>[];
      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
          .setMockMethodCallHandler(SystemChannels.platform, (call) async {
        if (call.method == 'Clipboard.setData') {
          copied.add('${(call.arguments as Map)['text']}');
        }
        return null;
      });

      await openTool(tester, '分组分配');
      await fillTool(tester, GroupAllocationPage, ['6', '4']);
      await runTool(tester);
      // 点结果的**标签**（值本身渲染成数学排版，不一定有同名的 Text）
      await tester.tap(find.text('方案数 k!·S(6,4)'));
      await tester.pumpAndSettle();
      expect(copied, ['x^3/3']); // 复制的是 mock 给的纯文本
    });

    testWidgets('重置按钮清空输入和结果', (tester) async {
      await openTool(tester, '分组分配');
      await fillTool(tester, GroupAllocationPage, ['6', '4']);
      await runTool(tester);
      expect(find.text('方案数 k!·S(6,4)'), findsOneWidget);

      await tester.tap(find.widgetWithText(OutlinedButton, '重置'));
      await tester.pumpAndSettle();

      expect(find.text('方案数 k!·S(6,4)'), findsNothing);
      final fields = find.descendant(
        of: find.byType(GroupAllocationPage),
        matching: find.byType(TextField),
      );
      expect(tester.widget<TextField>(fields.at(0)).controller!.text, '');
    });

    testWidgets('分组分配：k!·S(n,k) 是 Symja 算的', (tester) async {
      await openTool(tester, '分组分配');
      await fillTool(tester, GroupAllocationPage, ['6', '4']);
      await runTool(tester);

      expect(
        calls
            .where((c) => c.method == 'evaluate')
            .map((c) => '${c.arguments['expr']}'),
        contains('Rationalize[Factorial[4]*StirlingS2[6, 4]]'),
      );
    });

    test('错位相减法的结果公式：尾巴是 −B，不是 +B', () {
      // B = −4 → 尾巴写成 `+ 4`
      expect(
        sFormula(a: '8', b: '-4', q: '2').plain,
        'S(n) = (8·n - 4)·2^n + 4',
      );
      // B = 2 → 尾巴写成 `- 2`
      expect(
        sFormula(a: '4', b: '2', q: '2').plain,
        'S(n) = (4·n + 2)·2^n - 2',
      );
      // LaTeX 里分数要写成 \frac
      final tex = sFormula(a: '1/2', b: '-1/3', q: '3').tex;
      expect(tex, contains(r'\frac{1}{2}'));
      expect(tex, contains(r'\frac{1}{3}'));
      expect(tex, contains('{3}^{n} + '));
    });

    testWidgets('错位相减法把 Sₙ 的公式整条渲染出来', (tester) async {
      await openTool(tester, '错位相减法');
      await fillTool(tester, CuoWeiXiangJianPage, ['2', '1', '2', '1']);
      await runTool(tester);

      // 结果卡在（渲染成数学排版），不是只把 A、B 两个数甩出来
      expect(find.text('结果 Sₙ = (A·n + B)·qⁿ − B'), findsOneWidget);
      // 乘号是显式写的：`va*vq^(vm+1)` 而不是 `va vq^(vm+1)`
      expect(
        calls
            .where((c) => c.method == 'evaluate')
            .map((c) => '${c.arguments['expr']}'),
        contains('With[{va=2,vb=1,vq=2,vm=1}, va*vq^(vm+1)/(vq-1)]'),
      );
    });

    testWidgets('n 边形染色：(k−1)ⁿ+(k−1)(−1)ⁿ 是 Symja 算的', (tester) async {
      await openTool(tester, 'n 边形染色');
      await fillTool(tester, CycleColoringPage, ['5', '3']);
      await runTool(tester);

      expect(
        calls
            .where((c) => c.method == 'evaluate')
            .map((c) => '${c.arguments['expr']}'),
        contains('Rationalize[(3-1)^5 + (3-1)*(-1)^5]'),
      );
    });
  });

  group('设置', () {
    testWidgets('齿轮打开设置面板；E-Ink 打开后主题换灰阶、动画关掉', (tester) async {
      await pumpApp(tester);
      await goTo(tester, '控制台');
      await tester.tap(find.byIcon(Icons.settings_outlined));
      await tester.pumpAndSettle();
      expect(find.text('MCP 服务器端口'), findsOneWidget);

      await tester.tap(find.byType(SwitchListTile));
      await tester.pumpAndSettle();
      expect(tester.widget<SwitchListTile>(find.byType(SwitchListTile)).value, isTrue);

      // 动画关掉：无障碍开关 + 主题里的水波纹
      final ctx = tester.element(find.byType(ShellPage));
      expect(MediaQuery.of(ctx).disableAnimations, isTrue);
      final app = tester.widget<MaterialApp>(find.byType(MaterialApp));
      expect(app.theme!.splashFactory, NoSplash.splashFactory);
    });

    testWidgets('近似值位数：滑动条能调，计算器的 N[...] 跟着变', (tester) async {
      await pumpApp(tester);
      await goTo(tester, '控制台');
      await tester.tap(find.byIcon(Icons.settings_outlined));
      await tester.pumpAndSettle();

      await tester.drag(find.byType(Slider), const Offset(-400, 0));
      await tester.pumpAndSettle();
      final digits =
          tester.widget<Slider>(find.byType(Slider)).value.round();
      expect(digits, AppSettings.minDigits);

      await tester.tapAt(const Offset(10, 10)); // 关面板
      await tester.pumpAndSettle();

      // 计算器切到「近似」，送进引擎的表达式应当带上这个位数
      await goTo(tester, '计算器');
      await tester.tap(find.text('精确'));
      await tester.pumpAndSettle();
      await press(tester, '2');

      expect(
        calls.lastWhere((c) => c.method == 'evaluate').arguments['expr'],
        'N[Round[2, 1/10^$digits]]',
      );
    });

    testWidgets('设置的 MCP 端口会传给原生侧', (tester) async {
      await pumpApp(tester);
      await goTo(tester, '控制台');
      await tester.tap(find.byIcon(Icons.settings_outlined));
      await tester.pumpAndSettle();

      await tester.enterText(find.byType(TextField).last, '9100');
      await tester.testTextInput.receiveAction(TextInputAction.done);
      await tester.pumpAndSettle();
      // 关掉设置面板（点面板外面的遮罩）
      await tester.tapAt(const Offset(10, 10));
      await tester.pumpAndSettle();

      // 换个入口启动 MCP，应当带上刚设的端口
      await tester.tap(find.byIcon(Icons.cloud_outlined));
      await tester.pumpAndSettle();
      await tester.tap(find.widgetWithText(FilledButton, '启动'));
      await tester.pumpAndSettle();

      final start = calls.lastWhere((c) => c.method == 'start');
      expect(start.arguments['port'], 9100);
    });
  });
}