Flutter iOS Embedder
FlutterEmbedderKeyResponderTest.mm
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #import <Foundation/Foundation.h>
6 #import <XCTest/XCTest.h>
7 #include <_types/_uint64_t.h>
8 
13 #include "flutter/shell/platform/embedder/embedder.h"
14 #include "flutter/shell/platform/embedder/test_utils/key_codes.g.h"
15 
16 using namespace flutter::testing::keycodes;
17 using namespace flutter::testing;
18 
20 
21 #define XCTAssertStrEqual(value, expected) \
22  XCTAssertTrue(strcmp(value, expected) == 0, \
23  @"String \"%s\" not equal to the expected value of \"%s\"", value, expected)
24 
25 // A wrap to convert FlutterKeyEvent to a ObjC class.
26 @interface TestKeyEvent : NSObject
27 @property(nonatomic) FlutterKeyEvent* data;
28 @property(nonatomic) FlutterKeyEventCallback callback;
29 @property(nonatomic, nullable) void* userData;
30 @end
31 
32 @implementation TestKeyEvent
33 - (instancetype)initWithEvent:(const FlutterKeyEvent*)event
34  callback:(nullable FlutterKeyEventCallback)callback
35  userData:(nullable void*)userData {
36  self = [super init];
37  _data = new FlutterKeyEvent(*event);
38  if (event->character != nullptr) {
39  size_t len = strlen(event->character);
40  char* character = new char[len + 1];
41  strlcpy(character, event->character, len + 1);
42  _data->character = character;
43  }
44  _callback = callback;
45  _userData = userData;
46  return self;
47 }
48 
49 - (BOOL)hasCallback {
50  return _callback != nil;
51 }
52 
53 - (void)respond:(BOOL)handled {
54  NSAssert(
55  _callback != nil,
56  @"Improper call to `respond` that does not have a callback."); // Caller's responsibility
57  _callback(handled, _userData);
58 }
59 
60 - (void)dealloc {
61  if (_data->character != nullptr) {
62  delete[] _data->character;
63  }
64  delete _data;
65 }
66 @end
67 
68 namespace {
69 API_AVAILABLE(ios(13.4))
70 constexpr UIKeyboardHIDUsage kKeyCodeUndefined = (UIKeyboardHIDUsage)0x03;
71 API_AVAILABLE(ios(13.4))
72 constexpr UIKeyboardHIDUsage kKeyCodeKeyA = (UIKeyboardHIDUsage)0x04;
73 API_AVAILABLE(ios(13.4))
74 constexpr UIKeyboardHIDUsage kKeyCodePeriod = (UIKeyboardHIDUsage)0x37;
75 API_AVAILABLE(ios(13.4))
76 constexpr UIKeyboardHIDUsage kKeyCodeKeyW = (UIKeyboardHIDUsage)0x1a;
77 API_AVAILABLE(ios(13.4))
78 constexpr UIKeyboardHIDUsage kKeyCodeShiftLeft = (UIKeyboardHIDUsage)0xe1;
79 API_AVAILABLE(ios(13.4))
80 constexpr UIKeyboardHIDUsage kKeyCodeShiftRight = (UIKeyboardHIDUsage)0xe5;
81 API_AVAILABLE(ios(13.4))
82 constexpr UIKeyboardHIDUsage kKeyCodeNumpad1 = (UIKeyboardHIDUsage)0x59;
83 API_AVAILABLE(ios(13.4))
84 constexpr UIKeyboardHIDUsage kKeyCodeCapsLock = (UIKeyboardHIDUsage)0x39;
85 API_AVAILABLE(ios(13.4))
86 constexpr UIKeyboardHIDUsage kKeyCodeF1 = (UIKeyboardHIDUsage)0x3a;
87 API_AVAILABLE(ios(13.4))
88 constexpr UIKeyboardHIDUsage kKeyCodeCommandLeft = (UIKeyboardHIDUsage)0xe3;
89 API_AVAILABLE(ios(13.4))
90 constexpr UIKeyboardHIDUsage kKeyCodeAltRight = (UIKeyboardHIDUsage)0xe6;
91 API_AVAILABLE(ios(13.4))
92 constexpr UIKeyboardHIDUsage kKeyCodeEject = (UIKeyboardHIDUsage)0xb8;
93 
94 constexpr uint64_t kPhysicalKeyUndefined = 0x00070003;
95 
96 constexpr uint64_t kLogicalKeyUndefined = 0x1300000003;
97 
98 constexpr uint64_t kModifierFlagNone = 0x0;
99 
100 typedef void (^ResponseCallback)(bool handled);
101 } // namespace
102 
103 @interface FlutterEmbedderKeyResponderTest : XCTestCase
104 @end
105 
106 @implementation FlutterEmbedderKeyResponderTest
107 
108 - (void)setUp {
109  // All of these tests were designed to run on iOS 13.4 or later.
110  if (@available(iOS 13.4, *)) {
111  } else {
112  XCTSkip(@"Required API not present for test.");
113  }
114 }
115 
116 - (void)tearDown {
117 }
118 
119 // Test the most basic key events.
120 //
121 // Press, hold, and release key A on an US keyboard.
122 - (void)testBasicKeyEvent API_AVAILABLE(ios(13.4)) {
123  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
124  __block BOOL last_handled = TRUE;
125  FlutterKeyEvent* event;
126 
128  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
129  void* _Nullable user_data) {
130  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
131  callback:callback
132  userData:user_data]];
133  }];
134 
135  last_handled = FALSE;
136  [responder handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "a", "a")
137  callback:^(BOOL handled) {
138  last_handled = handled;
139  }];
140 
141  XCTAssertEqual([events count], 1u);
142  event = [events lastObject].data;
143  XCTAssertNotEqual(event, nullptr);
144  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
145  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
146  XCTAssertEqual(event->timestamp, 123000000.0f);
147  XCTAssertEqual(event->physical, kPhysicalKeyA);
148  XCTAssertEqual(event->logical, kLogicalKeyA);
149  XCTAssertStrEqual(event->character, "a");
150  XCTAssertEqual(event->synthesized, false);
151 
152  XCTAssertEqual(last_handled, FALSE);
153  XCTAssert([[events lastObject] hasCallback]);
154  [[events lastObject] respond:TRUE];
155  XCTAssertEqual(last_handled, TRUE);
156 
157  [events removeAllObjects];
158 
159  last_handled = TRUE;
160  [responder handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f)
161  callback:^(BOOL handled) {
162  last_handled = handled;
163  }];
164 
165  XCTAssertEqual([events count], 1u);
166  event = [events lastObject].data;
167  XCTAssertNotEqual(event, nullptr);
168  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
169  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
170  XCTAssertEqual(event->timestamp, 123000000.0f);
171  XCTAssertEqual(event->physical, kPhysicalKeyA);
172  XCTAssertEqual(event->logical, kLogicalKeyA);
173  XCTAssertEqual(event->character, nullptr);
174  XCTAssertEqual(event->synthesized, false);
175 
176  XCTAssertEqual(last_handled, TRUE);
177  XCTAssert([[events lastObject] hasCallback]);
178  [[events lastObject] respond:FALSE]; // Check if responding FALSE works
179  XCTAssertEqual(last_handled, FALSE);
180 
181  [events removeAllObjects];
182 }
183 
184 - (void)testIosKeyPlane API_AVAILABLE(ios(13.4)) {
185  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
186  __block BOOL last_handled = TRUE;
187  FlutterKeyEvent* event;
188 
190  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
191  void* _Nullable user_data) {
192  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
193  callback:callback
194  userData:user_data]];
195  }];
196 
197  last_handled = FALSE;
198  // Verify that the eject key (keycode 0xb8, which is not present in the keymap)
199  // should be translated to the right logical and physical keys.
200  [responder handlePress:keyDownEvent(kKeyCodeEject, kModifierFlagNone, 123.0f)
201  callback:^(BOOL handled) {
202  last_handled = handled;
203  }];
204 
205  XCTAssertEqual([events count], 1u);
206  event = [events lastObject].data;
207  XCTAssertNotEqual(event, nullptr);
208  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
209  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
210  XCTAssertEqual(event->physical, kKeyCodeEject | kIosPlane);
211  XCTAssertEqual(event->logical, kKeyCodeEject | kIosPlane);
212  XCTAssertEqual(event->character, nullptr);
213  XCTAssertEqual(event->synthesized, false);
214 
215  XCTAssertEqual(last_handled, FALSE);
216  XCTAssert([[events lastObject] hasCallback]);
217  [[events lastObject] respond:TRUE];
218  XCTAssertEqual(last_handled, TRUE);
219 
220  [events removeAllObjects];
221 
222  last_handled = TRUE;
223  [responder handlePress:keyUpEvent(kKeyCodeEject, kModifierFlagNone, 123.0f)
224  callback:^(BOOL handled) {
225  last_handled = handled;
226  }];
227 
228  XCTAssertEqual([events count], 1u);
229  event = [events lastObject].data;
230  XCTAssertNotEqual(event, nullptr);
231  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
232  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
233  XCTAssertEqual(event->physical, kKeyCodeEject | kIosPlane);
234  XCTAssertEqual(event->logical, kKeyCodeEject | kIosPlane);
235  XCTAssertEqual(event->character, nullptr);
236  XCTAssertEqual(event->synthesized, false);
237 
238  XCTAssertEqual(last_handled, TRUE);
239  XCTAssert([[events lastObject] hasCallback]);
240  [[events lastObject] respond:FALSE]; // Check if responding FALSE works
241  XCTAssertEqual(last_handled, FALSE);
242 
243  [events removeAllObjects];
244 }
245 
246 - (void)testOutOfOrderModifiers API_AVAILABLE(ios(13.4)) {
247  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
248  FlutterKeyEvent* event;
249 
251  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
252  void* _Nullable user_data) {
253  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
254  callback:callback
255  userData:user_data]];
256  }];
257 
258  // This tests that we synthesize the correct modifier keys when we release the
259  // modifier key that created the letter before we release the letter.
260  [responder handlePress:keyDownEvent(kKeyCodeAltRight, kModifierFlagAltAny, 123.0f)
261  callback:^(BOOL handled){
262  }];
263 
264  XCTAssertEqual([events count], 1u);
265  event = [events lastObject].data;
266  XCTAssertNotEqual(event, nullptr);
267  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
268  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
269  XCTAssertEqual(event->physical, kPhysicalAltRight);
270  XCTAssertEqual(event->logical, kLogicalAltRight);
271  XCTAssertEqual(event->character, nullptr);
272  XCTAssertEqual(event->synthesized, false);
273 
274  [events removeAllObjects];
275 
276  // Test non-ASCII characters being produced.
277  [responder handlePress:keyDownEvent(kKeyCodeKeyW, kModifierFlagAltAny, 123.0f, "���", "w")
278  callback:^(BOOL handled){
279  }];
280 
281  XCTAssertEqual([events count], 1u);
282  event = [events lastObject].data;
283  XCTAssertNotEqual(event, nullptr);
284  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
285  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
286  XCTAssertEqual(event->physical, kPhysicalKeyW);
287  XCTAssertEqual(event->logical, kLogicalKeyW);
288  XCTAssertStrEqual(event->character, "∑");
289  XCTAssertEqual(event->synthesized, false);
290 
291  [events removeAllObjects];
292 
293  // Releasing the modifier key before the letter should send the key up to the
294  // framework.
295  [responder handlePress:keyUpEvent(kKeyCodeAltRight, kModifierFlagAltAny, 123.0f)
296  callback:^(BOOL handled){
297  }];
298 
299  XCTAssertEqual([events count], 1u);
300  event = [events lastObject].data;
301  XCTAssertNotEqual(event, nullptr);
302  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
303  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
304  XCTAssertEqual(event->physical, kPhysicalAltRight);
305  XCTAssertEqual(event->logical, kLogicalAltRight);
306  XCTAssertEqual(event->character, nullptr);
307  XCTAssertEqual(event->synthesized, false);
308 
309  [events removeAllObjects];
310 
311  // Yes, iOS sends a modifier flag for the Alt key being down on this event,
312  // even though the Alt (Option) key has already been released. This means that
313  // for the framework to be in the correct state, we must synthesize a key down
314  // event for the modifier key here, and another key up before the next key
315  // event.
316  [responder handlePress:keyUpEvent(kKeyCodeKeyW, kModifierFlagAltAny, 123.0f)
317  callback:^(BOOL handled){
318  }];
319 
320  XCTAssertEqual([events count], 1u);
321  event = [events lastObject].data;
322  XCTAssertNotEqual(event, nullptr);
323  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
324  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
325  XCTAssertEqual(event->physical, kPhysicalKeyW);
326  XCTAssertEqual(event->logical, kLogicalKeyW);
327  XCTAssertEqual(event->character, nullptr);
328  XCTAssertEqual(event->synthesized, false);
329 
330  [events removeAllObjects];
331 
332  // Here we should simulate a key up for the Alt key, since it is no longer
333  // shown as down in the modifier flags.
334  [responder handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "��", "a")
335  callback:^(BOOL handled){
336  }];
337 
338  XCTAssertEqual([events count], 1u);
339  event = [events lastObject].data;
340  XCTAssertNotEqual(event, nullptr);
341  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
342  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
343  XCTAssertEqual(event->physical, kPhysicalKeyA);
344  XCTAssertEqual(event->logical, kLogicalKeyA);
345  XCTAssertStrEqual(event->character, "å");
346  XCTAssertEqual(event->synthesized, false);
347 }
348 
349 - (void)testIgnoreDuplicateDownEvent API_AVAILABLE(ios(13.4)) {
350  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
351  __block BOOL last_handled = TRUE;
352  FlutterKeyEvent* event;
353 
355  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
356  void* _Nullable user_data) {
357  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
358  callback:callback
359  userData:user_data]];
360  }];
361 
362  last_handled = FALSE;
363  [responder handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "a", "a")
364  callback:^(BOOL handled) {
365  last_handled = handled;
366  }];
367 
368  XCTAssertEqual([events count], 1u);
369  event = [events lastObject].data;
370  XCTAssertNotEqual(event, nullptr);
371  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
372  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
373  XCTAssertEqual(event->physical, kPhysicalKeyA);
374  XCTAssertEqual(event->logical, kLogicalKeyA);
375  XCTAssertStrEqual(event->character, "a");
376  XCTAssertEqual(event->synthesized, false);
377  XCTAssertEqual(last_handled, FALSE);
378  [[events lastObject] respond:TRUE];
379  XCTAssertEqual(last_handled, TRUE);
380 
381  [events removeAllObjects];
382 
383  last_handled = FALSE;
384  [responder handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "a", "a")
385  callback:^(BOOL handled) {
386  last_handled = handled;
387  }];
388 
389  XCTAssertEqual([events count], 1u);
390  event = [events lastObject].data;
391  XCTAssertNotEqual(event, nullptr);
392  XCTAssertEqual(event->physical, 0ull);
393  XCTAssertEqual(event->logical, 0ull);
394  XCTAssertEqual(event->synthesized, false);
395  XCTAssertFalse([[events lastObject] hasCallback]);
396  XCTAssertEqual(last_handled, TRUE);
397 
398  [events removeAllObjects];
399 
400  last_handled = FALSE;
401  [responder handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f)
402  callback:^(BOOL handled) {
403  last_handled = handled;
404  }];
405 
406  XCTAssertEqual([events count], 1u);
407  event = [events lastObject].data;
408  XCTAssertNotEqual(event, nullptr);
409  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
410  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
411  XCTAssertEqual(event->physical, kPhysicalKeyA);
412  XCTAssertEqual(event->logical, kLogicalKeyA);
413  XCTAssertEqual(event->character, nullptr);
414  XCTAssertEqual(event->synthesized, false);
415  XCTAssertEqual(last_handled, FALSE);
416  [[events lastObject] respond:TRUE];
417  XCTAssertEqual(last_handled, TRUE);
418 
419  [events removeAllObjects];
420 }
421 
422 - (void)testIgnoreAbruptUpEvent API_AVAILABLE(ios(13.4)) {
423  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
424  __block BOOL last_handled = TRUE;
425  FlutterKeyEvent* event;
426 
428  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
429  void* _Nullable user_data) {
430  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
431  callback:callback
432  userData:user_data]];
433  }];
434 
435  last_handled = FALSE;
436  [responder handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f)
437  callback:^(BOOL handled) {
438  last_handled = handled;
439  }];
440 
441  XCTAssertEqual([events count], 1u);
442  event = [events lastObject].data;
443  XCTAssertNotEqual(event, nullptr);
444  XCTAssertEqual(event->physical, 0ull);
445  XCTAssertEqual(event->logical, 0ull);
446  XCTAssertEqual(event->synthesized, false);
447  XCTAssertFalse([[events lastObject] hasCallback]);
448  XCTAssertEqual(last_handled, TRUE);
449 
450  [events removeAllObjects];
451 }
452 
453 // Press R-Shift, A, then release R-Shift then A, on a US keyboard.
454 //
455 // This is special because the characters for the A key will change in this
456 // process.
457 - (void)testToggleModifiersDuringKeyTap API_AVAILABLE(ios(13.4)) {
458  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
459  FlutterKeyEvent* event;
460 
462  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
463  void* _Nullable user_data) {
464  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
465  callback:callback
466  userData:user_data]];
467  }];
468 
469  [responder handlePress:keyDownEvent(kKeyCodeShiftRight, kModifierFlagShiftAny, 123.0f)
470  callback:^(BOOL handled){
471  }];
472 
473  XCTAssertEqual([events count], 1u);
474 
475  event = [events lastObject].data;
476  XCTAssertNotEqual(event, nullptr);
477  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
478  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
479  XCTAssertEqual(event->timestamp, 123000000.0f);
480  XCTAssertEqual(event->physical, kPhysicalShiftRight);
481  XCTAssertEqual(event->logical, kLogicalShiftRight);
482  XCTAssertEqual(event->character, nullptr);
483  XCTAssertEqual(event->synthesized, false);
484  [[events lastObject] respond:TRUE];
485 
486  [events removeAllObjects];
487 
488  [responder handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagShiftAny, 123.0f, "A", "A")
489  callback:^(BOOL handled){
490  }];
491 
492  XCTAssertEqual([events count], 1u);
493  event = [events lastObject].data;
494  XCTAssertNotEqual(event, nullptr);
495  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
496  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
497  XCTAssertEqual(event->physical, kPhysicalKeyA);
498  XCTAssertEqual(event->logical, kLogicalKeyA);
499  XCTAssertStrEqual(event->character, "A");
500  XCTAssertEqual(event->synthesized, false);
501  [[events lastObject] respond:TRUE];
502 
503  [events removeAllObjects];
504 
505  [responder handlePress:keyUpEvent(kKeyCodeShiftRight, kModifierFlagNone, 123.0f)
506  callback:^(BOOL handled){
507  }];
508 
509  XCTAssertEqual([events count], 1u);
510  event = [events lastObject].data;
511  XCTAssertNotEqual(event, nullptr);
512  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
513  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
514  XCTAssertEqual(event->physical, kPhysicalShiftRight);
515  XCTAssertEqual(event->logical, kLogicalShiftRight);
516  XCTAssertEqual(event->character, nullptr);
517  XCTAssertEqual(event->synthesized, false);
518  [[events lastObject] respond:TRUE];
519 
520  [events removeAllObjects];
521 
522  [responder handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f)
523  callback:^(BOOL handled){
524  }];
525 
526  XCTAssertEqual([events count], 1u);
527  event = [events lastObject].data;
528  XCTAssertNotEqual(event, nullptr);
529  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
530  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
531  XCTAssertEqual(event->physical, kPhysicalKeyA);
532  XCTAssertEqual(event->logical, kLogicalKeyA);
533  XCTAssertEqual(event->character, nullptr);
534  XCTAssertEqual(event->synthesized, false);
535  [[events lastObject] respond:TRUE];
536 
537  [events removeAllObjects];
538 }
539 
540 // Special modifier flags.
541 //
542 // Some keys in modifierFlags are not to indicate modifier state, but to mark
543 // the key area that the key belongs to, such as numpad keys or function keys.
544 // Ensure these flags do not obstruct other keys.
545 - (void)testSpecialModiferFlags API_AVAILABLE(ios(13.4)) {
546  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
547  FlutterKeyEvent* event;
548  __block BOOL last_handled = TRUE;
549  id keyEventCallback = ^(BOOL handled) {
550  last_handled = handled;
551  };
552 
554  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
555  void* _Nullable user_data) {
556  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
557  callback:callback
558  userData:user_data]];
559  }];
560 
561  // Keydown: Numpad1, Fn (undefined), F1, KeyA, ShiftLeft
562  // Then KeyUp: Numpad1, Fn (undefined), F1, KeyA, ShiftLeft
563 
564  // Numpad 1
565  // OS provides: char: "1", code: 0x59, modifiers: 0x200000
566  [responder handlePress:keyDownEvent(kKeyCodeNumpad1, kModifierFlagNumPadKey, 123.0, "1", "1")
567  callback:keyEventCallback];
568 
569  XCTAssertEqual([events count], 1u);
570  event = [events lastObject].data;
571  XCTAssertNotEqual(event, nullptr);
572  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
573  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
574  XCTAssertEqual(event->physical, kPhysicalNumpad1);
575  XCTAssertEqual(event->logical, kLogicalNumpad1);
576  XCTAssertStrEqual(event->character, "1");
577  XCTAssertEqual(event->synthesized, false);
578  [[events lastObject] respond:TRUE];
579 
580  [events removeAllObjects];
581 
582  // Fn Key (sends HID undefined)
583  // OS provides: char: nil, keycode: 0x3, modifiers: 0x0
584  [responder handlePress:keyDownEvent(kKeyCodeUndefined, kModifierFlagNone, 123.0)
585  callback:keyEventCallback];
586 
587  XCTAssertEqual([events count], 1u);
588  event = [events lastObject].data;
589  XCTAssertNotEqual(event, nullptr);
590  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
591  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
592  XCTAssertEqual(event->physical, kPhysicalKeyUndefined);
593  XCTAssertEqual(event->logical, kLogicalKeyUndefined);
594  XCTAssertEqual(event->character, nullptr);
595  XCTAssertEqual(event->synthesized, false);
596  [[events lastObject] respond:TRUE];
597 
598  [events removeAllObjects];
599 
600  // F1 Down
601  // OS provides: char: UIKeyInputF1, code: 0x3a, modifiers: 0x0
602  [responder handlePress:keyDownEvent(kKeyCodeF1, kModifierFlagNone, 123.0f, "\\^P", "\\^P")
603  callback:keyEventCallback];
604 
605  XCTAssertEqual([events count], 1u);
606  event = [events lastObject].data;
607  XCTAssertNotEqual(event, nullptr);
608  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
609  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
610  XCTAssertEqual(event->physical, kPhysicalF1);
611  XCTAssertEqual(event->logical, kLogicalF1);
612  XCTAssertEqual(event->character, nullptr);
613  XCTAssertEqual(event->synthesized, false);
614  [[events lastObject] respond:TRUE];
615 
616  [events removeAllObjects];
617 
618  // KeyA Down
619  // OS provides: char: "q", code: 0x4, modifiers: 0x0
620  [responder handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "a", "a")
621  callback:keyEventCallback];
622 
623  XCTAssertEqual([events count], 1u);
624  event = [events lastObject].data;
625  XCTAssertNotEqual(event, nullptr);
626  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
627  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
628  XCTAssertEqual(event->physical, kPhysicalKeyA);
629  XCTAssertEqual(event->logical, kLogicalKeyA);
630  XCTAssertStrEqual(event->character, "a");
631  XCTAssertEqual(event->synthesized, false);
632  [[events lastObject] respond:TRUE];
633 
634  [events removeAllObjects];
635 
636  // ShiftLeft Down
637  // OS Provides: char: nil, code: 0xe1, modifiers: 0x20000
638  [responder handlePress:keyDownEvent(kKeyCodeShiftLeft, kModifierFlagShiftAny, 123.0f)
639  callback:keyEventCallback];
640 
641  XCTAssertEqual([events count], 1u);
642  event = [events lastObject].data;
643  XCTAssertNotEqual(event, nullptr);
644  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
645  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
646  XCTAssertEqual(event->physical, kPhysicalShiftLeft);
647  XCTAssertEqual(event->logical, kLogicalShiftLeft);
648  XCTAssertEqual(event->character, nullptr);
649  XCTAssertEqual(event->synthesized, false);
650 
651  [events removeAllObjects];
652 
653  // Numpad 1 Up
654  // OS provides: char: "1", code: 0x59, modifiers: 0x200000
655  [responder handlePress:keyUpEvent(kKeyCodeNumpad1, kModifierFlagNumPadKey, 123.0f)
656  callback:keyEventCallback];
657 
658  XCTAssertEqual([events count], 2u);
659 
660  // Because the OS no longer provides the 0x20000 (kModifierFlagShiftAny), we
661  // have to simulate a keyup.
662  event = [events firstObject].data;
663  XCTAssertNotEqual(event, nullptr);
664  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
665  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
666  XCTAssertEqual(event->physical, kPhysicalShiftLeft);
667  XCTAssertEqual(event->logical, kLogicalShiftLeft);
668  XCTAssertEqual(event->character, nullptr);
669  XCTAssertEqual(event->synthesized, true);
670 
671  event = [events lastObject].data;
672  XCTAssertNotEqual(event, nullptr);
673  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
674  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
675  XCTAssertEqual(event->physical, kPhysicalNumpad1);
676  XCTAssertEqual(event->logical, kLogicalNumpad1);
677  XCTAssertEqual(event->character, nullptr);
678  XCTAssertEqual(event->synthesized, false);
679  [[events lastObject] respond:TRUE];
680 
681  [events removeAllObjects];
682 
683  // F1 Up
684  // OS provides: char: UIKeyInputF1, code: 0x3a, modifiers: 0x0
685  [responder handlePress:keyUpEvent(kKeyCodeF1, kModifierFlagNone, 123.0f)
686  callback:keyEventCallback];
687 
688  XCTAssertEqual([events count], 1u);
689  event = [events lastObject].data;
690  XCTAssertNotEqual(event, nullptr);
691  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
692  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
693  XCTAssertEqual(event->physical, kPhysicalF1);
694  XCTAssertEqual(event->logical, kLogicalF1);
695  XCTAssertEqual(event->character, nullptr);
696  XCTAssertEqual(event->synthesized, false);
697  [[events lastObject] respond:TRUE];
698 
699  [events removeAllObjects];
700 
701  // Fn Key (sends HID undefined)
702  // OS provides: char: nil, code: 0x3, modifiers: 0x0
703  [responder handlePress:keyUpEvent(kKeyCodeUndefined, kModifierFlagNone, 123.0)
704  callback:keyEventCallback];
705 
706  XCTAssertEqual([events count], 1u);
707  event = [events lastObject].data;
708  XCTAssertNotEqual(event, nullptr);
709  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
710  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
711  XCTAssertEqual(event->physical, kPhysicalKeyUndefined);
712  XCTAssertEqual(event->logical, kLogicalKeyUndefined);
713  XCTAssertEqual(event->synthesized, false);
714  [[events lastObject] respond:TRUE];
715 
716  [events removeAllObjects];
717 
718  // KeyA Up
719  // OS provides: char: "a", code: 0x4, modifiers: 0x0
720  [responder handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f)
721  callback:keyEventCallback];
722 
723  XCTAssertEqual([events count], 1u);
724  event = [events lastObject].data;
725  XCTAssertNotEqual(event, nullptr);
726  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
727  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
728  XCTAssertEqual(event->physical, kPhysicalKeyA);
729  XCTAssertEqual(event->logical, kLogicalKeyA);
730  XCTAssertEqual(event->character, nullptr);
731  XCTAssertEqual(event->synthesized, false);
732  [[events lastObject] respond:TRUE];
733 
734  [events removeAllObjects];
735 
736  // ShiftLeft Up
737  // OS provides: char: nil, code: 0xe1, modifiers: 0x20000
738  [responder handlePress:keyUpEvent(kKeyCodeShiftLeft, kModifierFlagShiftAny, 123.0f)
739  callback:keyEventCallback];
740 
741  XCTAssertEqual([events count], 1u);
742  event = [events lastObject].data;
743  XCTAssertNotEqual(event, nullptr);
744  XCTAssertEqual(event->physical, 0ull);
745  XCTAssertEqual(event->logical, 0ull);
746  XCTAssertEqual(event->synthesized, false);
747  XCTAssertFalse([[events lastObject] hasCallback]);
748  XCTAssertEqual(last_handled, TRUE);
749 
750  [events removeAllObjects];
751 }
752 
753 - (void)testIdentifyLeftAndRightModifiers API_AVAILABLE(ios(13.4)) {
754  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
755  FlutterKeyEvent* event;
756 
758  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
759  void* _Nullable user_data) {
760  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
761  callback:callback
762  userData:user_data]];
763  }];
764 
765  [responder handlePress:keyDownEvent(kKeyCodeShiftLeft, kModifierFlagShiftAny, 123.0f)
766  callback:^(BOOL handled){
767  }];
768 
769  XCTAssertEqual([events count], 1u);
770  event = [events lastObject].data;
771  XCTAssertNotEqual(event, nullptr);
772  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
773  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
774  XCTAssertEqual(event->physical, kPhysicalShiftLeft);
775  XCTAssertEqual(event->logical, kLogicalShiftLeft);
776  XCTAssertEqual(event->character, nullptr);
777  XCTAssertEqual(event->synthesized, false);
778  [[events lastObject] respond:TRUE];
779 
780  [events removeAllObjects];
781 
782  [responder handlePress:keyDownEvent(kKeyCodeShiftRight, kModifierFlagShiftAny, 123.0f)
783  callback:^(BOOL handled){
784  }];
785 
786  XCTAssertEqual([events count], 1u);
787  event = [events lastObject].data;
788  XCTAssertNotEqual(event, nullptr);
789  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
790  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
791  XCTAssertEqual(event->physical, kPhysicalShiftRight);
792  XCTAssertEqual(event->logical, kLogicalShiftRight);
793  XCTAssertEqual(event->character, nullptr);
794  XCTAssertEqual(event->synthesized, false);
795  [[events lastObject] respond:TRUE];
796 
797  [events removeAllObjects];
798 
799  [responder handlePress:keyUpEvent(kKeyCodeShiftLeft, kModifierFlagShiftAny, 123.0f)
800  callback:^(BOOL handled){
801  }];
802 
803  XCTAssertEqual([events count], 1u);
804  event = [events lastObject].data;
805  XCTAssertNotEqual(event, nullptr);
806  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
807  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
808  XCTAssertEqual(event->physical, kPhysicalShiftLeft);
809  XCTAssertEqual(event->logical, kLogicalShiftLeft);
810  XCTAssertEqual(event->character, nullptr);
811  XCTAssertEqual(event->synthesized, false);
812  [[events lastObject] respond:TRUE];
813 
814  [events removeAllObjects];
815 
816  [responder handlePress:keyUpEvent(kKeyCodeShiftRight, kModifierFlagShiftAny, 123.0f)
817  callback:^(BOOL handled){
818  }];
819 
820  XCTAssertEqual([events count], 1u);
821  event = [events lastObject].data;
822  XCTAssertNotEqual(event, nullptr);
823  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
824  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
825  XCTAssertEqual(event->physical, kPhysicalShiftRight);
826  XCTAssertEqual(event->logical, kLogicalShiftRight);
827  XCTAssertEqual(event->character, nullptr);
828  XCTAssertEqual(event->synthesized, false);
829  [[events lastObject] respond:TRUE];
830 
831  [events removeAllObjects];
832 }
833 
834 // Press the CapsLock key when CapsLock state is desynchronized
835 - (void)testSynchronizeCapsLockStateOnCapsLock API_AVAILABLE(ios(13.4)) {
836  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
837  __block BOOL last_handled = TRUE;
838  id keyEventCallback = ^(BOOL handled) {
839  last_handled = handled;
840  };
841  FlutterKeyEvent* event;
842 
844  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
845  void* _Nullable user_data) {
846  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
847  callback:callback
848  userData:user_data]];
849  }];
850 
851  last_handled = FALSE;
852  [responder handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagCapsLock, 123.0f, "A", "A")
853  callback:keyEventCallback];
854 
855  XCTAssertEqual([events count], 3u);
856 
857  event = events[0].data;
858  XCTAssertNotEqual(event, nullptr);
859  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
860  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
861  XCTAssertEqual(event->physical, kPhysicalCapsLock);
862  XCTAssertEqual(event->logical, kLogicalCapsLock);
863  XCTAssertEqual(event->character, nullptr);
864  XCTAssertEqual(event->synthesized, true);
865  XCTAssertFalse([events[0] hasCallback]);
866 
867  event = events[1].data;
868  XCTAssertNotEqual(event, nullptr);
869  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
870  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
871  XCTAssertEqual(event->physical, kPhysicalCapsLock);
872  XCTAssertEqual(event->logical, kLogicalCapsLock);
873  XCTAssertEqual(event->character, nullptr);
874  XCTAssertEqual(event->synthesized, true);
875  XCTAssertFalse([events[1] hasCallback]);
876 
877  event = events[2].data;
878  XCTAssertNotEqual(event, nullptr);
879  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
880  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
881  XCTAssertEqual(event->physical, kPhysicalKeyA);
882  XCTAssertEqual(event->logical, kLogicalKeyA);
883  XCTAssertStrEqual(event->character, "A");
884  XCTAssertEqual(event->synthesized, false);
885  XCTAssert([events[2] hasCallback]);
886 
887  XCTAssertEqual(last_handled, FALSE);
888  [[events lastObject] respond:TRUE];
889  XCTAssertEqual(last_handled, TRUE);
890 
891  [events removeAllObjects];
892 
893  // Release the "A" key.
894  [responder handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagCapsLock, 123.0f)
895  callback:keyEventCallback];
896  XCTAssertEqual([events count], 1u);
897  event = [events lastObject].data;
898  XCTAssertNotEqual(event, nullptr);
899  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
900  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
901  XCTAssertEqual(event->physical, kPhysicalKeyA);
902  XCTAssertEqual(event->logical, kLogicalKeyA);
903  XCTAssertEqual(event->synthesized, false);
904 
905  [events removeAllObjects];
906 
907  // In: CapsLock down
908  // Out: CapsLock down
909  last_handled = FALSE;
910  [responder handlePress:keyDownEvent(kKeyCodeCapsLock, kModifierFlagCapsLock, 123.0f)
911  callback:keyEventCallback];
912 
913  XCTAssertEqual([events count], 1u);
914  event = [events firstObject].data;
915  XCTAssertNotEqual(event, nullptr);
916  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
917  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
918  XCTAssertEqual(event->physical, kPhysicalCapsLock);
919  XCTAssertEqual(event->logical, kLogicalCapsLock);
920  XCTAssertEqual(event->character, nullptr);
921  XCTAssertEqual(event->synthesized, false);
922  XCTAssert([[events firstObject] hasCallback]);
923 
924  [events removeAllObjects];
925 
926  // In: CapsLock up
927  // Out: CapsLock up
928  // This turns off the caps lock, triggering a synthesized up/down to tell the
929  // framework that.
930  last_handled = FALSE;
931  [responder handlePress:keyUpEvent(kKeyCodeCapsLock, kModifierFlagCapsLock, 123.0f)
932  callback:keyEventCallback];
933 
934  XCTAssertEqual([events count], 1u);
935  event = [events firstObject].data;
936  XCTAssertNotEqual(event, nullptr);
937  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
938  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
939  XCTAssertEqual(event->physical, kPhysicalCapsLock);
940  XCTAssertEqual(event->logical, kLogicalCapsLock);
941  XCTAssertEqual(event->character, nullptr);
942  XCTAssertEqual(event->synthesized, false);
943  XCTAssert([[events firstObject] hasCallback]);
944 
945  [events removeAllObjects];
946 
947  last_handled = FALSE;
948  [responder handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "a", "a")
949  callback:keyEventCallback];
950 
951  // Just to make sure that we aren't simulating events now, since the state is
952  // consistent, and should be off.
953  XCTAssertEqual([events count], 1u);
954  event = [events lastObject].data;
955  XCTAssertNotEqual(event, nullptr);
956  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
957  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
958  XCTAssertEqual(event->physical, kPhysicalKeyA);
959  XCTAssertEqual(event->logical, kLogicalKeyA);
960  XCTAssertStrEqual(event->character, "a");
961  XCTAssertEqual(event->synthesized, false);
962  XCTAssert([[events firstObject] hasCallback]);
963 }
964 
965 // Press the CapsLock key when CapsLock state is desynchronized
966 - (void)testSynchronizeCapsLockStateOnNormalKey API_AVAILABLE(ios(13.4)) {
967  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
968  __block BOOL last_handled = TRUE;
969  id keyEventCallback = ^(BOOL handled) {
970  last_handled = handled;
971  };
972  FlutterKeyEvent* event;
973 
975  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
976  void* _Nullable user_data) {
977  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
978  callback:callback
979  userData:user_data]];
980  }];
981 
982  last_handled = FALSE;
983  [responder handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagCapsLock, 123.0f, "A", "a")
984  callback:keyEventCallback];
985 
986  XCTAssertEqual([events count], 3u);
987 
988  event = events[0].data;
989  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
990  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
991  XCTAssertEqual(event->physical, kPhysicalCapsLock);
992  XCTAssertEqual(event->logical, kLogicalCapsLock);
993  XCTAssertEqual(event->character, nullptr);
994  XCTAssertEqual(event->synthesized, true);
995  XCTAssertFalse([events[0] hasCallback]);
996 
997  event = events[1].data;
998  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
999  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
1000  XCTAssertEqual(event->physical, kPhysicalCapsLock);
1001  XCTAssertEqual(event->logical, kLogicalCapsLock);
1002  XCTAssertEqual(event->character, nullptr);
1003  XCTAssertEqual(event->synthesized, true);
1004  XCTAssertFalse([events[1] hasCallback]);
1005 
1006  event = events[2].data;
1007  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
1008  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
1009  XCTAssertEqual(event->physical, kPhysicalKeyA);
1010  XCTAssertEqual(event->logical, kLogicalKeyA);
1011  XCTAssertStrEqual(event->character, "A");
1012  XCTAssertEqual(event->synthesized, false);
1013  XCTAssert([events[2] hasCallback]);
1014 
1015  XCTAssertEqual(last_handled, FALSE);
1016  [[events lastObject] respond:TRUE];
1017  XCTAssertEqual(last_handled, TRUE);
1018 
1019  [events removeAllObjects];
1020 }
1021 
1022 // Press Cmd-. should correctly result in an Escape event.
1023 - (void)testCommandPeriodKey API_AVAILABLE(ios(13.4)) {
1024  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
1025  id keyEventCallback = ^(BOOL handled) {
1026  };
1027  FlutterKeyEvent* event;
1028 
1030  initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
1031  void* _Nullable user_data) {
1032  [events addObject:[[TestKeyEvent alloc] initWithEvent:&event callback:nil userData:nil]];
1033  callback(true, user_data);
1034  }];
1035 
1036  // MetaLeft down.
1037  [responder handlePress:keyDownEvent(kKeyCodeCommandLeft, kModifierFlagMetaAny, 123.0f, "", "")
1038  callback:keyEventCallback];
1039  XCTAssertEqual([events count], 1u);
1040  event = events[0].data;
1041  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
1042  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
1043  XCTAssertEqual(event->physical, kPhysicalMetaLeft);
1044  XCTAssertEqual(event->logical, kLogicalMetaLeft);
1045  XCTAssertEqual(event->character, nullptr);
1046  XCTAssertEqual(event->synthesized, false);
1047  [events removeAllObjects];
1048 
1049  // Period down, which is logically Escape.
1050  [responder handlePress:keyDownEvent(kKeyCodePeriod, kModifierFlagMetaAny, 123.0f,
1051  "UIKeyInputEscape", "UIKeyInputEscape")
1052  callback:keyEventCallback];
1053  XCTAssertEqual([events count], 1u);
1054  event = events[0].data;
1055  XCTAssertEqual(event->type, kFlutterKeyEventTypeDown);
1056  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
1057  XCTAssertEqual(event->physical, kPhysicalPeriod);
1058  XCTAssertEqual(event->logical, kLogicalEscape);
1059  XCTAssertEqual(event->character, nullptr);
1060  XCTAssertEqual(event->synthesized, false);
1061  [events removeAllObjects];
1062 
1063  // Period up, which unconventionally has characters.
1064  [responder handlePress:keyUpEvent(kKeyCodePeriod, kModifierFlagMetaAny, 123.0f,
1065  "UIKeyInputEscape", "UIKeyInputEscape")
1066  callback:keyEventCallback];
1067  XCTAssertEqual([events count], 1u);
1068  event = events[0].data;
1069  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
1070  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
1071  XCTAssertEqual(event->physical, kPhysicalPeriod);
1072  XCTAssertEqual(event->logical, kLogicalEscape);
1073  XCTAssertEqual(event->character, nullptr);
1074  XCTAssertEqual(event->synthesized, false);
1075  [events removeAllObjects];
1076 
1077  // MetaLeft up.
1078  [responder handlePress:keyUpEvent(kKeyCodeCommandLeft, kModifierFlagMetaAny, 123.0f, "", "")
1079  callback:keyEventCallback];
1080  XCTAssertEqual([events count], 1u);
1081  event = events[0].data;
1082  XCTAssertEqual(event->type, kFlutterKeyEventTypeUp);
1083  XCTAssertEqual(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
1084  XCTAssertEqual(event->physical, kPhysicalMetaLeft);
1085  XCTAssertEqual(event->logical, kLogicalMetaLeft);
1086  XCTAssertEqual(event->character, nullptr);
1087  XCTAssertEqual(event->synthesized, false);
1088  [events removeAllObjects];
1089 }
1090 
1091 @end
#define XCTAssertStrEqual(value, expected)
UITextSmartQuotesType smartQuotesType API_AVAILABLE(ios(11.0))
const uint64_t kIosPlane
Definition: KeyCodeMap.g.mm:32
FlutterKeyEventCallback callback
void handlePress:callback:(nonnull FlutterUIPressProxy *press,[callback] ios(13.4) API_AVAILABLE)