Flutter macOS Embedder
FlutterViewControllerTestObjC Class Reference
Inheritance diagram for FlutterViewControllerTestObjC:

Instance Methods

(bool) - testKeyEventsAreSentToFramework:
 
(bool) - testKeyEventsArePropagatedIfNotHandled:
 
(bool) - testKeyEventsAreNotPropagatedIfHandled:
 
(bool) - testCtrlTabKeyEventIsPropagated:
 
(bool) - testKeyEquivalentIsPassedToTextInputPlugin:
 
(bool) - testFlagsChangedEventsArePropagatedIfNotHandled:
 
(bool) - testKeyboardIsRestartedOnEngineRestart:
 
(bool) - testTrackpadGesturesAreSentToFramework:
 
(bool) - mouseAndGestureEventsAreHandledSeparately:
 
(bool) - testMouseDownUpEventsSentToNextResponder:
 
(bool) - testModifierKeysAreSynthesizedOnMouseMove:
 
(bool) - testViewWillAppearCalledMultipleTimes:
 
(bool) - testFlutterViewIsConfigured:
 
(bool) - testLookupKeyAssets
 
(bool) - testLookupKeyAssetsWithPackage
 
(bool) - testViewControllerIsReleased
 

Class Methods

(void) + respondFalseForSendEvent:callback:userData:
 

Detailed Description

Definition at line 108 of file FlutterViewControllerTest.mm.

Method Documentation

◆ mouseAndGestureEventsAreHandledSeparately:

- (bool) mouseAndGestureEventsAreHandledSeparately: (id)  engineMock

Definition at line 175 of file FlutterViewControllerTest.mm.

1077  :(id)engineMock {
1078  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
1079  nibName:@""
1080  bundle:nil];
1081  [viewController loadView];
1082 
1083  // Test for pan events.
1084  // Start gesture.
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]];
1091 
1092  fml::CFRef<CGEventRef> cgEventUpdate(CGEventCreateCopy(cgEventStart));
1093  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventScrollPhase, kCGScrollPhaseChanged);
1094  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis2, 1); // pan_x
1095  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis1, 2); // pan_y
1096  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventUpdate]];
1097 
1098  NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1099  [viewController mouseEntered:mouseEvent];
1100  [viewController mouseExited:mouseEvent];
1101 
1102  // End gesture.
1103  fml::CFRef<CGEventRef> cgEventEnd(CGEventCreateCopy(cgEventStart));
1104  CGEventSetIntegerValueField(cgEventEnd, kCGScrollWheelEventScrollPhase, kCGScrollPhaseEnded);
1105  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventEnd]];
1106 
1107  return true;
1108 }

◆ respondFalseForSendEvent:callback:userData:

+ (void) respondFalseForSendEvent: (const FlutterKeyEvent&)  event
callback: (nullable FlutterKeyEventCallback)  callback
userData: (nullable void*)  userData 

Definition at line 175 of file FlutterViewControllerTest.mm.

766  :(const FlutterKeyEvent&)event
767  callback:(nullable FlutterKeyEventCallback)callback
768  userData:(nullable void*)userData {
769  if (callback != nullptr) {
770  callback(false, userData);
771  }
772 }

◆ testCtrlTabKeyEventIsPropagated:

- (bool) testCtrlTabKeyEventIsPropagated: (id)  mockEngine

Definition at line 175 of file FlutterViewControllerTest.mm.

404  :(id)engineMock {
405  __block bool called = false;
406  __block FlutterKeyEvent last_event;
407  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
408  callback:nil
409  userData:nil])
410  .andDo((^(NSInvocation* invocation) {
411  FlutterKeyEvent* event;
412  [invocation getArgument:&event atIndex:2];
413  called = true;
414  last_event = *event;
415  }));
416  FlutterKeyboardManager* keyboardManager =
417  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
418  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
419 
420  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
421  nibName:@""
422  bundle:nil];
423  // Ctrl+tab
424  NSEvent* event = [NSEvent keyEventWithType:NSEventTypeKeyDown
425  location:NSZeroPoint
426  modifierFlags:0x40101
427  timestamp:0
428  windowNumber:0
429  context:nil
430  characters:@""
431  charactersIgnoringModifiers:@""
432  isARepeat:NO
433  keyCode:48];
434  const uint64_t kPhysicalKeyTab = 0x7002b;
435 
436  [viewController viewWillAppear]; // Initializes the event channel.
437  // Creates a NSWindow so that FlutterView view can be first responder.
438  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
439  styleMask:NSBorderlessWindowMask
440  backing:NSBackingStoreBuffered
441  defer:NO];
442  window.contentView = viewController.view;
443  [window makeFirstResponder:viewController.flutterView];
444  [viewController.view performKeyEquivalent:event];
445 
446  EXPECT_TRUE(called);
447  EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
448  EXPECT_EQ(last_event.physical, kPhysicalKeyTab);
449  return true;
450 }
static const FlutterKeyEvent kDefaultFlutterKeyEvent

