Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

25.9 KB
Raw Blame
import 'dart:ui' show SemanticsAction, Tristate;

import 'package:harness/shared/theme/app_icons.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness/shared/theme/app_theme.dart' as grid;
import 'package:harness/shared/widgets/app_menu.dart';
import 'package:harness/shared/widgets/app_select_field.dart';

/// [top] puts the field at the top of the window instead of its middle.
///
/// A `MenuAnchor` squeezes its panel into the room BELOW the anchor, so a field
/// centred in a 600pt test window leaves only ~300 and a seven-row list gets
/// compressed — an artefact of the harness, not of the widget. Any test that
/// measures a tall panel has to give it somewhere to open.
Widget _host(Widget child, {bool top = false}) => MaterialApp(
  theme: grid.buildAppTheme(brightness: Brightness.dark),
  themeAnimationDuration: Duration.zero,
  home: Builder(
    builder: (context) {
      grid.AppTheme.brightness.value = Theme.of(context).brightness;
      return grid.BrightnessScope(
        child: Scaffold(
          body: top
              ? Align(alignment: Alignment.topCenter, child: child)
              : Center(child: child),
        ),
      );
    },
  ),
);

const _options = <SelectOption<String?>>[
  SelectOption(value: null, label: 'System', note: 'SF Pro'),
  SelectOption(value: 'Helvetica Neue', label: 'Helvetica Neue'),
  SelectOption(value: 'Menlo', label: 'Menlo'),
];

/// Type-agnostic: the suite exercises both `AppSelectField<String?>` (the font
/// picker, where null means "system") and `AppSelectField<String>`.
final _field = find.byWidgetPredicate(
  (w) => w.runtimeType.toString().startsWith('AppSelectField<'),
);

Future<void> _open(WidgetTester tester) async {
  await tester.tap(_field);
  await tester.pumpAndSettle();
}

