5 #import <Foundation/Foundation.h>
6 #import <XCTest/XCTest.h>
7 #include <_types/_uint64_t.h>
13 #include "flutter/shell/platform/embedder/embedder.h"
14 #include "flutter/shell/platform/embedder/test_utils/key_codes.g.h"
16 using namespace flutter::testing::keycodes;
21 #define XCTAssertStrEqual(value, expected) \
22 XCTAssertTrue(strcmp(value, expected) == 0, \
23 @"String \"%s\" not equal to the expected value of \"%s\"", value, expected)
27 @property(nonatomic) FlutterKeyEvent* data;
28 @property(nonatomic) FlutterKeyEventCallback callback;
29 @property(nonatomic, nullable)
void* userData;
33 - (instancetype)initWithEvent:(const FlutterKeyEvent*)event
34 callback:(nullable FlutterKeyEventCallback)callback
35 userData:(nullable
void*)userData {
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;
50 return _callback != nil;
53 - (void)respond:(BOOL)handled {
56 @"Improper call to `respond` that does not have a callback.");
57 _callback(handled, _userData);
61 if (_data->character !=
nullptr) {
62 delete[] _data->character;
70 constexpr UIKeyboardHIDUsage kKeyCodeUndefined = (UIKeyboardHIDUsage)0x03;
72 constexpr UIKeyboardHIDUsage kKeyCodeKeyA = (UIKeyboardHIDUsage)0x04;
74 constexpr UIKeyboardHIDUsage kKeyCodePeriod = (UIKeyboardHIDUsage)0x37;
76 constexpr UIKeyboardHIDUsage kKeyCodeKeyW = (UIKeyboardHIDUsage)0x1a;
78 constexpr UIKeyboardHIDUsage kKeyCodeShiftLeft = (UIKeyboardHIDUsage)0xe1;
80 constexpr UIKeyboardHIDUsage kKeyCodeShiftRight = (UIKeyboardHIDUsage)0xe5;
82 constexpr UIKeyboardHIDUsage kKeyCodeNumpad1 = (UIKeyboardHIDUsage)0x59;
84 constexpr UIKeyboardHIDUsage kKeyCodeCapsLock = (UIKeyboardHIDUsage)0x39;
86 constexpr UIKeyboardHIDUsage kKeyCodeF1 = (UIKeyboardHIDUsage)0x3a;
88 constexpr UIKeyboardHIDUsage kKeyCodeCommandLeft = (UIKeyboardHIDUsage)0xe3;
90 constexpr UIKeyboardHIDUsage kKeyCodeAltRight = (UIKeyboardHIDUsage)0xe6;
92 constexpr UIKeyboardHIDUsage kKeyCodeEject = (UIKeyboardHIDUsage)0xb8;
94 constexpr uint64_t kPhysicalKeyUndefined = 0x00070003;
96 constexpr uint64_t kLogicalKeyUndefined = 0x1300000003;
98 constexpr uint64_t kModifierFlagNone = 0x0;
100 typedef
void (^ResponseCallback)(
bool handled);
110 if (@available(iOS 13.4, *)) {
112 XCTSkip(
@"Required API not present for test.");
123 __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
124 __block BOOL last_handled = TRUE;
125 FlutterKeyEvent* event;
128 initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
129 void* _Nullable user_data) {
130 [events addObject:[[
TestKeyEvent alloc] initWithEvent:&event
132 userData:user_data]];
135 last_handled = FALSE;
136 [responder
handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "a", "a")
138 last_handled = handled;
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);
150 XCTAssertEqual(event->synthesized,
false);
152 XCTAssertEqual(last_handled, FALSE);
153 XCTAssert([[events lastObject] hasCallback]);
154 [[events lastObject] respond:TRUE];
155 XCTAssertEqual(last_handled, TRUE);
157 [events removeAllObjects];
160 [responder
handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f)
162 last_handled = handled;
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);
176 XCTAssertEqual(last_handled, TRUE);
177 XCTAssert([[events lastObject] hasCallback]);
178 [[events lastObject] respond:FALSE];
179 XCTAssertEqual(last_handled, FALSE);
181 [events removeAllObjects];
185 __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
186 __block BOOL last_handled = TRUE;
187 FlutterKeyEvent* event;
190 initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
191 void* _Nullable user_data) {
192 [events addObject:[[
TestKeyEvent alloc] initWithEvent:&event
194 userData:user_data]];
197 last_handled = FALSE;
200 [responder
handlePress:keyDownEvent(kKeyCodeEject, kModifierFlagNone, 123.0f)
202 last_handled = handled;
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);
215 XCTAssertEqual(last_handled, FALSE);
216 XCTAssert([[events lastObject] hasCallback]);
217 [[events lastObject] respond:TRUE];
218 XCTAssertEqual(last_handled, TRUE);
220 [events removeAllObjects];
223 [responder
handlePress:keyUpEvent(kKeyCodeEject, kModifierFlagNone, 123.0f)
225 last_handled = handled;
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);
238 XCTAssertEqual(last_handled, TRUE);
239 XCTAssert([[events lastObject] hasCallback]);
240 [[events lastObject] respond:FALSE];
241 XCTAssertEqual(last_handled, FALSE);
243 [events removeAllObjects];
247 __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
248 FlutterKeyEvent* event;
251 initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
252 void* _Nullable user_data) {
253 [events addObject:[[
TestKeyEvent alloc] initWithEvent:&event
255 userData:user_data]];
260 [responder
handlePress:keyDownEvent(kKeyCodeAltRight, kModifierFlagAltAny, 123.0f)
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);
274 [events removeAllObjects];
277 [responder
handlePress:keyDownEvent(kKeyCodeKeyW, kModifierFlagAltAny, 123.0f, "� ��", "w")
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);
289 XCTAssertEqual(event->synthesized,
false);
291 [events removeAllObjects];
295 [responder
handlePress:keyUpEvent(kKeyCodeAltRight, kModifierFlagAltAny, 123.0f)
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);
309 [events removeAllObjects];
316 [responder
handlePress:keyUpEvent(kKeyCodeKeyW, kModifierFlagAltAny, 123.0f)
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);
330 [events removeAllObjects];
334 [responder
handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "� �", "a")
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);
346 XCTAssertEqual(event->synthesized,
false);
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;
355 initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
356 void* _Nullable user_data) {
357 [events addObject:[[
TestKeyEvent alloc] initWithEvent:&event
359 userData:user_data]];
362 last_handled = FALSE;
363 [responder
handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "a", "a")
365 last_handled = handled;
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);
376 XCTAssertEqual(event->synthesized,
false);
377 XCTAssertEqual(last_handled, FALSE);
378 [[events lastObject] respond:TRUE];
379 XCTAssertEqual(last_handled, TRUE);
381 [events removeAllObjects];
383 last_handled = FALSE;
384 [responder
handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "a", "a")
386 last_handled = handled;
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);
398 [events removeAllObjects];
400 last_handled = FALSE;
401 [responder
handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f)
403 last_handled = handled;
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);
419 [events removeAllObjects];
423 __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
424 __block BOOL last_handled = TRUE;
425 FlutterKeyEvent* event;
428 initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
429 void* _Nullable user_data) {
430 [events addObject:[[
TestKeyEvent alloc] initWithEvent:&event
432 userData:user_data]];
435 last_handled = FALSE;
436 [responder
handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f)
438 last_handled = handled;
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);
450 [events removeAllObjects];
457 - (void)testToggleModifiersDuringKeyTap
API_AVAILABLE(ios(13.4)) {
458 __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
459 FlutterKeyEvent* event;
462 initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
463 void* _Nullable user_data) {
464 [events addObject:[[
TestKeyEvent alloc] initWithEvent:&event
466 userData:user_data]];
469 [responder
handlePress:keyDownEvent(kKeyCodeShiftRight, kModifierFlagShiftAny, 123.0f)
473 XCTAssertEqual([events count], 1u);
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];
486 [events removeAllObjects];
488 [responder
handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagShiftAny, 123.0f, "A", "A")
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);
500 XCTAssertEqual(event->synthesized,
false);
501 [[events lastObject] respond:TRUE];
503 [events removeAllObjects];
505 [responder
handlePress:keyUpEvent(kKeyCodeShiftRight, kModifierFlagNone, 123.0f)
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];
520 [events removeAllObjects];
522 [responder
handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f)
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];
537 [events removeAllObjects];
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;
554 initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
555 void* _Nullable user_data) {
556 [events addObject:[[
TestKeyEvent alloc] initWithEvent:&event
558 userData:user_data]];
566 [responder
handlePress:keyDownEvent(kKeyCodeNumpad1, kModifierFlagNumPadKey, 123.0, "1", "1")
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);
577 XCTAssertEqual(event->synthesized,
false);
578 [[events lastObject] respond:TRUE];
580 [events removeAllObjects];
584 [responder
handlePress:keyDownEvent(kKeyCodeUndefined, kModifierFlagNone, 123.0)
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];
598 [events removeAllObjects];
602 [responder
handlePress:keyDownEvent(kKeyCodeF1, kModifierFlagNone, 123.0f, "\\^P", "\\^P")
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];
616 [events removeAllObjects];
620 [responder
handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "a", "a")
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);
631 XCTAssertEqual(event->synthesized,
false);
632 [[events lastObject] respond:TRUE];
634 [events removeAllObjects];
638 [responder
handlePress:keyDownEvent(kKeyCodeShiftLeft, kModifierFlagShiftAny, 123.0f)
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);
651 [events removeAllObjects];
655 [responder
handlePress:keyUpEvent(kKeyCodeNumpad1, kModifierFlagNumPadKey, 123.0f)
658 XCTAssertEqual([events count], 2u);
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);
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];
681 [events removeAllObjects];
685 [responder
handlePress:keyUpEvent(kKeyCodeF1, kModifierFlagNone, 123.0f)
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];
699 [events removeAllObjects];
703 [responder
handlePress:keyUpEvent(kKeyCodeUndefined, kModifierFlagNone, 123.0)
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];
716 [events removeAllObjects];
720 [responder
handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f)
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];
734 [events removeAllObjects];
738 [responder
handlePress:keyUpEvent(kKeyCodeShiftLeft, kModifierFlagShiftAny, 123.0f)
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);
750 [events removeAllObjects];
753 - (void)testIdentifyLeftAndRightModifiers
API_AVAILABLE(ios(13.4)) {
754 __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
755 FlutterKeyEvent* event;
758 initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
759 void* _Nullable user_data) {
760 [events addObject:[[
TestKeyEvent alloc] initWithEvent:&event
762 userData:user_data]];
765 [responder
handlePress:keyDownEvent(kKeyCodeShiftLeft, kModifierFlagShiftAny, 123.0f)
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];
780 [events removeAllObjects];
782 [responder
handlePress:keyDownEvent(kKeyCodeShiftRight, kModifierFlagShiftAny, 123.0f)
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];
797 [events removeAllObjects];
799 [responder
handlePress:keyUpEvent(kKeyCodeShiftLeft, kModifierFlagShiftAny, 123.0f)
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];
814 [events removeAllObjects];
816 [responder
handlePress:keyUpEvent(kKeyCodeShiftRight, kModifierFlagShiftAny, 123.0f)
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];
831 [events removeAllObjects];
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;
841 FlutterKeyEvent* event;
844 initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
845 void* _Nullable user_data) {
846 [events addObject:[[
TestKeyEvent alloc] initWithEvent:&event
848 userData:user_data]];
851 last_handled = FALSE;
852 [responder
handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagCapsLock, 123.0f, "A", "A")
855 XCTAssertEqual([events count], 3u);
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]);
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]);
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);
884 XCTAssertEqual(event->synthesized,
false);
885 XCTAssert([events[2] hasCallback]);
887 XCTAssertEqual(last_handled, FALSE);
888 [[events lastObject] respond:TRUE];
889 XCTAssertEqual(last_handled, TRUE);
891 [events removeAllObjects];
894 [responder
handlePress:keyUpEvent(kKeyCodeKeyA, kModifierFlagCapsLock, 123.0f)
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);
905 [events removeAllObjects];
909 last_handled = FALSE;
910 [responder
handlePress:keyDownEvent(kKeyCodeCapsLock, kModifierFlagCapsLock, 123.0f)
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]);
924 [events removeAllObjects];
930 last_handled = FALSE;
931 [responder
handlePress:keyUpEvent(kKeyCodeCapsLock, kModifierFlagCapsLock, 123.0f)
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]);
945 [events removeAllObjects];
947 last_handled = FALSE;
948 [responder
handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagNone, 123.0f, "a", "a")
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);
961 XCTAssertEqual(event->synthesized,
false);
962 XCTAssert([[events firstObject] hasCallback]);
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;
972 FlutterKeyEvent* event;
975 initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
976 void* _Nullable user_data) {
977 [events addObject:[[
TestKeyEvent alloc] initWithEvent:&event
979 userData:user_data]];
982 last_handled = FALSE;
983 [responder
handlePress:keyDownEvent(kKeyCodeKeyA, kModifierFlagCapsLock, 123.0f, "A", "a")
986 XCTAssertEqual([events count], 3u);
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]);
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]);
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);
1012 XCTAssertEqual(event->synthesized,
false);
1013 XCTAssert([events[2] hasCallback]);
1015 XCTAssertEqual(last_handled, FALSE);
1016 [[events lastObject] respond:TRUE];
1017 XCTAssertEqual(last_handled, TRUE);
1019 [events removeAllObjects];
1024 __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
1025 id keyEventCallback = ^(BOOL handled) {
1027 FlutterKeyEvent* event;
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);
1037 [responder
handlePress:keyDownEvent(kKeyCodeCommandLeft, kModifierFlagMetaAny, 123.0f, "", "")
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];
1050 [responder
handlePress:keyDownEvent(kKeyCodePeriod, kModifierFlagMetaAny, 123.0f,
1051 "UIKeyInputEscape", "UIKeyInputEscape")
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];
1064 [responder
handlePress:keyUpEvent(kKeyCodePeriod, kModifierFlagMetaAny, 123.0f,
1065 "UIKeyInputEscape", "UIKeyInputEscape")
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];
1078 [responder
handlePress:keyUpEvent(kKeyCodeCommandLeft, kModifierFlagMetaAny, 123.0f, "", "")
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];
#define XCTAssertStrEqual(value, expected)
UITextSmartQuotesType smartQuotesType API_AVAILABLE(ios(11.0))
FlutterKeyEventCallback callback
void handlePress:callback:(nonnull FlutterUIPressProxy *press,[callback] ios(13.4) API_AVAILABLE)