◆ testFlagsChangedEventsArePropagatedIfNotHandled:

- (bool) testFlagsChangedEventsArePropagatedIfNotHandled: (id)  mockEngine

Definition at line 175 of file FlutterViewControllerTest.mm.

592  :(id)engineMock {
593  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
594  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
595  [engineMock binaryMessenger])
596  .andReturn(binaryMessengerMock);
597  FlutterKeyboardManager* keyboardManager =
598  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
599  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
600  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
601  callback:nil
602  userData:nil])
603  .andCall([FlutterViewControllerTestObjC class],
604  @selector(respondFalseForSendEvent:callback:userData:));
605  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
606  nibName:@""
607  bundle:nil];
608  id responderMock = flutter::testing::mockResponder();
609  id responderWrapper = [[FlutterResponderWrapper alloc] initWithResponder:responderMock];
610  viewController.nextResponder = responderWrapper;
611  NSDictionary* expectedEvent = @{
612  @"keymap" : @"macos",
613  @"type" : @"keydown",
614  @"keyCode" : @(56), // SHIFT key
615  @"modifiers" : @(537001986),
616  };
617  NSData* encodedKeyEvent = [[FlutterJSONMessageCodec sharedInstance] encode:expectedEvent];
618  CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 56, TRUE); // SHIFT key
619  CGEventSetType(cgEvent, kCGEventFlagsChanged);
620  NSEvent* event = [NSEvent eventWithCGEvent:cgEvent];
621  OCMExpect( // NOLINT(google-objc-avoid-throwing-exception)
622  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
623  message:JSONMessageWithContentOf(encodedKeyEvent)
624  binaryReply:[OCMArg any]])
625  .andDo((^(NSInvocation* invocation) {
626  FlutterBinaryReply handler;
627  [invocation getArgument:&handler atIndex:4];
628  NSDictionary* reply = @{
629  @"handled" : @(false),
630  };
631  NSData* encodedReply = [[FlutterJSONMessageCodec sharedInstance] encode:reply];
632  handler(encodedReply);
633  }));
634  [viewController viewWillAppear]; // Initializes the event channel.
635  [viewController flagsChanged:event];
636  @try {
637  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
638  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
639  message:JSONMessageWithContentOf(encodedKeyEvent)
640  binaryReply:[OCMArg any]]);
641  } @catch (NSException* e) {
642  NSLog(@"%@", e.reason);
643  return false;
644  }
645  return true;
646 }
NS_ASSUME_NONNULL_BEGIN typedef void(^ FlutterBinaryReply)(NSData *_Nullable reply)
static id JSONMessageWithContentOf(NSData *expected)
instancetype sharedInstance()

◆ testFlutterViewIsConfigured:

- (bool) testFlutterViewIsConfigured: (id)  mockEngine

Definition at line 175 of file FlutterViewControllerTest.mm.

573  :(id)engineMock {
574  FlutterRenderer* renderer_ = [[FlutterRenderer alloc] initWithFlutterEngine:engineMock];
575  OCMStub([engineMock renderer]).andReturn(renderer_);
576 
577  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
578  nibName:@""
579  bundle:nil];
580  [viewController loadView];
581 
582  @try {
583  // Make sure "renderer" was called during "loadView", which means "flutterView" is created
584  OCMVerify([engineMock renderer]);
585  } @catch (...) {
586  return false;
587  }
588 
589  return true;
590 }

◆ testKeyboardIsRestartedOnEngineRestart:

- (bool) testKeyboardIsRestartedOnEngineRestart: (id)  mockEngine

Definition at line 175 of file FlutterViewControllerTest.mm.