void main() {
  tearDown(() => grid.AppTheme.brightness.value = Brightness.light);

  testWidgets('accessible selector announces purpose, value and open state', (
    tester,
  ) async {
    final semantics = tester.ensureSemantics();
    try {
      String? chosen;
      await tester.pumpWidget(
        _host(
          StatefulBuilder(
            builder: (context, setState) => AppSelectField<String?>(
              semanticLabel: 'Terminal font',
              value: chosen,
              options: _options,
              width: 280,
              onChanged: (value) => setState(() => chosen = value),
            ),
          ),
          top: true,
        ),
      );
      final trigger = find.bySemanticsLabel('Terminal font');
      final closed = tester.getSemantics(trigger);
      expect(closed.getSemanticsData().value, 'System, SF Pro');
      expect(closed.getSemanticsData().flagsCollection.isButton, isTrue);
      expect(
        closed.getSemanticsData().flagsCollection.isExpanded,
        Tristate.isFalse,
      );
      expect(closed.getSemanticsData().hasAction(SemanticsAction.tap), isTrue);
      // Activating through assistive technology must open the same working menu.
      tester
          .renderObject(trigger)
          .owner!
          .semanticsOwner!
          .performAction(closed.id, SemanticsAction.tap);
      await tester.pumpAndSettle();
      expect(
        tester
            .getSemantics(trigger)
            .getSemanticsData()
            .flagsCollection
            .isExpanded,
        Tristate.isTrue,
      );
      expect(chosen, isNull, reason: 'opening does not change the setting');
      await tester.tap(find.widgetWithText(AppMenuItem, 'Menlo'));
      await tester.pumpAndSettle();
      expect(chosen, 'Menlo');
      final updated = tester.getSemantics(trigger).getSemanticsData();
      expect(updated.label, 'Terminal font');
      expect(updated.value, 'Menlo');
      expect(updated.flagsCollection.isExpanded, Tristate.isFalse);
      expect(updated.flagsCollection.isFocused, Tristate.isTrue);
    } finally {
      semantics.dispose();
    }
  });

  testWidgets('large text fits and focus remains distinct from selection', (
    tester,
  ) async {
    final focus = FocusNode();
    addTearDown(focus.dispose);
    await tester.pumpWidget(
      _host(
        MediaQuery(
          data: const MediaQueryData(
            textScaler: TextScaler.linear(2),
            highContrast: true,
            disableAnimations: true,
          ),
          child: AppSelectField<String>(
            width: 280,
            value: 'a',
            options: const [SelectOption(value: 'a', label: 'Alpha')],
            selected: false,
            focusNode: focus,
            onChanged: (_) {},
          ),
        ),
      ),
    );
    final field = tester.getRect(_field);
    final label = tester.getRect(find.text('Alpha'));
    expect(label.top, greaterThan(field.top));
    expect(label.bottom, lessThan(field.bottom));
    final box = find.descendant(
      of: _field,
      matching: find.byType(AnimatedContainer),
    );
    Border rim() =>
        (tester.widget<AnimatedContainer>(box).decoration! as BoxDecoration)
                .border!
            as Border;
    Color? fill() =>
        (tester.widget<AnimatedContainer>(box).decoration! as BoxDecoration)
            .color;
    final before = rim();
    final restingFill = fill();
    focus.requestFocus();
    await tester.pump();
    // Focus shows in the fill, never as a colored line.
    expect(fill(), isNot(restingFill));
    expect(rim().top.color, before.top.color);
    expect(rim().top.width, before.top.width);
    expect(tester.getRect(find.text('Alpha')), label);
    expect(tester.widget<AnimatedContainer>(box).duration, Duration.zero);
    expect(tester.takeException(), isNull);
  });

  testWidgets('typing a name focuses a choice without applying it', (
    tester,
  ) async {
    var picked = 'initial';
    await tester.pumpWidget(
      _host(
        AppSelectField<String>(
          value: 'local',
          options: const [
            SelectOption(value: 'local', label: 'This computer'),
            SelectOption(value: 'mac', label: 'MacBook Pro'),
            SelectOption(value: 'mini', label: 'Mac mini'),
            SelectOption(value: 'office', label: 'Office workstation'),
            SelectOption(value: 'workshop', label: 'Workshop machine'),
          ],
          onChanged: (value) => picked = value,
          width: 260,
        ),
      ),
    );
    await tester.sendKeyEvent(LogicalKeyboardKey.tab);
    await tester.pump();
    await tester.sendKeyEvent(LogicalKeyboardKey.enter);
    await tester.pumpAndSettle();
    await tester.sendKeyEvent(LogicalKeyboardKey.keyW, character: 'w');
    await tester.sendKeyEvent(LogicalKeyboardKey.keyO, character: 'o');
    await tester.pump();
    final row = find.widgetWithText(AppMenuItem, 'Workshop machine');
    expect(
      Focus.of(
        tester.element(
          find.descendant(of: row, matching: find.text('Workshop machine')),
        ),
      ).hasPrimaryFocus,
      isTrue,
    );
    expect(picked, 'initial');
    await tester.sendKeyEvent(LogicalKeyboardKey.enter);
    await tester.pumpAndSettle();
    expect(picked, 'workshop');
    expect(find.byType(AppMenuItem), findsNothing);
  });

  testWidgets(
    'Tab, Enter, arrows and Escape operate the picker',
    (tester) async {
      String? picked = 'unset';
      await tester.pumpWidget(
        _host(
          AppSelectField<String?>(
            value: 'Helvetica Neue',
            options: _options,
            onChanged: (value) => picked = value,
            width: 240,
          ),
        ),
      );
      await tester.sendKeyEvent(LogicalKeyboardKey.tab);
      await tester.pump();
      final anchor = tester.widget<InkWell>(
        find.descendant(of: _field, matching: find.byType(InkWell)),
      );
      expect(anchor.focusNode!.hasPrimaryFocus, isTrue);
      await tester.sendKeyEvent(LogicalKeyboardKey.enter);
      await tester.pumpAndSettle();
      expect(find.byType(AppMenuItem), findsNWidgets(3));
      final selected = tester.widget<AppMenuItem>(
        find.widgetWithText(AppMenuItem, 'Helvetica Neue'),
      );
      expect(selected.focusNode!.hasPrimaryFocus, isTrue);
      await tester.sendKeyEvent(LogicalKeyboardKey.arrowDown);
      await tester.pump();
      await tester.sendKeyEvent(LogicalKeyboardKey.enter);
      await tester.pumpAndSettle();
      expect(picked, 'Menlo');
      expect(find.byType(AppMenuItem), findsNothing);
      expect(anchor.focusNode!.hasPrimaryFocus, isTrue);
      await tester.sendKeyEvent(LogicalKeyboardKey.arrowDown);
      await tester.pumpAndSettle();
      expect(find.byType(AppMenuItem), findsNWidgets(3));
      await tester.sendKeyEvent(LogicalKeyboardKey.escape);
      await tester.pumpAndSettle();
      expect(find.byType(AppMenuItem), findsNothing);
      expect(anchor.focusNode!.hasPrimaryFocus, isTrue);
      expect(picked, 'Menlo');
      expect(tester.takeException(), isNull);
    },
    variant: const TargetPlatformVariant({
      TargetPlatform.macOS,
      TargetPlatform.linux,
      TargetPlatform.windows,
    }),
  );

  testWidgets('an unpicked row draws NO glyph — not an empty checkbox', (
    tester,
  ) async {
    // The regression this exists for: the leading slot was once filled with
    // `AppIcons.square` to keep the labels aligned. That glyph
    // draws a real outlined square, so a pick-one menu rendered as a list of
    // empty checkboxes — and put a border where §1 allows none.
    await tester.pumpWidget(
      _host(
        AppSelectField<String?>(
          value: null,
          options: _options,
          onChanged: (_) {},
          width: 188,
        ),
      ),
    );
    await _open(tester);

    expect(find.byType(AppMenuItem), findsNWidgets(3));
    expect(find.byIcon(AppIcons.square), findsNothing);
    // Exactly one glyph in the whole panel: the tick on the chosen row.
    expect(
      find.descendant(
        of: find.byType(AppMenuItem),
        matching: find.byType(Icon),
      ),
      findsOneWidget,
    );
    expect(find.byIcon(AppIcons.check), findsOneWidget);
  });

  testWidgets('the choice is marked three ways, not by colour alone', (
    tester,
  ) async {
    await tester.pumpWidget(
      _host(
        AppSelectField<String?>(
          value: 'Menlo',
          options: _options,
          onChanged: (_) {},
          width: 188,
        ),
      ),
    );
    await _open(tester);

    Text labelIn(String label) => tester.widget<Text>(
      find.descendant(
        of: find.widgetWithText(AppMenuItem, label),
        matching: find.text(label),
      ),
    );

    // 1. the tick, 2. the heavier label. (3. the accent wash is painted by an
    // `Ink` and is checked by eye, not here.)
    expect(find.byIcon(AppIcons.check), findsOneWidget);
    expect(labelIn('Menlo').style?.fontWeight, grid.AppFont.medium);
    expect(labelIn('Helvetica Neue').style?.fontWeight, grid.AppFont.regular);
  });

  testWidgets('a note reads as an aside, not as part of the name', (
    tester,
  ) async {
    await tester.pumpWidget(
      _host(
        AppSelectField<String?>(
          value: null,
          options: _options,
          onChanged: (_) {},
          width: 188,
        ),
      ),
    );
    await _open(tester);

    // Two Texts inside the row, not one label with a '·' glued into it — so the
    // face name can take quieter ink than the choice it qualifies.
    //
    // Scoped to the panel: the closed field shows the same pair, which is the
    // point — the control and its menu say the same thing the same way.
    final row = find.widgetWithText(AppMenuItem, 'System');
    expect(row, findsOneWidget);
    expect(
      find.descendant(of: row, matching: find.text('SF Pro')),
      findsOneWidget,
    );
    expect(find.textContaining('·'), findsNothing);

    final note = tester.widget<Text>(
      find.descendant(of: row, matching: find.text('SF Pro')),
    );
    final label = tester.widget<Text>(
      find.descendant(of: row, matching: find.text('System')),
    );
    expect(note.style?.color, isNot(label.style?.color));
    expect(note.style!.fontSize!, equals(label.style!.fontSize!));
  });

  testWidgets('a row mark gets its own slot, so labels never shift', (
    tester,
  ) async {
    // The engine picker carries a logo per row AND a tick on the chosen one.
    // They cannot share the leading slot: the picked row's label would sit a
    // glyph further right than every other row's.
    await tester.pumpWidget(
      _host(
        AppSelectField<String>(
          value: 'b',
          options: [
            SelectOption(
              value: 'a',
              label: 'Alpha',
              leading: () => const Icon(AppIcons.dot, size: 14),
            ),
            SelectOption(
              value: 'b',
              label: 'Beta',
              leading: () => const Icon(AppIcons.square, size: 14),
            ),
          ],
          onChanged: (_) {},
          width: 188,
        ),
      ),
    );
    await _open(tester);

    double labelX(String text) => tester
        .getTopLeft(
          find.descendant(
            of: find.byType(AppMenuItem),
            matching: find.text(text),
          ),
        )
        .dx;

    expect(
      labelX('Beta'),
      labelX('Alpha'),
      reason: 'the ticked row and the unticked one start on the same column',
    );
    // Both marks are drawn, and the tick is drawn as well as them, not instead.
    expect(find.byIcon(AppIcons.dot), findsWidgets);
    expect(find.byIcon(AppIcons.square), findsWidgets);
    expect(find.byIcon(AppIcons.check), findsOneWidget);
  });

  testWidgets('picking a row reports it and closes the panel', (tester) async {
    String? picked = 'unset';
    await tester.pumpWidget(
      _host(
        AppSelectField<String?>(
          value: null,
          options: _options,
          onChanged: (value) => picked = value,
          width: 188,
        ),
      ),
    );
    await _open(tester);

    await tester.tap(find.widgetWithText(AppMenuItem, 'Menlo'));
    await tester.pumpAndSettle();

    expect(picked, 'Menlo');
    expect(find.byType(AppMenuItem), findsNothing);
  });

  testWidgets('re-picking the current value reports nothing', (tester) async {
    var calls = 0;
    await tester.pumpWidget(
      _host(
        AppSelectField<String?>(
          value: 'Menlo',
          options: _options,
          onChanged: (_) => calls++,
          width: 188,
        ),
      ),
    );
    await _open(tester);

    await tester.tap(find.widgetWithText(AppMenuItem, 'Menlo'));
    await tester.pumpAndSettle();

    expect(calls, 0, reason: 'a no-op choice must not write to disk');
  });

  testWidgets('a picker and a context menu use the same row', (tester) async {
    await tester.pumpWidget(
      _host(
        Column(
          children: [
            AppSelectField<String?>(
              value: null,
              options: _options,
              onChanged: (_) {},
              width: 188,
            ),
            AppMenuItem(
              icon: AppIcons.dot,
              label: 'A context row',
              onPressed: () {},
            ),
          ],
        ),
      ),
    );

    final contextRow = tester.widget<AppMenuItem>(
      find.widgetWithText(AppMenuItem, 'A context row'),
    );
    expect(contextRow.metrics, AppMenuRowMetrics.compact);

    await _open(tester);
    final pickerRow = tester.widget<AppMenuItem>(
      find.widgetWithText(AppMenuItem, 'Menlo'),
    );
    expect(pickerRow.metrics, AppMenuRowMetrics.compact);
  });

  testWidgets('a row measures the extent its metrics claim', (tester) async {
    // The constant IS a measurement, and this is the measurement — the STRIDE
    // between two rows, not one row's own box, because the first row abuts the
    // panel edge and reports a pixel that is not there.
    //
    // It got its value this way: the arithmetic said 38.8, the layout said 40.
    // A panel sized from the arithmetic overflows and hangs a scrollbar on
    // itself, which is the bug this test exists to prevent coming back.
    await tester.pumpWidget(
      _host(
        AppSelectField<String?>(
          value: null,
          options: _options,
          onChanged: (_) {},
          width: 188,
        ),
      ),
    );
    await _open(tester);

    final first = tester.getRect(find.byType(AppMenuItem).at(0));
    final second = tester.getRect(find.byType(AppMenuItem).at(1));
    expect(
      second.top - first.top,
      closeTo(AppMenuRowMetrics.compact.extent, 0.1),
    );
  });

  testWidgets('a list that fits does NOT grow a scrollbar', (tester) async {
    // Seven rows is the engine picker, and at AppControl.menuMaxHeight (240) it
    // overflowed by five pixels — enough for Material to draw furniture saying
    // there was more to see.
    final many = [
      for (var i = 0; i < 7; i++)
        SelectOption<String?>(value: 'e$i', label: 'Engine $i'),
    ];
    await tester.pumpWidget(
      _host(
        AppSelectField<String?>(
          value: 'e0',
          options: many,
          onChanged: (_) {},
          width: 188,
        ),
        top: true,
      ),
    );
    await _open(tester);

    // What matters is that all seven are laid out and the last one is whole —
    // at AppControl.menuMaxHeight (240) the panel held six and a scrollbar.
    //
    // The exact stride is pinned by the three-row test above, not here: a panel
    // this tall is squeezed by whatever room the anchor has below it, so a
    // stride measured here is a fact about the test window, not about the row.
    expect(find.byType(AppMenuItem), findsNWidgets(7));
    final first = tester.getRect(find.byType(AppMenuItem).at(0));
    final last = tester.getRect(find.byType(AppMenuItem).at(6));
    expect(last.top, greaterThan(first.top));
    expect(last.height, closeTo(AppMenuRowMetrics.compact.extent, 0.1));
    expect(
      last.bottom - first.top,
      closeTo(7 * AppMenuRowMetrics.compact.extent, 0.1),
    );
  });

  testWidgets('the panel is at least as wide as the field it hangs off', (
    tester,
  ) async {
    await tester.pumpWidget(
      _host(
        AppSelectField<String?>(
          value: null,
          options: _options,
          onChanged: (_) {},
          width: 188,
        ),
      ),
    );
    final fieldWidth = tester.getSize(_field).width;
    await _open(tester);

    final rowWidth = tester.getSize(find.byType(AppMenuItem).first).width;
    expect(
      rowWidth,
      greaterThanOrEqualTo(fieldWidth - 1),
      reason: 'a panel narrower than its control reads as an unrelated box',
    );
    // …and never narrower than the floor, whatever the field does. A 188pt
    // field holds names that a 188pt list would have to truncate.
    expect(rowWidth, greaterThanOrEqualTo(240));
  });

  group('a detail line', () {
    const detailed = <SelectOption<String>>[
      SelectOption(
        value: 'invite',
        label: 'Invite only',
        detail: 'Only people you invite can use this grid.',
      ),
      SelectOption(
        value: 'public',
        label: 'Public',
        detail: 'Anyone can use this grid.',
      ),
    ];

    testWidgets('shows the sentence in the open menu, not in the field', (
      tester,
    ) async {
      await tester.pumpWidget(
        _host(
          AppSelectField<String>(
            value: 'invite',
            options: detailed,
            onChanged: (_) {},
          ),
          top: true,
        ),
      );
      // Closed, the control is only as wide as itself — a sentence would arrive
      // clipped mid-clause and read as a rendering bug.
      expect(find.textContaining('Only people you invite'), findsNothing);

      await _open(tester);
      expect(find.textContaining('Only people you invite'), findsOneWidget);
      expect(find.textContaining('Anyone can use'), findsOneWidget);
    });

    // A panel measured with the plain extent is shorter than its own rows, and
    // grows a scrollbar to show the overflow — furniture that says "there is
    // more here" when there is not.
    testWidgets('is counted when the panel is sized, so no scrollbar', (
      tester,
    ) async {
      await tester.pumpWidget(
        _host(
          AppSelectField<String>(
            value: 'invite',
            options: detailed,
            onChanged: (_) {},
          ),
          top: true,
        ),
      );
      await _open(tester);

      final rows = tester
          .widgetList<AppMenuItem>(find.byType(AppMenuItem))
          .length;
      expect(rows, 2);
      final first = tester.getRect(find.byType(AppMenuItem).at(0));
      expect(
        first.height,
        greaterThan(AppMenuRowMetrics.compact.extent),
        reason: 'a row carrying a sentence is taller than one without',
      );
      expect(
        tester.getRect(find.byType(AppMenuItem).at(1)).bottom - first.top,
        lessThanOrEqualTo(2 * AppMenuRowMetrics.compact.detailExtent + 1),
      );
    });
  });

  group('a searchable menu', () {
    // Nine rows: one past `filterThreshold`, and the shape of the real list —
    // a dozen coding engines that differ only by name, and the harnesses a
    // person actually came looking for.
    const long = <SelectOption<String>>[
      SelectOption(
        value: 'claude',
        label: 'Claude Code',
        detail: 'Code · Anthropic',
      ),
      SelectOption(value: 'codex', label: 'Codex', detail: 'Code · OpenAI'),
      SelectOption(
        value: 'cursor',
        label: 'Cursor',
        detail: 'Code · Anysphere',
      ),
      SelectOption(value: 'kilo', label: 'Kilo', detail: 'Code · Kilo Code'),
      SelectOption(value: 'amp', label: 'Amp', detail: 'Code · Sourcegraph'),
      SelectOption(value: 'grok', label: 'Grok', detail: 'Code · xAI'),
      SelectOption(
        value: 'marp',
        label: 'Marp',
        detail: 'Slides · Yuki Hattori',
      ),
      SelectOption(
        value: 'typst',
        label: 'Typst',
        detail: 'Documents · Typst GmbH',
      ),
      SelectOption(
        value: 'manim',
        label: 'Manim',
        detail: 'Math animation · Manim Community',
      ),
    ];
    final filter = find.byKey(const Key('app-select-filter'));

    Future<void> openWith(
      WidgetTester tester,
      List<SelectOption<String>> options,
      List<String> picked,
    ) async {
      await tester.pumpWidget(
        _host(
          AppSelectField<String>(
            value: 'claude',
            options: options,
            onChanged: picked.add,
            filterable: true,
            width: 240,
          ),
          top: true,
        ),
      );
      await _open(tester);
    }

    testWidgets('opens on the field past the threshold, and not below it', (
      tester,
    ) async {
      final picked = <String>[];
      await openWith(tester, long, picked);
      expect(filter, findsOneWidget);
      expect(
        tester.widget<TextField>(filter).focusNode!.hasPrimaryFocus,
        isTrue,
        reason: 'the first keystroke must narrow the list, not open a browser',
      );
      await tester.sendKeyEvent(LogicalKeyboardKey.escape);
      await tester.pumpAndSettle();

      // Eight rows is a list you READ. A search box over it is furniture that
      // says "there is more here" when there is not.
      await openWith(tester, long.take(8).toList(), picked);
      expect(filter, findsNothing);
      expect(find.byType(AppMenuItem), findsNWidgets(8));
      expect(picked, isEmpty);
    });

    testWidgets('typing narrows the rows, and Enter takes the match', (
      tester,
    ) async {
      final picked = <String>[];
      await openWith(tester, long, picked);
      await tester.enterText(filter, 'typ');
      await tester.pumpAndSettle();
      expect(find.byType(AppMenuItem), findsOneWidget);
      expect(find.widgetWithText(AppMenuItem, 'Typst'), findsOneWidget);
      await tester.sendKeyEvent(LogicalKeyboardKey.enter);
      await tester.pumpAndSettle();
      expect(picked, ['typst']);
      expect(find.byType(AppMenuItem), findsNothing);
    });

    testWidgets('matches the second line too, and Enter takes the first', (
      tester,
    ) async {
      final picked = <String>[];
      await openWith(tester, long, picked);
      // Nothing called "anthropic" — the maker is on the detail line, and on
      // this list that is what people know a row by.
      await tester.enterText(filter, 'ANTHROPIC');
      await tester.pumpAndSettle();
      expect(find.byType(AppMenuItem), findsOneWidget);
      expect(find.widgetWithText(AppMenuItem, 'Claude Code'), findsOneWidget);

      await tester.enterText(filter, 'ma');
      await tester.pumpAndSettle();
      expect(find.byType(AppMenuItem), findsNWidgets(2));
      await tester.sendKeyEvent(LogicalKeyboardKey.enter);
      await tester.pumpAndSettle();
      expect(picked, ['marp'], reason: 'the first of several matches');
    });

    testWidgets('Escape closes it, and reopening forgets the query', (
      tester,
    ) async {
      final picked = <String>[];
      await openWith(tester, long, picked);
      await tester.enterText(filter, 'ma');
      await tester.pumpAndSettle();
      expect(find.byType(AppMenuItem), findsNWidgets(2));
      await tester.sendKeyEvent(LogicalKeyboardKey.escape);
      await tester.pumpAndSettle();
      expect(picked, isEmpty);
      expect(find.byType(AppMenuItem), findsNothing);

      await _open(tester);
      expect(tester.widget<TextField>(filter).controller!.text, isEmpty);
      expect(find.byType(AppMenuItem), findsNWidgets(long.length));
      expect(tester.takeException(), isNull);
    });

    testWidgets('a query that matches nothing says so', (tester) async {
      final picked = <String>[];
      await openWith(tester, long, picked);
      await tester.enterText(filter, 'zzz');
      await tester.pumpAndSettle();
      expect(find.byType(AppMenuItem), findsNothing);
      // Not an empty panel: a typo must read as "no matches" rather than as a
      // menu that mysteriously emptied.
      expect(find.text('No matches'), findsOneWidget);
      await tester.sendKeyEvent(LogicalKeyboardKey.enter);
      await tester.pumpAndSettle();
      expect(picked, isEmpty);
      expect(
        filter,
        findsOneWidget,
        reason: 'Enter on nothing chooses nothing',
      );
    });
  });
}