9 #import <OCMock/OCMock.h>
11 #include "flutter/common/constants.h"
12 #include "flutter/fml/platform/darwin/cf_utils.h"
20 #include "flutter/shell/platform/embedder/test_utils/key_codes.g.h"
21 #include "flutter/testing/autoreleasepool_test.h"
22 #include "flutter/testing/testing.h"
24 #pragma mark - Test Helper Classes
31 @property(nonatomic) FlutterKeyEvent*
data;
32 - (nonnull instancetype)initWithEvent:(
const FlutterKeyEvent*)event;
36 - (instancetype)initWithEvent:(
const FlutterKeyEvent*)
event {
38 _data =
new FlutterKeyEvent(*event);
58 - (instancetype)initWithResponder:(NSResponder*)responder {
59 if (
self = [super init]) {
65 - (void)keyDown:(NSEvent*)event {
66 [_responder keyDown:event];
69 - (void)keyUp:(NSEvent*)event {
70 [_responder keyUp:event];
73 - (BOOL)performKeyEquivalent:(NSEvent*)event {
74 return [_responder performKeyEquivalent:event];
77 - (void)flagsChanged:(NSEvent*)event {
78 [_responder flagsChanged:event];
86 @property(nonatomic, assign) BOOL mouseDownCalled;
87 @property(nonatomic, assign) BOOL mouseUpCalled;
91 - (void)mouseDown:(NSEvent*)event {
95 - (void)mouseUp:(NSEvent*)event {
96 self.mouseUpCalled = YES;
103 return [OCMArg checkWithBlock:^BOOL(NSData* message) {
109 - (bool)testKeyEventsAreSentToFramework:(
id)mockEngine;
110 - (bool)testKeyEventsArePropagatedIfNotHandled:(
id)mockEngine;
111 - (bool)testKeyEventsAreNotPropagatedIfHandled:(
id)mockEngine;
112 - (bool)testCtrlTabKeyEventIsPropagated:(
id)mockEngine;
113 - (bool)testKeyEquivalentIsPassedToTextInputPlugin:(
id)mockEngine;
114 - (bool)testFlagsChangedEventsArePropagatedIfNotHandled:(
id)mockEngine;
115 - (bool)testKeyboardIsRestartedOnEngineRestart:(
id)mockEngine;
116 - (bool)testTrackpadGesturesAreSentToFramework:(
id)mockEngine;
117 - (bool)mouseAndGestureEventsAreHandledSeparately:(
id)engineMock;
118 - (bool)testMouseDownUpEventsSentToNextResponder:(
id)mockEngine;
119 - (bool)testModifierKeysAreSynthesizedOnMouseMove:(
id)mockEngine;
120 - (bool)testViewWillAppearCalledMultipleTimes:(
id)mockEngine;
121 - (bool)testFlutterViewIsConfigured:(
id)mockEngine;
126 + (void)respondFalseForSendEvent:(const FlutterKeyEvent&)event
127 callback:(nullable FlutterKeyEventCallback)callback
128 userData:(nullable
void*)userData;
131 #pragma mark - Static helper functions
133 using namespace ::flutter::testing::keycodes;
139 id MockGestureEvent(NSEventType type, NSEventPhase phase,
double magnification,
double rotation) {
140 id event = [OCMockObject mockForClass:[NSEvent class]];
141 NSPoint locationInWindow = NSMakePoint(0, 0);
144 NSTimeInterval timestamp = 1;
145 NSUInteger modifierFlags = 0;
146 [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(type)] type];
147 [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(phase)] phase];
148 [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(locationInWindow)] locationInWindow];
149 [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(deltaX)] deltaX];
150 [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(deltaY)] deltaY];
151 [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(timestamp)] timestamp];
152 [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(modifierFlags)] modifierFlags];
153 [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(magnification)] magnification];
154 [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(rotation)] rotation];
160 NSString* fixtures = @(testing::GetFixturesPath());
162 initWithAssetsPath:fixtures
163 ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
164 return [[
FlutterEngine alloc] initWithName:@"test" project:project allowHeadlessExecution:true];
167 NSResponder* mockResponder() {
168 NSResponder* mock = OCMStrictClassMock([NSResponder
class]);
169 OCMStub([mock keyDown:[OCMArg any]]).andDo(nil);
170 OCMStub([mock keyUp:[OCMArg any]]).andDo(nil);
171 OCMStub([mock flagsChanged:[OCMArg any]]).andDo(nil);
175 NSEvent* CreateMouseEvent(NSEventModifierFlags modifierFlags) {
176 return [NSEvent mouseEventWithType:NSEventTypeMouseMoved
178 modifierFlags:modifierFlags
189 #pragma mark - gtest tests
198 [viewControllerMock loadView];
199 auto subViews = [viewControllerMock.view subviews];
201 EXPECT_EQ([subViews count], 1u);
202 EXPECT_EQ(subViews[0], viewControllerMock.flutterView);
204 NSTextField* textField = [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 1, 1)];
205 [viewControllerMock.view addSubview:textField];
207 subViews = [viewControllerMock.view subviews];
208 EXPECT_EQ([subViews count], 2u);
210 auto accessibilityChildren = viewControllerMock.view.accessibilityChildren;
212 EXPECT_EQ([accessibilityChildren count], 1u);
213 EXPECT_EQ(accessibilityChildren[0], viewControllerMock.flutterView);
218 [viewControllerMock loadView];
219 EXPECT_EQ([viewControllerMock.flutterView acceptsFirstMouse:nil], YES);
227 [viewController loadView];
229 NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
230 styleMask:NSBorderlessWindowMask
231 backing:NSBackingStoreBuffered
233 window.contentView = viewController.view;
234 NSView* dummyView = [[NSView alloc] initWithFrame:CGRectZero];
235 [viewController.view addSubview:dummyView];
237 NSDictionary* setClientConfig = @{
238 @"viewId" : @(flutter::kFlutterImplicitViewId),
245 [engine.textInputPlugin handleMethodCall:methodCall result:result];
248 [dummyView addSubview:engine.textInputPlugin];
251 EXPECT_TRUE([window makeFirstResponder:engine.textInputPlugin]);
252 EXPECT_EQ([window firstResponder], engine.textInputPlugin);
253 EXPECT_FALSE(engine.textInputPlugin.superview == viewController.view);
256 EXPECT_TRUE(viewController.
engine.textInputPlugin.superview == viewController.view);
260 NSString* fixtures = @(testing::GetFixturesPath());
262 initWithAssetsPath:fixtures
263 ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
266 ASSERT_EQ(viewController.
mouseTrackingMode, kFlutterMouseTrackingModeInActiveApp);
270 id mockEngine = GetMockEngine();
275 id mockEngine = GetMockEngine();
281 id mockEngine = GetMockEngine();
287 id mockEngine = GetMockEngine();
292 id mockEngine = GetMockEngine();
294 testKeyEquivalentIsPassedToTextInputPlugin:mockEngine]);
298 id mockEngine = GetMockEngine();
300 testFlagsChangedEventsArePropagatedIfNotHandled:mockEngine]);
304 id mockEngine = GetMockEngine();
310 id mockEngine = GetMockEngine();
316 id mockEngine = GetMockEngine();
322 id mockEngine = GetMockEngine();
328 id mockEngine = GetMockEngine();
334 id mockEngine = GetMockEngine();
340 id mockEngine = GetMockEngine();
358 #pragma mark - FlutterViewControllerTestObjC
362 - (bool)testKeyEventsAreSentToFramework:(
id)engineMock {
365 [engineMock binaryMessenger])
366 .andReturn(binaryMessengerMock);
369 OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
375 @selector(respondFalseForSendEvent:callback:userData:));
379 NSDictionary* expectedEvent = @{
380 @"keymap" :
@"macos",
381 @"type" :
@"keydown",
383 @"modifiers" : @(538968064),
384 @"characters" :
@".",
385 @"charactersIgnoringModifiers" :
@".",
388 CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 65, TRUE);
389 NSEvent*
event = [NSEvent eventWithCGEvent:cgEvent];
390 [viewController viewWillAppear];
391 [viewController keyDown:event];
394 [binaryMessengerMock sendOnChannel:
@"flutter/keyevent"
396 binaryReply:[OCMArg any]]);
404 - (bool)testCtrlTabKeyEventIsPropagated:(
id)engineMock {
405 __block
bool called =
false;
406 __block FlutterKeyEvent last_event;
410 .andDo((^(NSInvocation* invocation) {
411 FlutterKeyEvent* event;
412 [invocation getArgument:&event atIndex:2];
418 OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
424 NSEvent*
event = [NSEvent keyEventWithType:NSEventTypeKeyDown
426 modifierFlags:0x40101
431 charactersIgnoringModifiers:@""
434 const uint64_t kPhysicalKeyTab = 0x7002b;
436 [viewController viewWillAppear];
438 NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
439 styleMask:NSBorderlessWindowMask
440 backing:NSBackingStoreBuffered
442 window.contentView = viewController.view;
443 [window makeFirstResponder:viewController.flutterView];
444 [viewController.view performKeyEquivalent:event];
447 EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
448 EXPECT_EQ(last_event.physical, kPhysicalKeyTab);
452 - (bool)testKeyEquivalentIsPassedToTextInputPlugin:(
id)engineMock {
453 __block
bool called =
false;
454 __block FlutterKeyEvent last_event;
458 .andDo((^(NSInvocation* invocation) {
459 FlutterKeyEvent* event;
460 [invocation getArgument:&event atIndex:2];
468 NSEvent*
event = [NSEvent keyEventWithType:NSEventTypeKeyDown
470 modifierFlags:0x40101
475 charactersIgnoringModifiers:@""
478 const uint64_t kPhysicalKeyTab = 0x7002b;
480 [viewController viewWillAppear];
482 NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
483 styleMask:NSBorderlessWindowMask
484 backing:NSBackingStoreBuffered
486 window.contentView = viewController.view;
488 NSDictionary* setClientConfig = @{
489 @"viewId" : @(flutter::kFlutterImplicitViewId),
496 [viewController.engine.textInputPlugin handleMethodCall:methodCall result:result];
498 [viewController.engine.textInputPlugin
505 [window makeFirstResponder:viewController.engine.textInputPlugin];
507 [viewController.view performKeyEquivalent:event];
510 EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
511 EXPECT_EQ(last_event.physical, kPhysicalKeyTab);
515 - (bool)testKeyEventsArePropagatedIfNotHandled:(
id)engineMock {
518 [engineMock binaryMessenger])
519 .andReturn(binaryMessengerMock);
522 OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
527 @selector(respondFalseForSendEvent:callback:userData:));
531 id responderMock = flutter::testing::mockResponder();
533 viewController.nextResponder = responderWrapper;
534 NSDictionary* expectedEvent = @{
535 @"keymap" :
@"macos",
536 @"type" :
@"keydown",
538 @"modifiers" : @(538968064),
539 @"characters" :
@".",
540 @"charactersIgnoringModifiers" :
@".",
543 CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 65, TRUE);
544 NSEvent*
event = [NSEvent eventWithCGEvent:cgEvent];
546 [binaryMessengerMock sendOnChannel:
@"flutter/keyevent"
548 binaryReply:[OCMArg any]])
549 .andDo((^(NSInvocation* invocation) {
551 [invocation getArgument:&handler atIndex:4];
552 NSDictionary* reply = @{
553 @"handled" : @(
false),
556 handler(encodedReply);
558 [viewController viewWillAppear];
559 [viewController keyDown:event];
562 [responderMock keyDown:[OCMArg any]]);
564 [binaryMessengerMock sendOnChannel:
@"flutter/keyevent"
566 binaryReply:[OCMArg any]]);
573 - (bool)testFlutterViewIsConfigured:(
id)engineMock {
575 OCMStub([engineMock renderer]).andReturn(renderer_);
580 [viewController loadView];
584 OCMVerify([engineMock renderer]);
592 - (bool)testFlagsChangedEventsArePropagatedIfNotHandled:(
id)engineMock {
595 [engineMock binaryMessenger])
596 .andReturn(binaryMessengerMock);
599 OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
604 @selector(respondFalseForSendEvent:callback:userData:));
608 id responderMock = flutter::testing::mockResponder();
610 viewController.nextResponder = responderWrapper;
611 NSDictionary* expectedEvent = @{
612 @"keymap" :
@"macos",
613 @"type" :
@"keydown",
615 @"modifiers" : @(537001986),
618 CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 56, TRUE);
619 CGEventSetType(cgEvent, kCGEventFlagsChanged);
620 NSEvent*
event = [NSEvent eventWithCGEvent:cgEvent];
622 [binaryMessengerMock sendOnChannel:
@"flutter/keyevent"
624 binaryReply:[OCMArg any]])
625 .andDo((^(NSInvocation* invocation) {
627 [invocation getArgument:&handler atIndex:4];
628 NSDictionary* reply = @{
629 @"handled" : @(
false),
632 handler(encodedReply);
634 [viewController viewWillAppear];
635 [viewController flagsChanged:event];
638 [binaryMessengerMock sendOnChannel:
@"flutter/keyevent"
640 binaryReply:[OCMArg any]]);
641 }
@catch (NSException* e) {
642 NSLog(
@"%@", e.reason);
648 - (bool)testKeyEventsAreNotPropagatedIfHandled:(
id)engineMock {
651 [engineMock binaryMessenger])
652 .andReturn(binaryMessengerMock);
655 OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
660 @selector(respondFalseForSendEvent:callback:userData:));
664 id responderMock = flutter::testing::mockResponder();
666 viewController.nextResponder = responderWrapper;
667 NSDictionary* expectedEvent = @{
668 @"keymap" :
@"macos",
669 @"type" :
@"keydown",
671 @"modifiers" : @(538968064),
672 @"characters" :
@".",
673 @"charactersIgnoringModifiers" :
@".",
676 CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 65, TRUE);
677 NSEvent*
event = [NSEvent eventWithCGEvent:cgEvent];
679 [binaryMessengerMock sendOnChannel:
@"flutter/keyevent"
681 binaryReply:[OCMArg any]])
682 .andDo((^(NSInvocation* invocation) {
684 [invocation getArgument:&handler atIndex:4];
685 NSDictionary* reply = @{
686 @"handled" : @(
true),
689 handler(encodedReply);
691 [viewController viewWillAppear];
692 [viewController keyDown:event];
695 never(), [responderMock keyDown:[OCMArg any]]);
697 [binaryMessengerMock sendOnChannel:
@"flutter/keyevent"
699 binaryReply:[OCMArg any]]);
706 - (bool)testKeyboardIsRestartedOnEngineRestart:(
id)engineMock {
709 [engineMock binaryMessenger])
710 .andReturn(binaryMessengerMock);
711 __block
bool called =
false;
712 __block FlutterKeyEvent last_event;
716 OCMStub([engineMock keyboardManager]).andDo(^(NSInvocation* invocation) {
717 [invocation setReturnValue:&keyboardManager];
723 .andDo((^(NSInvocation* invocation) {
724 FlutterKeyEvent* event;
725 [invocation getArgument:&event atIndex:2];
733 [viewController viewWillAppear];
734 NSEvent* keyADown = [NSEvent keyEventWithType:NSEventTypeKeyDown
741 charactersIgnoringModifiers:@"a"
744 const uint64_t kPhysicalKeyA = 0x70004;
751 [viewController keyDown:keyADown];
753 EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
754 EXPECT_EQ(last_event.physical, kPhysicalKeyA);
759 [viewController keyDown:keyADown];
761 EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
762 EXPECT_EQ(last_event.physical, kPhysicalKeyA);
766 + (void)respondFalseForSendEvent:(const FlutterKeyEvent&)event
767 callback:(nullable FlutterKeyEventCallback)callback
768 userData:(nullable
void*)userData {
769 if (callback !=
nullptr) {
770 callback(
false, userData);
774 - (bool)testTrackpadGesturesAreSentToFramework:(
id)engineMock {
777 OCMStub([engineMock renderer]).andReturn(renderer_);
778 __block
bool called =
false;
779 __block FlutterPointerEvent last_event;
781 .andDo((^(NSInvocation* invocation) {
782 FlutterPointerEvent* event;
783 [invocation getArgument:&event atIndex:2];
791 [viewController loadView];
795 CGEventRef cgEventStart = CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0);
796 CGEventSetType(cgEventStart, kCGEventScrollWheel);
797 CGEventSetIntegerValueField(cgEventStart, kCGScrollWheelEventScrollPhase, kCGScrollPhaseBegan);
798 CGEventSetIntegerValueField(cgEventStart, kCGScrollWheelEventIsContinuous, 1);
801 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventStart]];
803 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
804 EXPECT_EQ(last_event.phase, kPanZoomStart);
805 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
806 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
809 CGEventRef cgEventUpdate = CGEventCreateCopy(cgEventStart);
810 CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventScrollPhase, kCGScrollPhaseChanged);
811 CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis2, 1);
812 CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis1, 2);
815 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventUpdate]];
817 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
818 EXPECT_EQ(last_event.phase, kPanZoomUpdate);
819 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
820 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
821 EXPECT_EQ(last_event.pan_x, 8 * viewController.flutterView.layer.contentsScale);
822 EXPECT_EQ(last_event.pan_y, 16 * viewController.flutterView.layer.contentsScale);
826 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventUpdate]];
828 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
829 EXPECT_EQ(last_event.phase, kPanZoomUpdate);
830 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
831 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
832 EXPECT_EQ(last_event.pan_x, 16 * viewController.flutterView.layer.contentsScale);
833 EXPECT_EQ(last_event.pan_y, 32 * viewController.flutterView.layer.contentsScale);
836 CGEventRef cgEventEnd = CGEventCreateCopy(cgEventStart);
837 CGEventSetIntegerValueField(cgEventEnd, kCGScrollWheelEventScrollPhase, kCGScrollPhaseEnded);
840 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventEnd]];
842 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
843 EXPECT_EQ(last_event.phase, kPanZoomEnd);
844 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
845 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
848 CGEventRef cgEventMomentumStart = CGEventCreateCopy(cgEventStart);
849 CGEventSetIntegerValueField(cgEventMomentumStart, kCGScrollWheelEventScrollPhase, 0);
850 CGEventSetIntegerValueField(cgEventMomentumStart, kCGScrollWheelEventMomentumPhase,
851 kCGMomentumScrollPhaseBegin);
854 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMomentumStart]];
855 EXPECT_FALSE(called);
858 CGEventRef cgEventMomentumUpdate = CGEventCreateCopy(cgEventStart);
859 CGEventSetIntegerValueField(cgEventMomentumUpdate, kCGScrollWheelEventScrollPhase, 0);
860 CGEventSetIntegerValueField(cgEventMomentumUpdate, kCGScrollWheelEventMomentumPhase,
861 kCGMomentumScrollPhaseContinue);
864 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMomentumUpdate]];
865 EXPECT_FALSE(called);
868 id touchMock = OCMClassMock([NSTouch
class]);
869 NSSet* touchSet = [NSSet setWithObject:touchMock];
870 id touchEventMock1 = OCMClassMock([NSEvent
class]);
871 OCMStub([touchEventMock1 allTouches]).andReturn(touchSet);
872 CGPoint touchLocation = {0, 0};
873 OCMStub([touchEventMock1 locationInWindow]).andReturn(touchLocation);
874 OCMStub([(NSEvent*)touchEventMock1 timestamp]).andReturn(0.150);
878 [viewController touchesBeganWithEvent:touchEventMock1];
879 EXPECT_FALSE(called);
882 id touchEventMock2 = OCMClassMock([NSEvent
class]);
883 OCMStub([touchEventMock2 allTouches]).andReturn(touchSet);
884 OCMStub([touchEventMock2 locationInWindow]).andReturn(touchLocation);
885 OCMStub([(NSEvent*)touchEventMock2 timestamp]).andReturn(0.005);
889 [viewController touchesBeganWithEvent:touchEventMock2];
891 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindScrollInertiaCancel);
892 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
895 CGEventRef cgEventMomentumEnd = CGEventCreateCopy(cgEventStart);
896 CGEventSetIntegerValueField(cgEventMomentumEnd, kCGScrollWheelEventScrollPhase, 0);
897 CGEventSetIntegerValueField(cgEventMomentumEnd, kCGScrollWheelEventMomentumPhase,
898 kCGMomentumScrollPhaseEnd);
901 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMomentumEnd]];
902 EXPECT_FALSE(called);
905 CGEventRef cgEventMayBegin = CGEventCreateCopy(cgEventStart);
906 CGEventSetIntegerValueField(cgEventMayBegin, kCGScrollWheelEventScrollPhase,
907 kCGScrollPhaseMayBegin);
910 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMayBegin]];
912 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
913 EXPECT_EQ(last_event.phase, kPanZoomStart);
914 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
915 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
918 CGEventRef cgEventCancel = CGEventCreateCopy(cgEventStart);
919 CGEventSetIntegerValueField(cgEventCancel, kCGScrollWheelEventScrollPhase,
920 kCGScrollPhaseCancelled);
923 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventCancel]];
925 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
926 EXPECT_EQ(last_event.phase, kPanZoomEnd);
927 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
928 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
931 CGEventRef cgEventDiscrete = CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0);
932 CGEventSetType(cgEventDiscrete, kCGEventScrollWheel);
933 CGEventSetIntegerValueField(cgEventDiscrete, kCGScrollWheelEventIsContinuous, 0);
934 CGEventSetIntegerValueField(cgEventDiscrete, kCGScrollWheelEventDeltaAxis2, 1);
935 CGEventSetIntegerValueField(cgEventDiscrete, kCGScrollWheelEventDeltaAxis1, 2);
938 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventDiscrete]];
940 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindScroll);
942 EXPECT_EQ(last_event.scroll_delta_x, -40 * viewController.flutterView.layer.contentsScale);
943 EXPECT_EQ(last_event.scroll_delta_y, -80 * viewController.flutterView.layer.contentsScale);
947 CGEventRef cgEventDiscreteShift =
948 CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0);
949 CGEventSetType(cgEventDiscreteShift, kCGEventScrollWheel);
950 CGEventSetFlags(cgEventDiscreteShift,
static_cast<uint64_t
>(kCGEventFlagMaskShift) |
952 CGEventSetIntegerValueField(cgEventDiscreteShift, kCGScrollWheelEventIsContinuous, 0);
953 CGEventSetIntegerValueField(cgEventDiscreteShift, kCGScrollWheelEventDeltaAxis2,
955 CGEventSetIntegerValueField(cgEventDiscreteShift, kCGScrollWheelEventDeltaAxis1,
959 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventDiscreteShift]];
961 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindScroll);
963 EXPECT_FLOAT_EQ(last_event.scroll_delta_x, 0.0 * viewController.flutterView.layer.contentsScale);
964 EXPECT_FLOAT_EQ(last_event.scroll_delta_y,
965 -80.0 * viewController.flutterView.layer.contentsScale);
970 [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
971 NSEventPhaseBegan, 1, 0)];
973 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
974 EXPECT_EQ(last_event.phase, kPanZoomStart);
975 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
976 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
980 [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
981 NSEventPhaseChanged, 1, 0)];
983 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
984 EXPECT_EQ(last_event.phase, kPanZoomUpdate);
985 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
986 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
987 EXPECT_EQ(last_event.pan_x, 0);
988 EXPECT_EQ(last_event.pan_y, 0);
989 EXPECT_EQ(last_event.scale, 2);
991 EXPECT_EQ(last_event.rotation, 0);
995 [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
996 NSEventPhaseChanged, 1, 0)];
998 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
999 EXPECT_EQ(last_event.phase, kPanZoomUpdate);
1000 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1001 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1002 EXPECT_EQ(last_event.pan_x, 0);
1003 EXPECT_EQ(last_event.pan_y, 0);
1004 EXPECT_EQ(last_event.scale, 4);
1006 EXPECT_EQ(last_event.rotation, 0);
1010 [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
1011 NSEventPhaseEnded, 0, 0)];
1012 EXPECT_TRUE(called);
1013 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1014 EXPECT_EQ(last_event.phase, kPanZoomEnd);
1015 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1016 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1021 [viewController rotateWithEvent:flutter::testing::MockGestureEvent(NSEventTypeRotate,
1022 NSEventPhaseBegan, 1, 0)];
1023 EXPECT_TRUE(called);
1024 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1025 EXPECT_EQ(last_event.phase, kPanZoomStart);
1026 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1027 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1031 [viewController rotateWithEvent:flutter::testing::MockGestureEvent(
1032 NSEventTypeRotate, NSEventPhaseChanged, 0, -180)];
1033 EXPECT_TRUE(called);
1034 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1035 EXPECT_EQ(last_event.phase, kPanZoomUpdate);
1036 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1037 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1038 EXPECT_EQ(last_event.pan_x, 0);
1039 EXPECT_EQ(last_event.pan_y, 0);
1040 EXPECT_EQ(last_event.scale, 1);
1041 EXPECT_EQ(last_event.rotation, M_PI);
1045 [viewController rotateWithEvent:flutter::testing::MockGestureEvent(
1046 NSEventTypeRotate, NSEventPhaseChanged, 0, -360)];
1047 EXPECT_TRUE(called);
1048 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1049 EXPECT_EQ(last_event.phase, kPanZoomUpdate);
1050 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1051 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1052 EXPECT_EQ(last_event.pan_x, 0);
1053 EXPECT_EQ(last_event.pan_y, 0);
1054 EXPECT_EQ(last_event.scale, 1);
1055 EXPECT_EQ(last_event.rotation, 3 * M_PI);
1059 [viewController rotateWithEvent:flutter::testing::MockGestureEvent(NSEventTypeRotate,
1060 NSEventPhaseEnded, 0, 0)];
1061 EXPECT_TRUE(called);
1062 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1063 EXPECT_EQ(last_event.phase, kPanZoomEnd);
1064 EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1065 EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1069 [viewController rotateWithEvent:flutter::testing::MockGestureEvent(NSEventTypeRotate,
1070 NSEventPhaseCancelled, 0, 0)];
1071 EXPECT_FALSE(called);
1077 - (bool)mouseAndGestureEventsAreHandledSeparately:(
id)engineMock {
1081 [viewController loadView];
1085 fml::CFRef<CGEventRef> cgEventStart(
1086 CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0));
1087 CGEventSetType(cgEventStart, kCGEventScrollWheel);
1088 CGEventSetIntegerValueField(cgEventStart, kCGScrollWheelEventScrollPhase, kCGScrollPhaseBegan);
1089 CGEventSetIntegerValueField(cgEventStart, kCGScrollWheelEventIsContinuous, 1);
1090 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventStart]];
1092 fml::CFRef<CGEventRef> cgEventUpdate(CGEventCreateCopy(cgEventStart));
1093 CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventScrollPhase, kCGScrollPhaseChanged);
1094 CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis2, 1);
1095 CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis1, 2);
1096 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventUpdate]];
1098 NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1099 [viewController mouseEntered:mouseEvent];
1100 [viewController mouseExited:mouseEvent];
1103 fml::CFRef<CGEventRef> cgEventEnd(CGEventCreateCopy(cgEventStart));
1104 CGEventSetIntegerValueField(cgEventEnd, kCGScrollWheelEventScrollPhase, kCGScrollPhaseEnded);
1105 [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventEnd]];
1110 - (bool)testViewWillAppearCalledMultipleTimes:(
id)engineMock {
1114 [viewController viewWillAppear];
1115 [viewController viewWillAppear];
1123 [key isEqualToString:
@"Contents/Frameworks/App.framework/Resources/flutter_assets/test.png"]);
1131 EXPECT_TRUE([packageKey
1133 @"Contents/Frameworks/App.framework/Resources/flutter_assets/packages/test/test.png"]);
1137 static void SwizzledNoop(
id self,
SEL _cmd) {}
1149 - (bool)testMouseDownUpEventsSentToNextResponder:(
id)engineMock {
1150 if (@available(macOS 13.3.1, *)) {
1160 Method mouseDown = class_getInstanceMethod([NSResponder
class],
@selector(mouseDown:));
1161 Method mouseUp = class_getInstanceMethod([NSResponder
class],
@selector(mouseUp:));
1162 IMP noopImp = (IMP)SwizzledNoop;
1163 IMP origMouseDown = method_setImplementation(mouseDown, noopImp);
1164 IMP origMouseUp = method_setImplementation(mouseUp, noopImp);
1174 NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1175 [view mouseDown:mouseEvent];
1180 [view mouseUp:mouseEvent];
1185 method_setImplementation(mouseDown, origMouseDown);
1186 method_setImplementation(mouseUp, origMouseUp);
1191 - (bool)testModifierKeysAreSynthesizedOnMouseMove:(
id)engineMock {
1194 [engineMock binaryMessenger])
1195 .andReturn(binaryMessengerMock);
1199 OCMStub([engineMock renderer]).andReturn(renderer_);
1203 OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
1206 __block NSMutableArray<KeyEventWrapper*>* events = [NSMutableArray array];
1210 .andDo((^(NSInvocation* invocation) {
1211 FlutterKeyEvent* event;
1212 [invocation getArgument:&event atIndex:2];
1216 __block NSMutableArray<NSDictionary*>* channelEvents = [NSMutableArray array];
1217 OCMStub([binaryMessengerMock sendOnChannel:
@"flutter/keyevent"
1218 message:[OCMArg any]
1219 binaryReply:[OCMArg any]])
1220 .andDo((^(NSInvocation* invocation) {
1222 [invocation getArgument:&data atIndex:3];
1224 [channelEvents addObject:event];
1230 [viewController loadView];
1231 [viewController viewWillAppear];
1234 NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1235 [viewController mouseMoved:mouseEvent];
1236 EXPECT_EQ([events count], 0u);
1240 FlutterKeyEvent* event;
1241 NSDictionary* channelEvent;
1242 NSNumber* logicalKey;
1243 NSNumber* physicalKey;
1244 NSEventModifierFlags flag = [flutter::keyCodeToModifierFlag[keyCode] unsignedLongValue];
1248 flag |= NSEventModifierFlagShift;
1251 flag |= NSEventModifierFlagControl;
1254 flag |= NSEventModifierFlagOption;
1257 flag |= NSEventModifierFlagCommand;
1261 NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(flag);
1262 [viewController mouseMoved:mouseEvent];
1263 EXPECT_EQ([events count], 1u);
1264 event = events[0].data;
1265 logicalKey = [flutter::keyCodeToLogicalKey objectForKey:keyCode];
1266 physicalKey = [flutter::keyCodeToPhysicalKey objectForKey:keyCode];
1267 EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1268 EXPECT_EQ(event->logical, logicalKey.unsignedLongLongValue);
1269 EXPECT_EQ(event->physical, physicalKey.unsignedLongLongValue);
1270 EXPECT_EQ(event->synthesized,
true);
1272 channelEvent = channelEvents[0];
1273 EXPECT_TRUE([channelEvent[
@"type"] isEqual:
@"keydown"]);
1274 EXPECT_TRUE([channelEvent[
@"keyCode"] isEqual:keyCode]);
1275 EXPECT_TRUE([channelEvent[
@"modifiers"] isEqual:@(flag)]);
1278 mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1279 [viewController mouseMoved:mouseEvent];
1280 EXPECT_EQ([events count], 2u);
1281 event = events[1].data;
1282 logicalKey = [flutter::keyCodeToLogicalKey objectForKey:keyCode];
1283 physicalKey = [flutter::keyCodeToPhysicalKey objectForKey:keyCode];
1284 EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
1285 EXPECT_EQ(event->logical, logicalKey.unsignedLongLongValue);
1286 EXPECT_EQ(event->physical, physicalKey.unsignedLongLongValue);
1287 EXPECT_EQ(event->synthesized,
true);
1289 channelEvent = channelEvents[1];
1290 EXPECT_TRUE([channelEvent[
@"type"] isEqual:
@"keyup"]);
1291 EXPECT_TRUE([channelEvent[
@"keyCode"] isEqual:keyCode]);
1292 EXPECT_TRUE([channelEvent[
@"modifiers"] isEqual:@(0)]);
1294 [events removeAllObjects];
1295 [channelEvents removeAllObjects];
1307 OCMStub([engineMock renderer]).andReturn(renderer_);
1312 [viewController loadView];
1313 weakController = viewController;
1315 [engineMock shutDownEngine];
1318 EXPECT_EQ(weakController, nil);
NS_ASSUME_NONNULL_BEGIN typedef void(^ FlutterBinaryReply)(NSData *_Nullable reply)
void(^ FlutterResult)(id _Nullable result)
static const FlutterKeyEvent kDefaultFlutterKeyEvent
static const FlutterPointerEvent kDefaultFlutterPointerEvent
static id JSONMessageWithContentOf(NSData *expected)
instancetype methodCallWithMethodName:arguments:(NSString *method,[arguments] id _Nullable arguments)
nonnull NSString * lookupKeyForAsset:(nonnull NSString *asset)
nonnull NSString * lookupKeyForAsset:fromPackage:(nonnull NSString *asset,[fromPackage] nonnull NSString *package)
FlutterMouseTrackingMode mouseTrackingMode
void onAccessibilityStatusChanged:(BOOL enabled)
bool testLookupKeyAssetsWithPackage()
bool testViewControllerIsReleased()
bool testLookupKeyAssets()
id CreateMockViewController()
id CreateMockFlutterEngine(NSString *pasteboardString)
AutoreleasePoolTest FlutterViewControllerTest
TEST_F(FlutterViewControllerTest, testViewControllerIsReleased)
const NSDictionary * keyCodeToModifierFlag
@ kModifierFlagControlLeft
@ kModifierFlagControlRight
@ kModifierFlagShiftRight
instancetype sharedInstance()