706  :(id)engineMock {
707  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
708  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
709  [engineMock binaryMessenger])
710  .andReturn(binaryMessengerMock);
711  __block bool called = false;
712  __block FlutterKeyEvent last_event;
713  __block FlutterKeyboardManager* keyboardManager =
714  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
715 
716  OCMStub([engineMock keyboardManager]).andDo(^(NSInvocation* invocation) {
717  [invocation setReturnValue:&keyboardManager];
718  });
719 
720  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
721  callback:nil
722  userData:nil])
723  .andDo((^(NSInvocation* invocation) {
724  FlutterKeyEvent* event;
725  [invocation getArgument:&event atIndex:2];
726  called = true;
727  last_event = *event;
728  }));
729 
730  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
731  nibName:@""
732  bundle:nil];
733  [viewController viewWillAppear];
734  NSEvent* keyADown = [NSEvent keyEventWithType:NSEventTypeKeyDown
735  location:NSZeroPoint
736  modifierFlags:0x100
737  timestamp:0
738  windowNumber:0
739  context:nil
740  characters:@"a"
741  charactersIgnoringModifiers:@"a"
742  isARepeat:FALSE
743  keyCode:0];
744  const uint64_t kPhysicalKeyA = 0x70004;
745 
746  // Send KeyA key down event twice. Without restarting the keyboard during
747  // onPreEngineRestart, the second event received will be an empty event with
748  // physical key 0x0 because duplicate key down events are ignored.
749 
750  called = false;
751  [viewController keyDown:keyADown];
752  EXPECT_TRUE(called);
753  EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
754  EXPECT_EQ(last_event.physical, kPhysicalKeyA);
755 
756  keyboardManager = [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
757 
758  called = false;
759  [viewController keyDown:keyADown];
760  EXPECT_TRUE(called);
761  EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
762  EXPECT_EQ(last_event.physical, kPhysicalKeyA);
763  return true;
764 }

◆ testKeyEquivalentIsPassedToTextInputPlugin:

- (bool) testKeyEquivalentIsPassedToTextInputPlugin: (id)  mockEngine

Definition at line 175 of file FlutterViewControllerTest.mm.

452  :(id)engineMock {
453  __block bool called = false;
454  __block FlutterKeyEvent last_event;
455  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
456  callback:nil
457  userData:nil])
458  .andDo((^(NSInvocation* invocation) {
459  FlutterKeyEvent* event;
460  [invocation getArgument:&event atIndex:2];
461  called = true;
462  last_event = *event;
463  }));
464  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
465  nibName:@""
466  bundle:nil];
467  // Ctrl+tab
468  NSEvent* event = [NSEvent keyEventWithType:NSEventTypeKeyDown
469  location:NSZeroPoint
470  modifierFlags:0x40101
471  timestamp:0
472  windowNumber:0
473  context:nil
474  characters:@""
475  charactersIgnoringModifiers:@""
476  isARepeat:NO
477  keyCode:48];
478  const uint64_t kPhysicalKeyTab = 0x7002b;
479 
480  [viewController viewWillAppear]; // Initializes the event channel.
481 
482  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
483  styleMask:NSBorderlessWindowMask
484  backing:NSBackingStoreBuffered
485  defer:NO];
486  window.contentView = viewController.view;
487 
488  NSDictionary* setClientConfig = @{
489  @"viewId" : @(flutter::kFlutterImplicitViewId),
490  };
491  FlutterMethodCall* methodCall =
492  [FlutterMethodCall methodCallWithMethodName:@"TextInput.setClient"
493  arguments:@[ @(1), setClientConfig ]];
494  FlutterResult result = ^(id result) {
495  };
496  [viewController.engine.textInputPlugin handleMethodCall:methodCall result:result];
497 
498  [viewController.engine.textInputPlugin
499  handleMethodCall:[FlutterMethodCall methodCallWithMethodName:@"TextInput.show" arguments:@[]]
500  result:^(id){
501  }];
502 
503  // Make the textInputPlugin first responder. This should still result in
504  // view controller reporting the key event.
505  [window makeFirstResponder:viewController.engine.textInputPlugin];
506 
507  [viewController.view performKeyEquivalent:event];
508 
509  EXPECT_TRUE(called);
510  EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
511  EXPECT_EQ(last_event.physical, kPhysicalKeyTab);
512  return true;
513 }
void(^ FlutterResult)(id _Nullable result)
instancetype methodCallWithMethodName:arguments:(NSString *method,[arguments] id _Nullable arguments)

◆ testKeyEventsAreNotPropagatedIfHandled:

- (bool) testKeyEventsAreNotPropagatedIfHandled: (id)  mockEngine

Definition at line 175 of file FlutterViewControllerTest.mm.

