WIP tests

Author: dkwingsmt

lib/web_ui/lib/src/engine/keyboard_binding.dart

@@ -153,6 +153,7 @@ class KeyboardBinding {
     });
     _listeners.clear();
     _converter.dispose();
+    // _rawKeyboard.dispose();
   }
 }
 

lib/web_ui/lib/src/engine/raw_keyboard.dart

@@ -19,10 +19,10 @@ class RawKeyboard {
   /// if no repeat events were received.
   final Map<String, Timer> _keydownTimers = <String, Timer>{};
 
-  /// Uninitializes the [RawKeyboard] singleton.
+  /// Terminates unfinished tasks in this [RawKeyboard] instance.
   ///
-  /// After calling this method this object becomes unusable and [instance]
-  /// becomes `null`. Call [initialize] again to initialize a new singleton.
+  /// The [dispose] must be called when a [RawKeyboard] instance is no longer
+  /// used.
   void dispose() {
     for (final String key in _keydownTimers.keys) {
       _keydownTimers[key]!.cancel();

lib/web_ui/test/keyboard_binding_test.dart

@@ -0,0 +1,284 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:typed_data';
+import 'package:meta/meta.dart' show isTest;
+import 'package:quiver/testing/async.dart';
+import 'package:test/bootstrap/browser.dart';
+import 'package:test/test.dart';
+import 'package:ui/src/engine.dart';
+import 'package:ui/ui.dart' as ui;
+
+const int kLocationStandard = 0;
+const int kLocationLeft = 1;
+const int kLocationRight = 2;
+const int kLocationNumpad = 3;
+
+final int kPhysicalKeyA = kWebToPhysicalKey['KeyA']!;
+final int kPhysicalKeyE = kWebToPhysicalKey['KeyE']!;
+final int kPhysicalKeyU = kWebToPhysicalKey['KeyU']!;
+final int kPhysicalDigit1 = kWebToPhysicalKey['Digit1']!;
+final int kPhysicalNumpad1 = kWebToPhysicalKey['Numpad1']!;
+final int kPhysicalShiftLeft = kWebToPhysicalKey['ShiftLeft']!;
+final int kPhysicalShiftRight = kWebToPhysicalKey['ShiftRight']!;
+final int kPhysicalMetaLeft = kWebToPhysicalKey['MetaLeft']!;
+final int kPhysicalTab = kWebToPhysicalKey['Tab']!;
+final int kPhysicalCapsLock = kWebToPhysicalKey['CapsLock']!;
+final int kPhysicalScrollLock = kWebToPhysicalKey['ScrollLock']!;
+// A web-specific physical key when code is empty.
+const int kPhysicalEmptyCode = 0x1700000000;
+
+const int kLogicalKeyA = 0x00000000061;
+const int kLogicalKeyU = 0x00000000075;
+const int kLogicalDigit1 = 0x00000000031;
+final int kLogicalNumpad1 = kWebLogicalLocationMap['1']![kLocationNumpad]!;
+final int kLogicalShiftLeft = kWebLogicalLocationMap['Shift']![kLocationLeft]!;
+final int kLogicalShiftRight = kWebLogicalLocationMap['Shift']![kLocationRight]!;
+final int kLogicalCtrlLeft = kWebLogicalLocationMap['Control']![kLocationLeft]!;
+final int kLogicalAltLeft = kWebLogicalLocationMap['Alt']![kLocationLeft]!;
+final int kLogicalMetaLeft = kWebLogicalLocationMap['Meta']![kLocationLeft]!;
+const int kLogicalTab = 0x0000000009;
+final int kLogicalCapsLock = kWebToLogicalKey['CapsLock']!;
+final int kLogicalScrollLock = kWebToLogicalKey['ScrollLock']!;
+
+typedef VoidCallback = void Function();
+
+void main() {
+  internalBootstrapBrowserTest(() => testMain);
+}
+
+ui.PlatformMessageCallback storeChannelDataTo(List<Map<String, dynamic>> storage) {
+  return (String channel, ByteData? data, ui.PlatformMessageResponseCallback? callback) {
+    expect(channel, 'flutter/keyevent');
+    final Map<String, dynamic>? dataReceived =
+        const JSONMessageCodec().decodeMessage(data) as Map<String, dynamic>?;
+    expect(dataReceived, isNotNull);
+    storage.add(dataReceived!);
+  };
+}
+
+void testMain() {
+  /// Used to save and restore [ui.window.onPlatformMessage] after each test.
+  ui.PlatformMessageCallback? savedCallback;
+
+  setUp(() {
+    savedCallback = ui.window.onPlatformMessage;
+  });
+
+  tearDown(() {
+    ui.window.onPlatformMessage = savedCallback;
+  });
+
+  test('Single key press, repeat, and release', () {
+    final List<ui.KeyData> keyDataList = <ui.KeyData>[];
+    final List<Map<String, dynamic>> channelData = <Map<String, dynamic>>[];
+    ui.window.onPlatformMessage = storeChannelDataTo(channelData);
+    final KeyboardBinding binding = KeyboardBinding.instance!;
+    final KeyboardConverter converter = KeyboardConverter((ui.KeyData key) {
+      keyDataList.add(key);
+      // Only handle down events
+      return key.type == ui.KeyEventType.down;
+    });
+    bool preventedDefault = false;
+    void onPreventDefault() { preventedDefault = true; }
+
+    converter.handleEvent(keyDownEvent('KeyA', 'a')
+      ..timeStamp = 1
+      ..onPreventDefault = onPreventDefault
+    );
+    expectKeyData(keyDataList.last,
+      timeStamp: const Duration(milliseconds: 1),
+      type: ui.KeyEventType.down,
+      physical: kPhysicalKeyA,
+      logical: kLogicalKeyA,
+      character: 'a',
+    );
+    expect(channelData, hasLength(1));
+    expect(channelData.last, <String, dynamic>{
+      'type': 'keyup',
+      'keymap': 'web',
+      'code': 'KeyA',
+      'location': 0,
+      'key': 'a',
+      'metaState': 0x0,
+      'keyCode': 1,
+    });
+    expect(preventedDefault, isTrue);
+    preventedDefault = false;
+
+    converter.handleEvent(keyRepeatedDownEvent('KeyA', 'a')
+      ..timeStamp = 1.5
+      ..onPreventDefault = onPreventDefault
+    );
+    expectKeyData(keyDataList.last,
+      timeStamp: const Duration(milliseconds: 1, microseconds: 500),
+      type: ui.KeyEventType.repeat,
+      physical: kPhysicalKeyA,
+      logical: kLogicalKeyA,
+      character: 'a',
+    );
+    expect(preventedDefault, isFalse);
+
+    converter.handleEvent(keyRepeatedDownEvent('KeyA', 'a')
+      ..timeStamp = 1500
+      ..onPreventDefault = onPreventDefault
+    );
+    expectKeyData(keyDataList.last,
+      timeStamp: const Duration(seconds: 1, milliseconds: 500),
+      type: ui.KeyEventType.repeat,
+      physical: kPhysicalKeyA,
+      logical: kLogicalKeyA,
+      character: 'a',
+    );
+    expect(preventedDefault, isFalse);
+
+    converter.handleEvent(keyUpEvent('KeyA', 'a')
+      ..timeStamp = 2000.5
+      ..onPreventDefault = onPreventDefault
+    );
+    expectKeyData(keyDataList.last,
+      timeStamp: const Duration(seconds: 2, microseconds: 500),
+      type: ui.KeyEventType.up,
+      physical: kPhysicalKeyA,
+      logical: kLogicalKeyA,
+      character: null,
+    );
+    expect(preventedDefault, isFalse);
+  });
+}
+
+class MockKeyboardEvent implements FlutterHtmlKeyboardEvent {
+  MockKeyboardEvent({
+    required this.type,
+    required this.code,
+    required this.key,
+    this.timeStamp = 0,
+    this.repeat = false,
+    this.altKey = false,
+    this.ctrlKey = false,
+    this.shiftKey = false,
+    this.metaKey = false,
+    this.location = 0,
+    this.onPreventDefault,
+  });
+
+  @override
+  String type;
+
+  @override
+  String? code;
+
+  @override
+  String? key;
+
+  @override
+  bool? repeat;
+
+  @override
+  num? timeStamp;
+
+  @override
+  bool altKey;
+
+  @override
+  bool ctrlKey;
+
+  @override
+  bool shiftKey;
+
+  @override
+  bool metaKey;
+
+  @override
+  int? location;
+
+  @override
+  bool getModifierState(String key) => modifierState.contains(key);
+  final Set<String> modifierState = <String>{};
+
+  @override
+  void preventDefault() { onPreventDefault?.call(); }
+  VoidCallback? onPreventDefault;
+}
+
+// Flags used for the `modifiers` argument of `key***Event` functions.
+const int kAlt = 0x1;
+const int kCtrl = 0x2;
+const int kShift = 0x4;
+const int kMeta = 0x8;
+
+// Utility functions to make code more concise.
+//
+// To add timeStamp or onPreventDefault, use syntax like `..timeStamp = `.
+MockKeyboardEvent keyDownEvent(String code, String key, [int modifiers = 0, int location = 0]) {
+  return MockKeyboardEvent(
+    type: 'keydown',
+    code: code,
+    key: key,
+    altKey: modifiers & kAlt != 0,
+    ctrlKey: modifiers & kCtrl != 0,
+    shiftKey: modifiers & kShift != 0,
+    metaKey: modifiers & kMeta != 0,
+    location: location,
+  );
+}
+
+MockKeyboardEvent keyUpEvent(String code, String key, [int modifiers = 0, int location = 0]) {
+  return MockKeyboardEvent(
+    type: 'keyup',
+    code: code,
+    key: key,
+    altKey: modifiers & kAlt != 0,
+    ctrlKey: modifiers & kCtrl != 0,
+    shiftKey: modifiers & kShift != 0,
+    metaKey: modifiers & kMeta != 0,
+    location: location,
+  );
+}
+
+MockKeyboardEvent keyRepeatedDownEvent(String code, String key, [int modifiers = 0, int location = 0]) {
+  return MockKeyboardEvent(
+    type: 'keydown',
+    code: code,
+    key: key,
+    altKey: modifiers & kAlt != 0,
+    ctrlKey: modifiers & kCtrl != 0,
+    shiftKey: modifiers & kShift != 0,
+    metaKey: modifiers & kMeta != 0,
+    repeat: true,
+    location: location,
+  );
+}
+
+// Flags used for the `activeLocks` argument of expectKeyData.
+const int kCapsLock = 0x1;
+const int kNumlLock = 0x2;
+const int kScrollLock = 0x4;
+
+void expectKeyData(
+  ui.KeyData target, {
+  required ui.KeyEventType type,
+  required int physical,
+  required int logical,
+  required String? character,
+  Duration? timeStamp,
+  bool synthesized = false,
+}) {
+  expect(target.type, type);
+  expect(target.physical, physical);
+  expect(target.logical, logical);
+  expect(target.character, character);
+  expect(target.synthesized, synthesized);
+  if (timeStamp != null)
+    expect(target.timeStamp, equals(timeStamp));
+}
+
+typedef FakeAsyncTest = void Function(FakeAsync);
+
+@isTest
+void testFakeAsync(String description, FakeAsyncTest fn) {
+  test(description, () {
+    FakeAsync().run(fn);
+  });
+}