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/expr_editor.dart';
import 'package:cal/main.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(() {
    // 光标闪烁是无限循环动画，会让 pumpAndSettle 永远等不到静止
    ExprEditor.blinkEnabled = false;
    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();
  }

  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 press(tester, '∫');

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

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

      expect(find.text('Integrate[x, x]'), findsOneWidget);
    });

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

      expect(find.text('x^2'), findsOneWidget);
    });

    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('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('控制台', () {
    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);
    });
  });
}