648  :(id)engineMock {
649  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
650  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
651  [engineMock binaryMessenger])
652  .andReturn(binaryMessengerMock);
653  FlutterKeyboardManager* keyboardManager =
654  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
655  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
656  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
657  callback:nil
658  userData:nil])
659  .andCall([FlutterViewControllerTestObjC class],
660  @selector(respondFalseForSendEvent:callback:userData:));
661  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
662  nibName:@""
663  bundle:nil];
664  id responderMock = flutter::testing::mockResponder();
665  id responderWrapper = [[FlutterResponderWrapper alloc] initWithResponder:responderMock];
666  viewController.nextResponder = responderWrapper;
667  NSDictionary* expectedEvent = @{
668  @"keymap" : @"macos",
669  @"type" : @"keydown",
670  @"keyCode" : @(65),
671  @"modifiers" : @(538968064),
672  @"characters" : @".",
673  @"charactersIgnoringModifiers" : @".",
674  };
675  NSData* encodedKeyEvent = [[FlutterJSONMessageCodec sharedInstance] encode:expectedEvent];
676  CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 65, TRUE);
677  NSEvent* event = [NSEvent eventWithCGEvent:cgEvent];
678  OCMExpect( // NOLINT(google-objc-avoid-throwing-exception)
679  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
680  message:JSONMessageWithContentOf(encodedKeyEvent)
681  binaryReply:[OCMArg any]])
682  .andDo((^(NSInvocation* invocation) {
683  FlutterBinaryReply handler;
684  [invocation getArgument:&handler atIndex:4];
685  NSDictionary* reply = @{
686  @"handled" : @(true),
687  };
688  NSData* encodedReply = [[FlutterJSONMessageCodec sharedInstance] encode:reply];
689  handler(encodedReply);
690  }));
691  [viewController viewWillAppear]; // Initializes the event channel.
692  [viewController keyDown:event];
693  @try {
694  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
695  never(), [responderMock keyDown:[OCMArg any]]);
696  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
697  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
698  message:JSONMessageWithContentOf(encodedKeyEvent)
699  binaryReply:[OCMArg any]]);
700  } @catch (...) {
701  return false;
702  }
703  return true;
704 }

◆ testKeyEventsArePropagatedIfNotHandled:

- (bool) testKeyEventsArePropagatedIfNotHandled: (id)  mockEngine

Definition at line 175 of file FlutterViewControllerTest.mm.

515  :(id)engineMock {
516  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
517  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
518  [engineMock binaryMessenger])
519  .andReturn(binaryMessengerMock);
520  FlutterKeyboardManager* keyboardManager =
521  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
522  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
523  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
524  callback:nil
525  userData:nil])
526  .andCall([FlutterViewControllerTestObjC class],
527  @selector(respondFalseForSendEvent:callback:userData:));
528  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
529  nibName:@""
530  bundle:nil];
531  id responderMock = flutter::testing::mockResponder();
532  id responderWrapper = [[FlutterResponderWrapper alloc] initWithResponder:responderMock];
533  viewController.nextResponder = responderWrapper;
534  NSDictionary* expectedEvent = @{
535  @"keymap" : @"macos",
536  @"type" : @"keydown",
537  @"keyCode" : @(65),
538  @"modifiers" : @(538968064),
539  @"characters" : @".",
540  @"charactersIgnoringModifiers" : @".",
541  };
542  NSData* encodedKeyEvent = [[FlutterJSONMessageCodec sharedInstance] encode:expectedEvent];
543  CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 65, TRUE);
544  NSEvent* event = [NSEvent eventWithCGEvent:cgEvent];
545  OCMExpect( // NOLINT(google-objc-avoid-throwing-exception)
546  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
547  message:JSONMessageWithContentOf(encodedKeyEvent)
548  binaryReply:[OCMArg any]])
549  .andDo((^(NSInvocation* invocation) {
550  FlutterBinaryReply handler;
551  [invocation getArgument:&handler atIndex:4];
552  NSDictionary* reply = @{
553  @"handled" : @(false),
554  };
555  NSData* encodedReply = [[FlutterJSONMessageCodec sharedInstance] encode:reply];
556  handler(encodedReply);
557  }));
558  [viewController viewWillAppear]; // Initializes the event channel.
559  [viewController keyDown:event];
560  @try {
561  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
562  [responderMock keyDown:[OCMArg any]]);
563  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
564  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
565  message:JSONMessageWithContentOf(encodedKeyEvent)
566  binaryReply:[OCMArg any]]);
567  } @catch (...) {
568  return false;
569  }
570  return true;
571 }

◆ testKeyEventsAreSentToFramework:

- (bool) testKeyEventsAreSentToFramework: (id)  mockEngine

Definition at line 175 of file FlutterViewControllerTest.mm.

362  :(id)engineMock {
363  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
364  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
365  [engineMock binaryMessenger])
366  .andReturn(binaryMessengerMock);
367  FlutterKeyboardManager* keyboardManager =
368  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
369  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
370 
371  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
372  callback:nil
373  userData:nil])
374  .andCall([FlutterViewControllerTestObjC class],
375  @selector(respondFalseForSendEvent:callback:userData:));
376  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
377  nibName:@""
378  bundle:nil];
379  NSDictionary* expectedEvent = @{
380  @"keymap" : @"macos",
381  @"type" : @"keydown",
382  @"keyCode" : @(65),
383  @"modifiers" : @(538968064),
384  @"characters" : @".",
385  @"charactersIgnoringModifiers" : @".",
386  };
387  NSData* encodedKeyEvent = [[FlutterJSONMessageCodec sharedInstance] encode:expectedEvent];
388  CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 65, TRUE);
389  NSEvent* event = [NSEvent eventWithCGEvent:cgEvent];
390  [viewController viewWillAppear]; // Initializes the event channel.
391  [viewController keyDown:event];
392  @try {
393  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
394  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
395  message:JSONMessageWithContentOf(encodedKeyEvent)
396  binaryReply:[OCMArg any]]);
397  } @catch (...) {
398  return false;
399  }
400  return true;
401 }

◆ testLookupKeyAssets

- (bool) testLookupKeyAssets

Definition at line 175 of file FlutterViewControllerTest.mm.

1119  {
1120  FlutterViewController* viewController = [[FlutterViewController alloc] initWithProject:nil];
1121  NSString* key = [viewController lookupKeyForAsset:@"test.png"];
1122  EXPECT_TRUE(
1123  [key isEqualToString:@"Contents/Frameworks/App.framework/Resources/flutter_assets/test.png"]);
1124  return true;
1125 }
nonnull NSString * lookupKeyForAsset:(nonnull NSString *asset)

◆ testLookupKeyAssetsWithPackage

- (bool) testLookupKeyAssetsWithPackage

Definition at line 175 of file FlutterViewControllerTest.mm.

1127  {
1128  FlutterViewController* viewController = [[FlutterViewController alloc] initWithProject:nil];
1129 
1130  NSString* packageKey = [viewController lookupKeyForAsset:@"test.png" fromPackage:@"test"];
1131  EXPECT_TRUE([packageKey
1132  isEqualToString:
1133  @"Contents/Frameworks/App.framework/Resources/flutter_assets/packages/test/test.png"]);
1134  return true;
1135 }
nonnull NSString * lookupKeyForAsset:fromPackage:(nonnull NSString *asset,[fromPackage] nonnull NSString *package)

◆ testModifierKeysAreSynthesizedOnMouseMove:

- (bool) testModifierKeysAreSynthesizedOnMouseMove: (id)  mockEngine

Definition at line 1137 of file FlutterViewControllerTest.mm.

1191  :(id)engineMock {
1192  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
1193  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
1194  [engineMock binaryMessenger])
1195  .andReturn(binaryMessengerMock);
1196 
1197  // Need to return a real renderer to allow view controller to load.
1198  FlutterRenderer* renderer_ = [[FlutterRenderer alloc] initWithFlutterEngine:engineMock];
1199  OCMStub([engineMock renderer]).andReturn(renderer_);
1200 
1201  FlutterKeyboardManager* keyboardManager =
1202  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
1203  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
1204 
1205  // Capture calls to sendKeyEvent
1206  __block NSMutableArray<KeyEventWrapper*>* events = [NSMutableArray array];
1207  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
1208  callback:nil
1209  userData:nil])
1210  .andDo((^(NSInvocation* invocation) {
1211  FlutterKeyEvent* event;
1212  [invocation getArgument:&event atIndex:2];
1213  [events addObject:[[KeyEventWrapper alloc] initWithEvent:event]];
1214  }));
1215 
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) {
1221  NSData* data;
1222  [invocation getArgument:&data atIndex:3];
1223  id event = [[FlutterJSONMessageCodec sharedInstance] decode:data];
1224  [channelEvents addObject:event];
1225  }));
1226 
1227  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
1228  nibName:@""
1229  bundle:nil];
1230  [viewController loadView];
1231  [viewController viewWillAppear];
1232 
1233  // Zeroed modifier flag should not synthesize events.
1234  NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1235  [viewController mouseMoved:mouseEvent];
1236  EXPECT_EQ([events count], 0u);
1237 
1238  // For each modifier key, check that key events are synthesized.
1239  for (NSNumber* keyCode in flutter::keyCodeToModifierFlag) {
1240  FlutterKeyEvent* event;
1241  NSDictionary* channelEvent;
1242  NSNumber* logicalKey;
1243  NSNumber* physicalKey;
1244  NSEventModifierFlags flag = [flutter::keyCodeToModifierFlag[keyCode] unsignedLongValue];
1245 
1246  // Cocoa event always contain combined flags.
1248  flag |= NSEventModifierFlagShift;
1249  }
1251  flag |= NSEventModifierFlagControl;
1252  }
1254  flag |= NSEventModifierFlagOption;
1255  }
1257  flag |= NSEventModifierFlagCommand;
1258  }
1259 
1260  // Should synthesize down event.
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);
1271 
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)]);
1276 
1277  // Should synthesize up event.
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);
1288 
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)]);
1293 
1294  [events removeAllObjects];
1295  [channelEvents removeAllObjects];
1296  };
1297 
1298  return true;
1299 }
const NSDictionary * keyCodeToModifierFlag
@ kModifierFlagControlLeft
@ kModifierFlagControlRight

◆ testMouseDownUpEventsSentToNextResponder:

- (bool) testMouseDownUpEventsSentToNextResponder: (id)  mockEngine

Definition at line 1137 of file FlutterViewControllerTest.mm.

1149  :(id)engineMock {
1150  if (@available(macOS 13.3.1, *)) {
1151  // This workaround is disabled for macOS 13.3.1 onwards, since the underlying AppKit bug is
1152  // fixed.
1153  return true;
1154  }
1155 
1156  // The root cause of the above bug is NSResponder mouseDown/mouseUp methods that don't correctly
1157  // walk the responder chain calling the appropriate method on the next responder under certain
1158  // conditions. Simulate this by swizzling out the default implementations and replacing them with
1159  // no-ops.
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);
1165 
1166  // Verify that mouseDown/mouseUp trigger mouseDown/mouseUp calls on FlutterViewController.
1167  MouseEventFlutterViewController* viewController =
1168  [[MouseEventFlutterViewController alloc] initWithEngine:engineMock nibName:@"" bundle:nil];
1169  FlutterView* view = (FlutterView*)[viewController view];
1170 
1171  EXPECT_FALSE(viewController.mouseDownCalled);
1172  EXPECT_FALSE(viewController.mouseUpCalled);
1173 
1174  NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1175  [view mouseDown:mouseEvent];
1176  EXPECT_TRUE(viewController.mouseDownCalled);
1177  EXPECT_FALSE(viewController.mouseUpCalled);
1178 
1179  viewController.mouseDownCalled = NO;
1180  [view mouseUp:mouseEvent];
1181  EXPECT_FALSE(viewController.mouseDownCalled);
1182  EXPECT_TRUE(viewController.mouseUpCalled);
1183 
1184  // Restore the original NSResponder mouseDown/mouseUp implementations.
1185  method_setImplementation(mouseDown, origMouseDown);
1186  method_setImplementation(mouseUp, origMouseUp);
1187 
1188  return true;
1189 }

◆ testTrackpadGesturesAreSentToFramework:

- (bool) testTrackpadGesturesAreSentToFramework: (id)  mockEngine

Definition at line 175 of file FlutterViewControllerTest.mm.

774  :(id)engineMock {
775  // Need to return a real renderer to allow view controller to load.
776  FlutterRenderer* renderer_ = [[FlutterRenderer alloc] initWithFlutterEngine:engineMock];
777  OCMStub([engineMock renderer]).andReturn(renderer_);
778  __block bool called = false;
779  __block FlutterPointerEvent last_event;
780  OCMStub([[engineMock ignoringNonObjectArgs] sendPointerEvent:kDefaultFlutterPointerEvent])
781  .andDo((^(NSInvocation* invocation) {
782  FlutterPointerEvent* event;
783  [invocation getArgument:&event atIndex:2];
784  called = true;
785  last_event = *event;
786  }));
787 
788  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
789  nibName:@""
790  bundle:nil];
791  [viewController loadView];
792 
793  // Test for pan events.
794  // Start gesture.
795  CGEventRef cgEventStart = CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0);
796  CGEventSetType(cgEventStart, kCGEventScrollWheel);
797  CGEventSetIntegerValueField(cgEventStart, kCGScrollWheelEventScrollPhase, kCGScrollPhaseBegan);
798  CGEventSetIntegerValueField(cgEventStart, kCGScrollWheelEventIsContinuous, 1);
799 
800  called = false;
801  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventStart]];
802  EXPECT_TRUE(called);
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);
807 
808  // Update gesture.
809  CGEventRef cgEventUpdate = CGEventCreateCopy(cgEventStart);
810  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventScrollPhase, kCGScrollPhaseChanged);
811  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis2, 1); // pan_x
812  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis1, 2); // pan_y
813 
814  called = false;
815  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventUpdate]];
816  EXPECT_TRUE(called);
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);
823 
824  // Make sure the pan values accumulate.
825  called = false;
826  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventUpdate]];
827  EXPECT_TRUE(called);
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);
834 
835  // End gesture.
836  CGEventRef cgEventEnd = CGEventCreateCopy(cgEventStart);
837  CGEventSetIntegerValueField(cgEventEnd, kCGScrollWheelEventScrollPhase, kCGScrollPhaseEnded);
838 
839  called = false;
840  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventEnd]];
841  EXPECT_TRUE(called);
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);
846 
847  // Start system momentum.
848  CGEventRef cgEventMomentumStart = CGEventCreateCopy(cgEventStart);
849  CGEventSetIntegerValueField(cgEventMomentumStart, kCGScrollWheelEventScrollPhase, 0);
850  CGEventSetIntegerValueField(cgEventMomentumStart, kCGScrollWheelEventMomentumPhase,
851  kCGMomentumScrollPhaseBegin);
852 
853  called = false;
854  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMomentumStart]];
855  EXPECT_FALSE(called);
856 
857  // Advance system momentum.
858  CGEventRef cgEventMomentumUpdate = CGEventCreateCopy(cgEventStart);
859  CGEventSetIntegerValueField(cgEventMomentumUpdate, kCGScrollWheelEventScrollPhase, 0);
860  CGEventSetIntegerValueField(cgEventMomentumUpdate, kCGScrollWheelEventMomentumPhase,
861  kCGMomentumScrollPhaseContinue);
862 
863  called = false;
864  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMomentumUpdate]];
865  EXPECT_FALSE(called);
866 
867  // Mock a touch on the trackpad.
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); // 150 milliseconds.
875 
876  // Scroll inertia cancel event should not be issued (timestamp too far in the future).
877  called = false;
878  [viewController touchesBeganWithEvent:touchEventMock1];
879  EXPECT_FALSE(called);
880 
881  // Mock another touch on the trackpad.
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); // 5 milliseconds.
886 
887  // Scroll inertia cancel event should be issued.
888  called = false;
889  [viewController touchesBeganWithEvent:touchEventMock2];
890  EXPECT_TRUE(called);
891  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindScrollInertiaCancel);
892  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
893 
894  // End system momentum.
895  CGEventRef cgEventMomentumEnd = CGEventCreateCopy(cgEventStart);
896  CGEventSetIntegerValueField(cgEventMomentumEnd, kCGScrollWheelEventScrollPhase, 0);
897  CGEventSetIntegerValueField(cgEventMomentumEnd, kCGScrollWheelEventMomentumPhase,
898  kCGMomentumScrollPhaseEnd);
899 
900  called = false;
901  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMomentumEnd]];
902  EXPECT_FALSE(called);
903 
904  // May-begin and cancel are used while macOS determines which type of gesture to choose.
905  CGEventRef cgEventMayBegin = CGEventCreateCopy(cgEventStart);
906  CGEventSetIntegerValueField(cgEventMayBegin, kCGScrollWheelEventScrollPhase,
907  kCGScrollPhaseMayBegin);
908 
909  called = false;
910  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMayBegin]];
911  EXPECT_TRUE(called);
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);
916 
917  // Cancel gesture.
918  CGEventRef cgEventCancel = CGEventCreateCopy(cgEventStart);
919  CGEventSetIntegerValueField(cgEventCancel, kCGScrollWheelEventScrollPhase,
920  kCGScrollPhaseCancelled);
921 
922  called = false;
923  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventCancel]];
924  EXPECT_TRUE(called);
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);
929 
930  // A discrete scroll event should use the PointerSignal system.
931  CGEventRef cgEventDiscrete = CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0);
932  CGEventSetType(cgEventDiscrete, kCGEventScrollWheel);
933  CGEventSetIntegerValueField(cgEventDiscrete, kCGScrollWheelEventIsContinuous, 0);
934  CGEventSetIntegerValueField(cgEventDiscrete, kCGScrollWheelEventDeltaAxis2, 1); // scroll_delta_x
935  CGEventSetIntegerValueField(cgEventDiscrete, kCGScrollWheelEventDeltaAxis1, 2); // scroll_delta_y
936 
937  called = false;
938  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventDiscrete]];
939  EXPECT_TRUE(called);
940  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindScroll);
941  // pixelsPerLine is 40.0 and direction is reversed.
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);
944 
945  // A discrete scroll event should use the PointerSignal system, and flip the
946  // direction when shift is pressed.
947  CGEventRef cgEventDiscreteShift =
948  CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0);
949  CGEventSetType(cgEventDiscreteShift, kCGEventScrollWheel);
950  CGEventSetFlags(cgEventDiscreteShift, static_cast<uint64_t>(kCGEventFlagMaskShift) |
951  static_cast<uint64_t>(flutter::kModifierFlagShiftLeft));
952  CGEventSetIntegerValueField(cgEventDiscreteShift, kCGScrollWheelEventIsContinuous, 0);
953  CGEventSetIntegerValueField(cgEventDiscreteShift, kCGScrollWheelEventDeltaAxis2,
954  0); // scroll_delta_x
955  CGEventSetIntegerValueField(cgEventDiscreteShift, kCGScrollWheelEventDeltaAxis1,
956  2); // scroll_delta_y
957 
958  called = false;
959  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventDiscreteShift]];
960  EXPECT_TRUE(called);
961  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindScroll);
962  // pixelsPerLine is 40.0, direction is reversed and axes have been flipped back.
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);
966 
967  // Test for scale events.
968  // Start gesture.
969  called = false;
970  [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
971  NSEventPhaseBegan, 1, 0)];
972  EXPECT_TRUE(called);
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);
977 
978  // Update gesture.
979  called = false;
980  [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
981  NSEventPhaseChanged, 1, 0)];
982  EXPECT_TRUE(called);
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); // macOS uses logarithmic scaling values, the linear value for
990  // flutter here should be 2^1 = 2.
991  EXPECT_EQ(last_event.rotation, 0);
992 
993  // Make sure the scale values accumulate.
994  called = false;
995  [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
996  NSEventPhaseChanged, 1, 0)];
997  EXPECT_TRUE(called);
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); // macOS uses logarithmic scaling values, the linear value for
1005  // flutter here should be 2^(1+1) = 2.
1006  EXPECT_EQ(last_event.rotation, 0);
1007 
1008  // End gesture.
1009  called = false;
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);
1017 
1018  // Test for rotation events.
1019  // Start gesture.
1020  called = false;
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);
1028 
1029  // Update gesture.
1030  called = false;
1031  [viewController rotateWithEvent:flutter::testing::MockGestureEvent(
1032  NSEventTypeRotate, NSEventPhaseChanged, 0, -180)]; // degrees
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); // radians
1042 
1043  // Make sure the rotation values accumulate.
1044  called = false;
1045  [viewController rotateWithEvent:flutter::testing::MockGestureEvent(
1046  NSEventTypeRotate, NSEventPhaseChanged, 0, -360)]; // degrees
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); // radians
1056 
1057  // End gesture.
1058  called = false;
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);
1066 
1067  // Test that stray NSEventPhaseCancelled event does not crash
1068  called = false;
1069  [viewController rotateWithEvent:flutter::testing::MockGestureEvent(NSEventTypeRotate,
1070  NSEventPhaseCancelled, 0, 0)];
1071  EXPECT_FALSE(called);
1072 
1073  return true;
1074 }
static const FlutterPointerEvent kDefaultFlutterPointerEvent

◆ testViewControllerIsReleased

- (bool) testViewControllerIsReleased

Definition at line 1137 of file FlutterViewControllerTest.mm.

1301  {
1302  __weak FlutterViewController* weakController;
1303  @autoreleasepool {
1304  id engineMock = flutter::testing::CreateMockFlutterEngine(@"");
1305 
1306  FlutterRenderer* renderer_ = [[FlutterRenderer alloc] initWithFlutterEngine:engineMock];
1307  OCMStub([engineMock renderer]).andReturn(renderer_);
1308 
1309  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
1310  nibName:@""
1311  bundle:nil];
1312  [viewController loadView];
1313  weakController = viewController;
1314 
1315  [engineMock shutDownEngine];
1316  }
1317 
1318  EXPECT_EQ(weakController, nil);
1319  return true;
1320 }
id CreateMockFlutterEngine(NSString *pasteboardString)

◆ testViewWillAppearCalledMultipleTimes:

- (bool) testViewWillAppearCalledMultipleTimes: (id)  mockEngine

Definition at line 175 of file FlutterViewControllerTest.mm.

1110  :(id)engineMock {
1111  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
1112  nibName:@""
1113  bundle:nil];
1114  [viewController viewWillAppear];
1115  [viewController viewWillAppear];
1116  return true;
1117 }

The documentation for this class was generated from the following file: