FlutterViewControllerTest.mm

Go to the documentation of this file.

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#import <OCMock/OCMock.h>
#import <XCTest/XCTest.h>
 
#include "flutter/fml/platform/darwin/message_loop_darwin.h"
#import "flutter/lib/ui/window/platform_configuration.h"
#include "flutter/lib/ui/window/pointer_data.h"
#import "flutter/lib/ui/window/viewport_metrics.h"
#import "flutter/shell/platform/darwin/common/framework/Headers/FlutterBinaryMessenger.h"
#import "flutter/shell/platform/darwin/common/framework/Headers/FlutterHourFormat.h"
#import "flutter/shell/platform/darwin/common/framework/Headers/FlutterMacros.h"
#import "flutter/shell/platform/darwin/ios/framework/Headers/FlutterViewController.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/FlutterAppDelegate_Internal.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/FlutterEmbedderKeyResponder.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/FlutterEngine+TaskRunners.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/FlutterEngine_Internal.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/FlutterFakeKeyEvents.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/FlutterPluginAppLifeCycleDelegate_internal.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/FlutterSharedApplication.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/FlutterTextInputPlugin.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/FlutterView.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/FlutterViewController_Internal.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/UIViewController+FlutterScreenAndSceneIfLoaded.h"
#import "flutter/shell/platform/darwin/ios/framework/Source/vsync_waiter_ios.h"
#import "flutter/shell/platform/embedder/embedder.h"
#import "flutter/testing/ios/IosUnitTests/App/AppDelegate.h"
#import "flutter/third_party/spring_animation/spring_animation.h"
 
FLUTTER_ASSERT_ARC
 
using namespace flutter::testing;
 
typedef void (^FlutterKeyboardAnimationCallback)(NSTimeInterval targetTime);
 
@interface FlutterKeyboardInsetManager (Test)
- (void)setUpKeyboardAnimationVsyncClient:
    (FlutterKeyboardAnimationCallback)keyboardAnimationCallback;
@property(nonatomic, assign, readwrite) CGFloat targetViewInsetBottom;
@property(nonatomic, assign) BOOL keyboardAnimationIsShowing;
@property(nonatomic, weak) id<FlutterKeyboardInsetManagerDelegate> delegate;
@property(nonatomic, strong) FlutterVSyncClient* keyboardAnimationVSyncClient;
@property(nonatomic, assign) BOOL isKeyboardInOrTransitioningFromBackground;
- (void)handleKeyboardNotification:(NSNotification*)notification;
- (BOOL)isKeyboardNotificationForDifferentView:(NSNotification*)notification;
- (CGFloat)calculateKeyboardInset:(CGRect)keyboardFrame
                     keyboardMode:(FlutterKeyboardMode)keyboardMode;
- (BOOL)shouldIgnoreKeyboardNotification:(NSNotification*)notification;
- (FlutterKeyboardMode)calculateKeyboardAttachMode:(NSNotification*)notification;
- (CGFloat)calculateMultitaskingAdjustment:(CGRect)screenRect keyboardFrame:(CGRect)keyboardFrame;
- (void)startKeyBoardAnimation:(NSTimeInterval)duration;
- (void)hideKeyboardImmediately;
- (UIView*)keyboardAnimationView;
- (SpringAnimation*)keyboardSpringAnimation;
- (void)setUpKeyboardSpringAnimationIfNeeded:(CAAnimation*)keyboardAnimation;
- (void)ensureViewportMetricsIsCorrect;
- (void)invalidateKeyboardAnimationVSyncClient;
@end
 
// A fake keyboard inset manager.
//
// Used to verify that FlutterViewController drives the manager through the
// FlutterKeyboardInsetManagerProtocol (e.g. on viewDidDisappear), while
// avoiding the need to set up and perform real animations.
@interface FakeFlutterKeyboardInsetManager : NSObject <FlutterKeyboardInsetManagerProtocol>
@property(nonatomic, assign) CGFloat targetViewInsetBottom;
@property(nonatomic, assign) BOOL isKeyboardInOrTransitioningFromBackground;
@property(nonatomic, strong) FlutterVSyncClient* keyboardAnimationVSyncClient;
@property(nonatomic, assign) BOOL didCallEnsureViewportMetricsIsCorrect;
@property(nonatomic, assign) BOOL didCallInvalidateKeyboardAnimationVSyncClient;
 
- (instancetype)initWithDelegate:(id<FlutterKeyboardInsetManagerDelegate>)delegate;
@end
 
@implementation FakeFlutterKeyboardInsetManager {
  __weak id<FlutterKeyboardInsetManagerDelegate> _delegate;
}
 
- (instancetype)initWithDelegate:(id<FlutterKeyboardInsetManagerDelegate>)delegate {
  self = [super init];
  if (self) {
    _delegate = delegate;
  }
  return self;
}
 
- (void)setDelegate:(id<FlutterKeyboardInsetManagerDelegate>)delegate {
  _delegate = delegate;
}
 
- (id<FlutterKeyboardInsetManagerDelegate>)delegate {
  return _delegate;
}
 
- (void)startKeyBoardAnimation:(NSTimeInterval)duration {
}
 
- (void)handleKeyboardNotification:(NSNotification*)notification {
}
 
- (void)setUpKeyboardAnimationVsyncClient:(FlutterKeyboardAnimationCallback)animationCallback {
  self.keyboardAnimationVSyncClient = nil;
}
 
- (void)invalidate {
}
 
- (void)setUpKeyboardSpringAnimationIfNeeded:(CAAnimation*)keyboardAnimation {
}
 
- (BOOL)shouldIgnoreKeyboardNotification:(NSNotification*)notification {
  return NO;
}
 
- (FlutterKeyboardMode)calculateKeyboardAttachMode:(NSNotification*)notification {
  return FlutterKeyboardModeHidden;
}
 
- (void)ensureViewportMetricsIsCorrect {
  self.didCallEnsureViewportMetricsIsCorrect = YES;
}
 
- (void)invalidateKeyboardAnimationVSyncClient {
  self.didCallInvalidateKeyboardAnimationVSyncClient = YES;
}
 
- (void)hideKeyboardImmediately {
  [self ensureViewportMetricsIsCorrect];
  [self invalidateKeyboardAnimationVSyncClient];
}
 
- (SpringAnimation*)keyboardSpringAnimation {
  return nullptr;
}
 
- (UIView*)keyboardAnimationView {
  return nullptr;
}
 
@end
 
@interface TestKeyboardInsetDelegate : NSObject <FlutterKeyboardInsetManagerDelegate>
@property(nonatomic, strong) UIScreen* mockScreen;
@property(nonatomic, strong) UIView* mockView;
@property(nonatomic, strong) FlutterEngine* mockEngine;
@property(nonatomic, assign) CGFloat currentInset;
@property(nonatomic, copy) void (^updateViewportMetricsBlock)(CGFloat inset);
@property(nonatomic, assign) BOOL isViewLoaded;
@property(nonatomic, assign) BOOL mockIsPadInSlideOverOrStageManagerMode;
@property(nonatomic, assign) CGRect mockConvertedViewRect;
@property(nonatomic, strong) FlutterFMLTaskRunner* mockTaskRunner;
@end
 
@implementation TestKeyboardInsetDelegate
 
- (instancetype)init {
  if (self = [super init]) {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
    _mockTaskRunner = [[FlutterFMLTaskRunner alloc]
        initWithTaskRunner:fml::MessageLoop::GetCurrent().GetTaskRunner()];
  }
  return self;
}
 
- (FlutterFMLTaskRunner*)uiTaskRunner {
  return self.mockTaskRunner;
}
 
- (void)updateViewportMetricsWithInset:(CGFloat)inset {
  self.currentInset = inset;
  if (self.updateViewportMetricsBlock) {
    self.updateViewportMetricsBlock(inset);
  }
}
 
- (CGFloat)physicalViewInsetBottom {
  return self.currentInset;
}
 
- (UIView*)view {
  return self.mockView;
}
 
- (FlutterEngine*)engine {
  return self.mockEngine;
}
 
- (UIScreen*)flutterScreenIfViewLoaded {
  return self.mockScreen;
}
 
- (BOOL)isPadInSlideOverOrStageManagerMode {
  return self.mockIsPadInSlideOverOrStageManagerMode;
}
 
- (CGRect)convertViewRectToScreen:(CGRect)rect {
  return self.mockConvertedViewRect;
}
 
@end
 
/// Sometimes we have to use a custom mock to avoid retain cycles in OCMock.
/// Used for testing low memory notification.
@interface FlutterEnginePartialMock : FlutterEngine
 
@property(nonatomic, strong) FlutterBasicMessageChannel* lifecycleChannel;
@property(nonatomic, strong) FlutterBasicMessageChannel* keyEventChannel;
@property(nonatomic, weak) FlutterViewController* viewController;
@property(nonatomic, strong) FlutterTextInputPlugin* textInputPlugin;
@property(nonatomic, assign) BOOL didCallNotifyLowMemory;
@property(nonatomic, strong) FlutterFMLTaskRunner* uiTaskRunner;
 
- (FlutterTextInputPlugin*)textInputPlugin;
 
- (void)sendKeyEvent:(const FlutterKeyEvent&)event
            callback:(nullable FlutterKeyEventCallback)callback
            userData:(nullable void*)userData;
 
- (nullable FlutterFMLTaskRunner*)uiTaskRunner;
- (BOOL)runWithEntrypoint:(nullable NSString*)entrypoint;
- (void)attachView;
@end
 
@implementation FlutterEnginePartialMock
 
// Synthesize properties declared readonly in FlutterEngine.
@synthesize lifecycleChannel;
@synthesize keyEventChannel;
@synthesize viewController;
@synthesize textInputPlugin;
 
- (void)notifyLowMemory {
  _didCallNotifyLowMemory = YES;
}
 
- (instancetype)init {
  if (self = [super init]) {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
    _uiTaskRunner = [[FlutterFMLTaskRunner alloc]
        initWithTaskRunner:fml::MessageLoop::GetCurrent().GetTaskRunner()];
  }
  return self;
}
 
- (nullable FlutterFMLTaskRunner*)uiTaskRunner {
  return _uiTaskRunner;
}
 
- (BOOL)runWithEntrypoint:(nullable NSString*)entrypoint {
  return YES;
}
 
- (void)attachView {
  // Do nothing to avoid crash when platformView is nil on bots.
}
 
- (void)sendKeyEvent:(const FlutterKeyEvent&)event
            callback:(FlutterKeyEventCallback)callback
            userData:(void*)userData API_AVAILABLE(ios(9.0)) {
  if (callback == nil) {
    return;
  }
  // NSAssert(callback != nullptr, @"Invalid callback");
  // Response is async, so we have to post it to the run loop instead of calling
  // it directly.
  CFRunLoopPerformBlock(CFRunLoopGetCurrent(), fml::MessageLoopDarwin::kMessageLoopCFRunLoopMode,
                        ^() {
                          callback(true, userData);
                        });
}
@end
 
@interface FlutterEngine ()
- (BOOL)createShell:(NSString*)entrypoint
         libraryURI:(NSString*)libraryURI
       initialRoute:(NSString*)initialRoute;
- (void)dispatchPointerDataPacket:(std::unique_ptr<flutter::PointerDataPacket>)packet;
- (void)updateViewportMetrics:(flutter::ViewportMetrics)viewportMetrics;
- (void)attachView;
@end
 
@interface FlutterEngine (TestLowMemory)
- (void)notifyLowMemory;
@end
 
extern NSNotificationName const FlutterViewControllerWillDealloc;
 
/// A simple mock class for FlutterEngine.
///
/// OCMClassMock can't be used for FlutterEngine sometimes because OCMock retains arguments to
/// invocations and since the init for FlutterViewController calls a method on the
/// FlutterEngine it creates a retain cycle that stops us from testing behaviors related to
/// deleting FlutterViewControllers.
///
/// Used for testing deallocation.
@interface MockEngine : NSObject
@property(nonatomic, strong) FlutterDartProject* project;
@end
 
@implementation MockEngine
- (FlutterViewController*)viewController {
  return nil;
}
- (void)setViewController:(FlutterViewController*)viewController {
  // noop
}
@end
 
@interface FlutterKeyboardManager (Tests)
@property(nonatomic, retain, readonly)
    NSMutableArray<id<FlutterKeyPrimaryResponder>>* primaryResponders;
@end
 
@interface FlutterEmbedderKeyResponder (Tests)
@property(nonatomic, copy, readonly) FlutterSendKeyEvent sendEvent;
@end
 
@interface NSObject (Tests)
@property(nonatomic, strong) FlutterEngine* mockLaunchEngine;
@end
 
@interface FlutterViewController (Tests) <FlutterKeyboardInsetManagerDelegate>
 
@property(nonatomic, assign) double targetViewInsetBottom;
@property(nonatomic, assign) BOOL keyboardAnimationIsShowing;
@property(nonatomic, strong) FlutterVSyncClient* keyboardAnimationVSyncClient;
@property(nonatomic, strong) FlutterVSyncClient* touchRateCorrectionVSyncClient;
@property(nonatomic, assign) BOOL awokenFromNib;
 
- (void)createTouchRateCorrectionVSyncClientIfNeeded;
- (void)surfaceUpdated:(BOOL)appeared;
- (void)performOrientationUpdate:(UIInterfaceOrientationMask)new_preferences;
- (void)handlePressEvent:(FlutterUIPressProxy*)press
              nextAction:(void (^)())next API_AVAILABLE(ios(13.4));
- (void)discreteScrollEvent:(UIPanGestureRecognizer*)recognizer;
- (void)updateViewportMetricsIfNeeded;
- (void)updateAutoResizeConstraints;
- (void)checkAndUpdateAutoResizeConstraints;
- (void)onUserSettingsChanged:(NSNotification*)notification;
- (void)applicationWillTerminate:(NSNotification*)notification;
- (void)goToApplicationLifecycle:(nonnull NSString*)state;
 
- (void)addInternalPlugins;
- (flutter::PointerData)generatePointerDataForFake;
- (void)sharedSetupWithProject:(nullable FlutterDartProject*)project
                  initialRoute:(nullable NSString*)initialRoute;
- (void)applicationBecameActive:(NSNotification*)notification;
- (void)applicationWillResignActive:(NSNotification*)notification;
- (void)applicationWillTerminate:(NSNotification*)notification;
- (void)applicationDidEnterBackground:(NSNotification*)notification;
- (void)applicationWillEnterForeground:(NSNotification*)notification;
- (void)sceneBecameActive:(NSNotification*)notification API_AVAILABLE(ios(13.0));
- (void)sceneWillResignActive:(NSNotification*)notification API_AVAILABLE(ios(13.0));
- (void)sceneWillDisconnect:(NSNotification*)notification API_AVAILABLE(ios(13.0));
- (void)sceneDidEnterBackground:(NSNotification*)notification API_AVAILABLE(ios(13.0));
- (void)sceneWillEnterForeground:(NSNotification*)notification API_AVAILABLE(ios(13.0));
- (void)triggerTouchRateCorrectionIfNeeded:(NSSet*)touches;
- (void)onAccessibilityStatusChanged:(NSNotification*)notification;
@end
 
@interface FlutterViewControllerTest : XCTestCase
@property(nonatomic, strong) id mockEngine;
@property(nonatomic, strong) id mockTextInputPlugin;
@property(nonatomic, strong) id messageSent;
- (void)sendMessage:(id _Nullable)message reply:(FlutterReply _Nullable)callback;
@end
 
@interface UITouch ()
 
@property(nonatomic, readwrite) UITouchPhase phase;
 
@end
 
@implementation FlutterViewControllerTest
 
- (void)setUp {
  self.mockEngine = OCMClassMock([FlutterEngine class]);
  self.mockTextInputPlugin = OCMClassMock([FlutterTextInputPlugin class]);
  OCMStub([self.mockEngine textInputPlugin]).andReturn(self.mockTextInputPlugin);
  self.messageSent = nil;
}
 
- (void)tearDown {
  // We stop mocking here to avoid retain cycles that stop
  // FlutterViewControllers from deallocing.
  [self.mockEngine stopMocking];
  self.mockEngine = nil;
  self.mockTextInputPlugin = nil;
  self.messageSent = nil;
}
 
- (id)setUpMockScreen {
  UIScreen* mockScreen = OCMClassMock([UIScreen class]);
  // iPhone 14 pixels
  CGRect screenBounds = CGRectMake(0, 0, 1170, 2532);
  OCMStub([mockScreen bounds]).andReturn(screenBounds);
  CGFloat screenScale = 1;
  OCMStub([mockScreen scale]).andReturn(screenScale);
 
  return mockScreen;
}
 
- (id)setUpMockView:(FlutterViewController*)viewControllerMock
             screen:(UIScreen*)screen
          viewFrame:(CGRect)viewFrame
     convertedFrame:(CGRect)convertedFrame {
  OCMStub([viewControllerMock flutterScreenIfViewLoaded]).andReturn(screen);
  UIView* view = [[UIView alloc] initWithFrame:viewFrame];
  UIWindow* window = [[UIWindow alloc] initWithFrame:viewFrame];
  [window addSubview:view];
 
  OCMStub([viewControllerMock viewIfLoaded]).andReturn(view);
  OCMStub([viewControllerMock view]).andReturn(view);
 
  return view;
}
 
- (void)testViewDidLoadWillInvokeCreateTouchRateCorrectionVSyncClient {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  [viewControllerMock loadView];
  [viewControllerMock viewDidLoad];
  OCMVerify([viewControllerMock createTouchRateCorrectionVSyncClientIfNeeded]);
}
 
- (void)testStartKeyboardAnimationWillInvokeSetupKeyboardSpringAnimationIfNeeded {
  FlutterEnginePartialMock* engine = [[FlutterEnginePartialMock alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  OCMStub([viewControllerMock isViewLoaded]).andReturn(YES);
  __unused UIView* dummyView = [viewControllerMock view];
  viewController.keyboardInsetManager.delegate =
      (id<FlutterKeyboardInsetManagerDelegate>)viewControllerMock;
 
  engine.viewController = viewControllerMock;
 
  FlutterKeyboardInsetManager* manager =
      (FlutterKeyboardInsetManager*)viewController.keyboardInsetManager;
 
  id viewClassMock = OCMClassMock([UIView class]);
  OCMStub([viewClassMock animateWithDuration:0.25 animations:[OCMArg any] completion:[OCMArg any]])
      .andDo(^(NSInvocation* invocation) {
        // -getArgument:atIndex: does a raw memcpy without retaining; declare the block locals
        // __unsafe_unretained so ARC doesn't over-release the invocation-owned blocks.
        __unsafe_unretained void (^animations)(void);
        [invocation getArgument:&animations atIndex:3];
        if (animations) {
          animations();
        }
        __unsafe_unretained void (^completion)(BOOL finished);
        [invocation getArgument:&completion atIndex:4];
        if (completion) {
          completion(YES);
        }
      });
 
  // Pre-seed a spring animation. startKeyBoardAnimation: must call
  // setUpKeyboardSpringAnimationIfNeeded:, which clears it back to nil since the UIView animation
  // is mocked out and therefore produces no real "position" CASpringAnimation to derive one from.
  manager.targetViewInsetBottom = 320;
  manager.keyboardSpringAnimation = [[SpringAnimation alloc] initWithStiffness:100
                                                                       damping:10
                                                                          mass:1
                                                               initialVelocity:0
                                                                     fromValue:0
                                                                       toValue:320];
  XCTAssertNotNil(manager.keyboardSpringAnimation);
 
  [manager startKeyBoardAnimation:0.25];
 
  XCTAssertNil(manager.keyboardSpringAnimation);
  [viewClassMock stopMocking];
}
 
- (void)testSetupKeyboardSpringAnimationIfNeeded {
  FlutterViewController* viewController =
      [[FlutterViewController alloc] initWithEngine:self.mockEngine nibName:nil bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  viewController.keyboardInsetManager.delegate =
      (id<FlutterKeyboardInsetManagerDelegate>)viewControllerMock;
  UIScreen* screen = [self setUpMockScreen];
  CGRect viewFrame = screen.bounds;
  [self setUpMockView:viewControllerMock
               screen:screen
            viewFrame:viewFrame
       convertedFrame:viewFrame];
 
  // Null check.
  [viewController.keyboardInsetManager setUpKeyboardSpringAnimationIfNeeded:nil];
  SpringAnimation* keyboardSpringAnimation =
      viewController.keyboardInsetManager.keyboardSpringAnimation;
  XCTAssertTrue(keyboardSpringAnimation == nil);
 
  // CAAnimation that is not a CASpringAnimation.
  CABasicAnimation* nonSpringAnimation = [CABasicAnimation animation];
  nonSpringAnimation.duration = 1.0;
  nonSpringAnimation.fromValue = [NSNumber numberWithFloat:0.0];
  nonSpringAnimation.toValue = [NSNumber numberWithFloat:1.0];
  nonSpringAnimation.keyPath = @"position";
  [viewController.keyboardInsetManager setUpKeyboardSpringAnimationIfNeeded:nonSpringAnimation];
  keyboardSpringAnimation = viewController.keyboardInsetManager.keyboardSpringAnimation;
 
  XCTAssertTrue(keyboardSpringAnimation == nil);
 
  // CASpringAnimation.
  CASpringAnimation* springAnimation = [CASpringAnimation animation];
  springAnimation.mass = 1.0;
  springAnimation.stiffness = 100.0;
  springAnimation.damping = 10.0;
  springAnimation.keyPath = @"position";
  springAnimation.fromValue = [NSValue valueWithCGPoint:CGPointMake(0, 0)];
  springAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(100, 100)];
  [viewController.keyboardInsetManager setUpKeyboardSpringAnimationIfNeeded:springAnimation];
  keyboardSpringAnimation = viewController.keyboardInsetManager.keyboardSpringAnimation;
  XCTAssertTrue(keyboardSpringAnimation != nil);
}
 
/**
 * @brief Verifies that simultaneous compounding animation calls are handled correctly.
 *
 * This captures animation calls made while the keyboard animation is currently animating.
 * If the new animation is in the same direction as the current animation, the current
 * animation should continue with an updated targetViewInsetBottom instead of starting a new one.
 */
- (void)testKeyboardAnimationIsShowingAndCompounding {
  UIScreen* screen = [self setUpMockScreen];
  CGFloat screenWidth = screen.bounds.size.width;
  CGFloat screenHeight = screen.bounds.size.height;
  CGRect viewFrame = screen.bounds;
 
  TestKeyboardInsetDelegate* delegate = [[TestKeyboardInsetDelegate alloc] init];
  delegate.isViewLoaded = YES;
  delegate.mockScreen = screen;
  delegate.mockView = [[UIView alloc] init];
  delegate.mockConvertedViewRect = viewFrame;
 
  FlutterEnginePartialMock* engine = [[FlutterEnginePartialMock alloc] init];
  delegate.mockEngine = engine;
 
  // Set the delegate as the engine's current view controller so the notifications are not
  // treated as coming from a different view (i.e. shouldIgnoreKeyboardNotification: returns NO).
  engine.viewController = (FlutterViewController*)delegate;
 
  FlutterKeyboardInsetManager* manager =
      [[FlutterKeyboardInsetManager alloc] initWithDelegate:delegate
                                         displayLinkManager:FlutterDisplayLinkManager.shared];
 
  BOOL isLocal = YES;
 
  // Start show keyboard animation.
  CGRect initialShowKeyboardBeginFrame = CGRectMake(0, screenHeight, screenWidth, 250);
  CGRect initialShowKeyboardEndFrame = CGRectMake(0, screenHeight - 250, screenWidth, 500);
  NSNotification* fakeNotification = [NSNotification
      notificationWithName:UIKeyboardWillChangeFrameNotification
                    object:nil
                  userInfo:@{
                    @"UIKeyboardFrameBeginUserInfoKey" : @(initialShowKeyboardBeginFrame),
                    @"UIKeyboardFrameEndUserInfoKey" : @(initialShowKeyboardEndFrame),
                    @"UIKeyboardAnimationDurationUserInfoKey" : @(0.25),
                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                  }];
  manager.targetViewInsetBottom = 0;
  [manager handleKeyboardNotification:fakeNotification];
  BOOL isShowingAnimation1 = manager.keyboardAnimationIsShowing;
  XCTAssertTrue(isShowingAnimation1);
 
  // Start compounding show keyboard animation.
  CGRect compoundingShowKeyboardBeginFrame = CGRectMake(0, screenHeight - 250, screenWidth, 250);
  CGRect compoundingShowKeyboardEndFrame = CGRectMake(0, screenHeight - 500, screenWidth, 500);
  fakeNotification = [NSNotification
      notificationWithName:UIKeyboardWillChangeFrameNotification
                    object:nil
                  userInfo:@{
                    @"UIKeyboardFrameBeginUserInfoKey" : @(compoundingShowKeyboardBeginFrame),
                    @"UIKeyboardFrameEndUserInfoKey" : @(compoundingShowKeyboardEndFrame),
                    @"UIKeyboardAnimationDurationUserInfoKey" : @(0.25),
                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                  }];
 
  [manager handleKeyboardNotification:fakeNotification];
  BOOL isShowingAnimation2 = manager.keyboardAnimationIsShowing;
  XCTAssertTrue(isShowingAnimation2);
  XCTAssertTrue(isShowingAnimation1 == isShowingAnimation2);
 
  // Start hide keyboard animation.
  CGRect initialHideKeyboardBeginFrame = CGRectMake(0, screenHeight - 500, screenWidth, 250);
  CGRect initialHideKeyboardEndFrame = CGRectMake(0, screenHeight - 250, screenWidth, 500);
  fakeNotification = [NSNotification
      notificationWithName:UIKeyboardWillChangeFrameNotification
                    object:nil
                  userInfo:@{
                    @"UIKeyboardFrameBeginUserInfoKey" : @(initialHideKeyboardBeginFrame),
                    @"UIKeyboardFrameEndUserInfoKey" : @(initialHideKeyboardEndFrame),
                    @"UIKeyboardAnimationDurationUserInfoKey" : @(0.25),
                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                  }];
 
  [manager handleKeyboardNotification:fakeNotification];
  BOOL isShowingAnimation3 = manager.keyboardAnimationIsShowing;
  XCTAssertFalse(isShowingAnimation3);
  XCTAssertTrue(isShowingAnimation2 != isShowingAnimation3);
 
  // Start compounding hide keyboard animation.
  CGRect compoundingHideKeyboardBeginFrame = CGRectMake(0, screenHeight - 250, screenWidth, 250);
  CGRect compoundingHideKeyboardEndFrame = CGRectMake(0, screenHeight, screenWidth, 500);
  fakeNotification = [NSNotification
      notificationWithName:UIKeyboardWillChangeFrameNotification
                    object:nil
                  userInfo:@{
                    @"UIKeyboardFrameBeginUserInfoKey" : @(compoundingHideKeyboardBeginFrame),
                    @"UIKeyboardFrameEndUserInfoKey" : @(compoundingHideKeyboardEndFrame),
                    @"UIKeyboardAnimationDurationUserInfoKey" : @(0.25),
                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                  }];
 
  [manager handleKeyboardNotification:fakeNotification];
  BOOL isShowingAnimation4 = manager.keyboardAnimationIsShowing;
  XCTAssertFalse(isShowingAnimation4);
  XCTAssertTrue(isShowingAnimation3 == isShowingAnimation4);
 
  [manager invalidate];
}
 
- (void)testShouldIgnoreKeyboardNotification {
  FlutterViewController* viewController =
      [[FlutterViewController alloc] initWithEngine:self.mockEngine nibName:nil bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  // Stub the mock engine to return the mock view controller to pass
  // isKeyboardNotificationForDifferentView
  OCMStub([self.mockEngine viewController]).andReturn(viewControllerMock);
 
  // Exercise the real shouldIgnoreKeyboardNotification: implementation.
  FlutterKeyboardInsetManager* managerMock = [[FlutterKeyboardInsetManager alloc]
        initWithDelegate:(id<FlutterKeyboardInsetManagerDelegate>)viewControllerMock
      displayLinkManager:FlutterDisplayLinkManager.shared];
  viewController.keyboardInsetManager = managerMock;
 
  UIScreen* screen = [self setUpMockScreen];
  CGRect viewFrame = screen.bounds;
  [self setUpMockView:viewControllerMock
               screen:screen
            viewFrame:viewFrame
       convertedFrame:viewFrame];
 
  CGFloat screenWidth = screen.bounds.size.width;
  CGFloat screenHeight = screen.bounds.size.height;
  CGRect emptyKeyboard = CGRectZero;
  CGRect zeroHeightKeyboard = CGRectMake(0, 0, screenWidth, 0);
  CGRect validKeyboardEndFrame = CGRectMake(0, screenHeight - 320, screenWidth, 320);
  BOOL isLocal = NO;
 
  // Hide notification, valid keyboard
  NSNotification* notification =
      [NSNotification notificationWithName:UIKeyboardWillHideNotification
                                    object:nil
                                  userInfo:@{
                                    @"UIKeyboardFrameEndUserInfoKey" : @(validKeyboardEndFrame),
                                    @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                                  }];
 
  BOOL shouldIgnore = [managerMock shouldIgnoreKeyboardNotification:notification];
  XCTAssertTrue(shouldIgnore == NO);
 
  // All zero keyboard
  isLocal = YES;
  notification = [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                               object:nil
                                             userInfo:@{
                                               @"UIKeyboardFrameEndUserInfoKey" : @(emptyKeyboard),
                                               @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                               @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                                             }];
  shouldIgnore = [managerMock shouldIgnoreKeyboardNotification:notification];
  XCTAssertTrue(shouldIgnore == YES);
 
  // Zero height keyboard
  isLocal = NO;
  notification =
      [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                    object:nil
                                  userInfo:@{
                                    @"UIKeyboardFrameEndUserInfoKey" : @(zeroHeightKeyboard),
                                    @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                                  }];
  shouldIgnore = [managerMock shouldIgnoreKeyboardNotification:notification];
  XCTAssertTrue(shouldIgnore == NO);
 
  // Valid keyboard, triggered from another app
  isLocal = NO;
  notification =
      [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                    object:nil
                                  userInfo:@{
                                    @"UIKeyboardFrameEndUserInfoKey" : @(validKeyboardEndFrame),
                                    @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                                  }];
  shouldIgnore = [managerMock shouldIgnoreKeyboardNotification:notification];
  XCTAssertTrue(shouldIgnore == YES);
 
  // Valid keyboard
  isLocal = YES;
  notification =
      [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                    object:nil
                                  userInfo:@{
                                    @"UIKeyboardFrameEndUserInfoKey" : @(validKeyboardEndFrame),
                                    @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                                  }];
  shouldIgnore = [managerMock shouldIgnoreKeyboardNotification:notification];
  XCTAssertTrue(shouldIgnore == NO);
 
  [(id)viewControllerMock stopMocking];
}
 
- (void)testKeyboardAnimationWillNotCrashWhenEngineDestroyed {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController.keyboardInsetManager
      setUpKeyboardAnimationVsyncClient:^(NSTimeInterval targetTime){
      }];
  [engine destroyContext];
}
 
- (void)testKeyboardAnimationFirstVsyncCallbackCalculatesSafeInset {
  FlutterEnginePartialMock* engine = [[FlutterEnginePartialMock alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  OCMStub([viewControllerMock isViewLoaded]).andReturn(YES);
  __unused UIView* dummyView = [viewControllerMock view];
  viewController.keyboardInsetManager.delegate =
      (id<FlutterKeyboardInsetManagerDelegate>)viewControllerMock;
 
  engine.viewController = viewControllerMock;
 
  XCTestExpectation* expectation = [self expectationWithDescription:@"metrics updated"];
  // Stub updateViewportMetricsWithInset: to capture the inset value passed.
  __block CGFloat capturedInset = -1.0;
  __block BOOL fulfilled = NO;
  OCMStub([viewControllerMock updateViewportMetricsWithInset:0])
      .ignoringNonObjectArgs()
      .andDo(^(NSInvocation* invocation) {
        [invocation getArgument:&capturedInset atIndex:2];
        if (!fulfilled) {
          fulfilled = YES;
          // Prevent the instant UIView animation completion block from overriding the captured
          // vsync inset.
          [viewController.keyboardInsetManager invalidateKeyboardAnimationVSyncClient];
          [expectation fulfill];
        }
      });
 
  // Configure keyboard spring animation.
  CASpringAnimation* springAnimation = [CASpringAnimation animation];
  springAnimation.mass = 1.0;
  springAnimation.stiffness = 100.0;
  springAnimation.damping = 10.0;
  springAnimation.keyPath = @"position";
 
  viewController.keyboardInsetManager.targetViewInsetBottom = 300.0;
 
  // Start the keyboard animation.
  [viewController.keyboardInsetManager startKeyBoardAnimation:0.25];
  [viewController.keyboardInsetManager setUpKeyboardSpringAnimationIfNeeded:springAnimation];
 
  // Simulate the first vsync callback passing the initial CADisplayLink directly.
  FlutterVSyncClient* client = viewController.keyboardInsetManager.keyboardAnimationVSyncClient;
  [client onDisplayLink:client.displayLink];
 
  // Wait for task runner to execute callback on main queue.
  [self waitForExpectationsWithTimeout:5.0 handler:nil];
 
  // The captured inset must be a finite, non-NaN, non-negative value (close to start of animation).
  XCTAssertFalse(isnan(capturedInset));
  XCTAssertFalse(isinf(capturedInset));
  XCTAssertGreaterThanOrEqual(capturedInset, 0.0);
  XCTAssertLessThan(capturedInset, 300.0);
}
 
- (void)testKeyboardAnimationCallbackIsDeliveredAsynchronously {
  // FlutterEnginePartialMock.uiTaskRunner runs on the current (test) message loop, so the vsync
  // client's display-link registration and invalidation happen deterministically on this thread.
  FlutterEnginePartialMock* engine = [[FlutterEnginePartialMock alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
 
  id mockCADisplayLink = OCMClassMock([CADisplayLink class]);
  OCMStub(
      ClassMethod([mockCADisplayLink displayLinkWithTarget:[OCMArg any]
                                                  selector:sel_registerName("onDisplayLink:")]));
 
  XCTestExpectation* expectation = [self expectationWithDescription:@"keyboard animation callback"];
  __block BOOL callbackExecuted = NO;
  [viewController.keyboardInsetManager
      setUpKeyboardAnimationVsyncClient:^(NSTimeInterval targetTime) {
        callbackExecuted = YES;
        [expectation fulfill];
      }];
 
  FlutterVSyncClient* client = viewController.keyboardInsetManager.keyboardAnimationVSyncClient;
  [client onDisplayLink:client.displayLink];
 
  // The callback is dispatched to the main queue, so it must not have run synchronously within
  // -onDisplayLink:.
  XCTAssertFalse(callbackExecuted);
 
  // Spinning the run loop drains the main queue, at which point the callback runs.
  [self waitForExpectationsWithTimeout:5.0 handler:nil];
  XCTAssertTrue(callbackExecuted);
  [mockCADisplayLink stopMocking];
}
 
- (void)testCalculateKeyboardAttachMode {
  FlutterViewController* viewController =
      [[FlutterViewController alloc] initWithEngine:self.mockEngine nibName:nil bundle:nil];
 
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  viewController.keyboardInsetManager.delegate =
      (id<FlutterKeyboardInsetManagerDelegate>)viewControllerMock;
  UIScreen* screen = [self setUpMockScreen];
  CGRect viewFrame = screen.bounds;
  [self setUpMockView:viewControllerMock
               screen:screen
            viewFrame:viewFrame
       convertedFrame:viewFrame];
 
  CGFloat screenWidth = screen.bounds.size.width;
  CGFloat screenHeight = screen.bounds.size.height;
 
  // hide notification
  CGRect keyboardFrame = CGRectZero;
  NSNotification* notification =
      [NSNotification notificationWithName:UIKeyboardWillHideNotification
                                    object:nil
                                  userInfo:@{
                                    @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                    @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                    @"UIKeyboardIsLocalUserInfoKey" : @(YES)
                                  }];
  FlutterKeyboardMode keyboardMode =
      [viewController.keyboardInsetManager calculateKeyboardAttachMode:notification];
  XCTAssertTrue(keyboardMode == FlutterKeyboardModeHidden);
 
  // all zeros
  keyboardFrame = CGRectZero;
  notification = [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                               object:nil
                                             userInfo:@{
                                               @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                               @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                               @"UIKeyboardIsLocalUserInfoKey" : @(YES)
                                             }];
  keyboardMode = [viewController.keyboardInsetManager calculateKeyboardAttachMode:notification];
  XCTAssertTrue(keyboardMode == FlutterKeyboardModeFloating);
 
  // 0 height
  keyboardFrame = CGRectMake(0, 0, screenWidth, 0);
  notification = [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                               object:nil
                                             userInfo:@{
                                               @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                               @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                               @"UIKeyboardIsLocalUserInfoKey" : @(YES)
                                             }];
  keyboardMode = [viewController.keyboardInsetManager calculateKeyboardAttachMode:notification];
  XCTAssertTrue(keyboardMode == FlutterKeyboardModeHidden);
 
  // floating
  keyboardFrame = CGRectMake(0, 0, 320, 320);
  notification = [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                               object:nil
                                             userInfo:@{
                                               @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                               @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                               @"UIKeyboardIsLocalUserInfoKey" : @(YES)
                                             }];
  keyboardMode = [viewController.keyboardInsetManager calculateKeyboardAttachMode:notification];
  XCTAssertTrue(keyboardMode == FlutterKeyboardModeFloating);
 
  // undocked
  keyboardFrame = CGRectMake(0, 0, screenWidth, 320);
  notification = [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                               object:nil
                                             userInfo:@{
                                               @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                               @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                               @"UIKeyboardIsLocalUserInfoKey" : @(YES)
                                             }];
  keyboardMode = [viewController.keyboardInsetManager calculateKeyboardAttachMode:notification];
  XCTAssertTrue(keyboardMode == FlutterKeyboardModeFloating);
 
  // docked
  keyboardFrame = CGRectMake(0, screenHeight - 320, screenWidth, 320);
  notification = [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                               object:nil
                                             userInfo:@{
                                               @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                               @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                               @"UIKeyboardIsLocalUserInfoKey" : @(YES)
                                             }];
  keyboardMode = [viewController.keyboardInsetManager calculateKeyboardAttachMode:notification];
  XCTAssertTrue(keyboardMode == FlutterKeyboardModeDocked);
 
  // docked - rounded values
  CGFloat longDecimalHeight = 320.666666666666666;
  keyboardFrame = CGRectMake(0, screenHeight - longDecimalHeight, screenWidth, longDecimalHeight);
  notification = [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                               object:nil
                                             userInfo:@{
                                               @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                               @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                               @"UIKeyboardIsLocalUserInfoKey" : @(YES)
                                             }];
  keyboardMode = [viewController.keyboardInsetManager calculateKeyboardAttachMode:notification];
  XCTAssertTrue(keyboardMode == FlutterKeyboardModeDocked);
 
  // hidden - rounded values
  keyboardFrame = CGRectMake(0, screenHeight - .0000001, screenWidth, longDecimalHeight);
  notification = [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                               object:nil
                                             userInfo:@{
                                               @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                               @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                               @"UIKeyboardIsLocalUserInfoKey" : @(YES)
                                             }];
  keyboardMode = [viewController.keyboardInsetManager calculateKeyboardAttachMode:notification];
  XCTAssertTrue(keyboardMode == FlutterKeyboardModeHidden);
 
  // hidden
  keyboardFrame = CGRectMake(0, screenHeight, screenWidth, 320);
  notification = [NSNotification notificationWithName:UIKeyboardWillChangeFrameNotification
                                               object:nil
                                             userInfo:@{
                                               @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                               @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                                               @"UIKeyboardIsLocalUserInfoKey" : @(YES)
                                             }];
  keyboardMode = [viewController.keyboardInsetManager calculateKeyboardAttachMode:notification];
  XCTAssertTrue(keyboardMode == FlutterKeyboardModeHidden);
}
 
- (void)testCalculateMultitaskingAdjustment {
  UIScreen* screen = [UIScreen mainScreen];
  CGFloat screenWidth = screen.bounds.size.width;
  CGFloat screenHeight = screen.bounds.size.height;
  CGRect screenRect = screen.bounds;
  CGRect convertedViewFrame = CGRectMake(0, 0, 320, screenHeight - 20);
  CGRect keyboardFrame = CGRectMake(20, screenHeight - 320, screenWidth, 300);
 
  TestKeyboardInsetDelegate* delegate = [[TestKeyboardInsetDelegate alloc] init];
  delegate.mockScreen = screen;
  delegate.isViewLoaded = YES;
 
  delegate.mockIsPadInSlideOverOrStageManagerMode = YES;
  delegate.mockConvertedViewRect = convertedViewFrame;
 
  FlutterKeyboardInsetManager* manager =
      [[FlutterKeyboardInsetManager alloc] initWithDelegate:delegate
                                         displayLinkManager:FlutterDisplayLinkManager.shared];
 
  CGFloat adjustment = [manager calculateMultitaskingAdjustment:screenRect
                                                  keyboardFrame:keyboardFrame];
  XCTAssertTrue(adjustment == 20);
}
 
- (void)testCalculateKeyboardInset {
  UIScreen* screen = [UIScreen mainScreen];
  CGFloat screenWidth = screen.bounds.size.width;
  CGFloat screenHeight = screen.bounds.size.height;
  CGRect convertedViewFrame = CGRectMake(0, 0, 320, screenHeight - 20);
  CGRect keyboardFrame = CGRectMake(20, screenHeight - 320, screenWidth, 300);
 
  TestKeyboardInsetDelegate* delegate = [[TestKeyboardInsetDelegate alloc] init];
  delegate.isViewLoaded = YES;
  delegate.mockScreen = screen;
 
  delegate.mockConvertedViewRect = convertedViewFrame;
 
  FlutterKeyboardInsetManager* manager =
      [[FlutterKeyboardInsetManager alloc] initWithDelegate:delegate
                                         displayLinkManager:FlutterDisplayLinkManager.shared];
 
  CGFloat inset = [manager calculateKeyboardInset:keyboardFrame
                                     keyboardMode:FlutterKeyboardModeDocked];
  XCTAssertTrue(inset == 300 * screen.scale);
}
 
- (void)testHandleKeyboardNotification {
  UIScreen* screen = [self setUpMockScreen];
  CGFloat screenWidth = screen.bounds.size.width;
  CGFloat screenHeight = screen.bounds.size.height;
  CGRect keyboardFrame = CGRectMake(0, screenHeight - 320, screenWidth, 320);
  CGRect viewFrame = screen.bounds;
  BOOL isLocal = YES;
  NSNotification* notification = [NSNotification
      notificationWithName:UIKeyboardWillShowNotification
                    object:nil
                  userInfo:@{
                    @"UIKeyboardFrameEndUserInfoKey" : [NSValue valueWithCGRect:keyboardFrame],
                    @"UIKeyboardAnimationDurationUserInfoKey" : @0.25,
                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                  }];
 
  TestKeyboardInsetDelegate* delegate = [[TestKeyboardInsetDelegate alloc] init];
  delegate.isViewLoaded = YES;
  delegate.mockScreen = screen;
 
  // view() is non-optional in the delegate protocol; provide a real view so the real
  // startKeyBoardAnimation: can add its animation view to the hierarchy.
  delegate.mockView = [[UIView alloc] init];
  delegate.mockConvertedViewRect = viewFrame;
 
  FlutterEnginePartialMock* engine = [[FlutterEnginePartialMock alloc] init];
  delegate.mockEngine = engine;
  engine.viewController = (FlutterViewController*)delegate;
 
  FlutterKeyboardInsetManager* manager =
      [[FlutterKeyboardInsetManager alloc] initWithDelegate:delegate
                                         displayLinkManager:FlutterDisplayLinkManager.shared];
  manager.targetViewInsetBottom = 0;
 
  [manager handleKeyboardNotification:notification];
 
  // Verify the docked keyboard produces an inset.
  XCTAssertTrue(manager.targetViewInsetBottom == 320 * screen.scale);
 
  // Verify handleKeyboardNotification: kicks off the animation, which sets up the vsync client.
  XCTAssertNotNil(manager.keyboardAnimationVSyncClient);
 
  [manager invalidate];
}
 
- (void)testEnsureBottomInsetIsZeroWhenKeyboardDismissed {
  FlutterEnginePartialMock* engine = [[FlutterEnginePartialMock alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
 
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  viewController.keyboardInsetManager.delegate =
      (id<FlutterKeyboardInsetManagerDelegate>)viewControllerMock;
 
  engine.viewController = viewControllerMock;
 
  CGRect keyboardFrame = CGRectZero;
  BOOL isLocal = YES;
  NSNotification* fakeNotification =
      [NSNotification notificationWithName:UIKeyboardWillHideNotification
                                    object:nil
                                  userInfo:@{
                                    @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                    @"UIKeyboardAnimationDurationUserInfoKey" : @(0.25),
                                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                                  }];
 
  viewController.keyboardInsetManager.targetViewInsetBottom = 10;
  [viewController.keyboardInsetManager handleKeyboardNotification:fakeNotification];
  XCTAssertTrue(viewController.keyboardInsetManager.targetViewInsetBottom == 0);
}
 
- (void)testStopKeyBoardAnimationWhenReceivedWillHideNotificationAfterWillShowNotification {
  // see: https://github.com/flutter/flutter/issues/112281
 
  FlutterEnginePartialMock* engine = [[FlutterEnginePartialMock alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  viewController.keyboardInsetManager.delegate =
      (id<FlutterKeyboardInsetManagerDelegate>)viewControllerMock;
 
  engine.viewController = viewControllerMock;
  OCMStub([viewControllerMock isViewLoaded]).andReturn(YES);
  __unused UIView* dummyView2 = [viewControllerMock view];
 
  UIScreen* screen = [self setUpMockScreen];
  OCMStub([screen scale]).andReturn(1.0);
  OCMStub([viewControllerMock flutterScreenIfViewLoaded]).andReturn(screen);
  CGRect viewFrame = screen.bounds;
  [self setUpMockView:viewControllerMock
               screen:screen
            viewFrame:viewFrame
       convertedFrame:viewFrame];
  viewController.keyboardInsetManager.targetViewInsetBottom = 0;
 
  CGFloat screenWidth = screen.bounds.size.width;
  CGFloat screenHeight = screen.bounds.size.height;
  CGRect keyboardFrame = CGRectMake(0, screenHeight - 320, screenWidth, 320);
  BOOL isLocal = YES;
 
  // Receive will show notification
  NSNotification* fakeShowNotification =
      [NSNotification notificationWithName:UIKeyboardWillShowNotification
                                    object:nil
                                  userInfo:@{
                                    UIKeyboardFrameEndUserInfoKey : @(keyboardFrame),
                                    UIKeyboardAnimationDurationUserInfoKey : @0.25,
                                    UIKeyboardIsLocalUserInfoKey : @(isLocal)
                                  }];
  [viewController.keyboardInsetManager handleKeyboardNotification:fakeShowNotification];
  XCTAssertEqual(viewController.keyboardInsetManager.targetViewInsetBottom, 320 * screen.scale);
 
  // Receive will hide notification
  NSNotification* fakeHideNotification =
      [NSNotification notificationWithName:UIKeyboardWillHideNotification
                                    object:nil
                                  userInfo:@{
                                    @"UIKeyboardFrameEndUserInfoKey" : @(keyboardFrame),
                                    @"UIKeyboardAnimationDurationUserInfoKey" : @(0.0),
                                    @"UIKeyboardIsLocalUserInfoKey" : @(isLocal)
                                  }];
  [viewController.keyboardInsetManager handleKeyboardNotification:fakeHideNotification];
  XCTAssertEqual(viewController.keyboardInsetManager.targetViewInsetBottom, 0);
 
  // Check if the keyboard animation is stopped.
  XCTAssertNil([viewController.keyboardInsetManager keyboardAnimationView]);
  XCTAssertNil([viewController.keyboardInsetManager keyboardSpringAnimation]);
}
 
- (void)testEnsureViewportMetricsWillInvokeAndDisplayLinkWillInvalidateInViewDidDisappear {
  FlutterEnginePartialMock* engine = [[FlutterEnginePartialMock alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  id viewControllerMock = OCMPartialMock(viewController);
  viewController.keyboardInsetManager.delegate =
      (id<FlutterKeyboardInsetManagerDelegate>)viewControllerMock;
 
  FakeFlutterKeyboardInsetManager* managerMock = [[FakeFlutterKeyboardInsetManager alloc]
      initWithDelegate:(id<FlutterKeyboardInsetManagerDelegate>)viewControllerMock];
  viewController.keyboardInsetManager = managerMock;
 
  [viewControllerMock viewDidDisappear:YES];
 
  XCTAssertTrue(managerMock.didCallEnsureViewportMetricsIsCorrect);
  XCTAssertTrue(managerMock.didCallInvalidateKeyboardAnimationVSyncClient);
}
 
- (void)testViewDidDisappearDoesntPauseEngineWhenNotTheViewController {
  id lifecycleChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  FlutterEnginePartialMock* mockEngine = [[FlutterEnginePartialMock alloc] init];
  mockEngine.lifecycleChannel = lifecycleChannel;
  FlutterViewController* viewControllerA =
      [[FlutterViewController alloc] initWithEngine:self.mockEngine nibName:nil bundle:nil];
  FlutterViewController* viewControllerB =
      [[FlutterViewController alloc] initWithEngine:self.mockEngine nibName:nil bundle:nil];
  id viewControllerMock = OCMPartialMock(viewControllerA);
  OCMStub([viewControllerMock surfaceUpdated:NO]);
  mockEngine.viewController = viewControllerB;
  [viewControllerA viewDidDisappear:NO];
  OCMReject([lifecycleChannel sendMessage:@"AppLifecycleState.paused"]);
  OCMReject([viewControllerMock surfaceUpdated:[OCMArg any]]);
}
 
- (void)testAppWillTerminateViewDidDestroyTheEngine {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  id viewControllerMock = OCMPartialMock(viewController);
  OCMStub([viewControllerMock goToApplicationLifecycle:@"AppLifecycleState.detached"]);
  OCMStub([mockEngine destroyContext]);
  [viewController applicationWillTerminate:nil];
  OCMVerify([viewControllerMock goToApplicationLifecycle:@"AppLifecycleState.detached"]);
  OCMVerify([mockEngine destroyContext]);
}
 
- (void)testViewDidDisappearDoesPauseEngineWhenIsTheViewController {
  id lifecycleChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  FlutterEnginePartialMock* mockEngine = [[FlutterEnginePartialMock alloc] init];
  mockEngine.lifecycleChannel = lifecycleChannel;
  __weak FlutterViewController* weakViewController;
  @autoreleasepool {
    FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                  nibName:nil
                                                                                   bundle:nil];
    weakViewController = viewController;
    id viewControllerMock = OCMPartialMock(viewController);
    OCMStub([viewControllerMock surfaceUpdated:NO]);
    [viewController viewDidDisappear:NO];
    OCMVerify([lifecycleChannel sendMessage:@"AppLifecycleState.paused"]);
    OCMVerify([viewControllerMock surfaceUpdated:NO]);
  }
  XCTAssertNil(weakViewController);
}
 
- (void)
    testEngineConfigSyncMethodWillExecuteWhenViewControllerInEngineIsCurrentViewControllerInViewWillAppear {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController viewWillAppear:YES];
  OCMVerify([viewController onUserSettingsChanged:nil]);
}
 
- (void)
    testEngineConfigSyncMethodWillNotExecuteWhenViewControllerInEngineIsNotCurrentViewControllerInViewWillAppear {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewControllerA = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                 nibName:nil
                                                                                  bundle:nil];
  mockEngine.viewController = nil;
  FlutterViewController* viewControllerB = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                 nibName:nil
                                                                                  bundle:nil];
  mockEngine.viewController = nil;
  mockEngine.viewController = viewControllerB;
  [viewControllerA viewWillAppear:YES];
  OCMVerify(never(), [viewControllerA onUserSettingsChanged:nil]);
}
 
- (void)
    testEngineConfigSyncMethodWillExecuteWhenViewControllerInEngineIsCurrentViewControllerInViewDidAppear {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController viewDidAppear:YES];
  OCMVerify([viewController onUserSettingsChanged:nil]);
}
 
- (void)
    testEngineConfigSyncMethodWillNotExecuteWhenViewControllerInEngineIsNotCurrentViewControllerInViewDidAppear {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewControllerA = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                 nibName:nil
                                                                                  bundle:nil];
  mockEngine.viewController = nil;
  FlutterViewController* viewControllerB = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                 nibName:nil
                                                                                  bundle:nil];
  mockEngine.viewController = nil;
  mockEngine.viewController = viewControllerB;
  [viewControllerA viewDidAppear:YES];
  OCMVerify(never(), [viewControllerA onUserSettingsChanged:nil]);
}
 
- (void)
    testEngineConfigSyncMethodWillExecuteWhenViewControllerInEngineIsCurrentViewControllerInViewWillDisappear {
  id lifecycleChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  FlutterEnginePartialMock* mockEngine = [[FlutterEnginePartialMock alloc] init];
  mockEngine.lifecycleChannel = lifecycleChannel;
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  mockEngine.viewController = viewController;
  [viewController viewWillDisappear:NO];
  OCMVerify([lifecycleChannel sendMessage:@"AppLifecycleState.inactive"]);
}
 
- (void)
    testEngineConfigSyncMethodWillNotExecuteWhenViewControllerInEngineIsNotCurrentViewControllerInViewWillDisappear {
  id lifecycleChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  FlutterEnginePartialMock* mockEngine = [[FlutterEnginePartialMock alloc] init];
  mockEngine.lifecycleChannel = lifecycleChannel;
  FlutterViewController* viewControllerA = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                 nibName:nil
                                                                                  bundle:nil];
  FlutterViewController* viewControllerB = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                 nibName:nil
                                                                                  bundle:nil];
  mockEngine.viewController = viewControllerB;
  [viewControllerA viewDidDisappear:NO];
  OCMReject([lifecycleChannel sendMessage:@"AppLifecycleState.inactive"]);
}
 
- (void)testUpdateViewportMetricsIfNeeded_DoesntInvokeEngineWhenNotTheViewController {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewControllerA = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                 nibName:nil
                                                                                  bundle:nil];
  mockEngine.viewController = nil;
  FlutterViewController* viewControllerB = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                 nibName:nil
                                                                                  bundle:nil];
  mockEngine.viewController = viewControllerB;
  [viewControllerA updateViewportMetricsIfNeeded];
  flutter::ViewportMetrics viewportMetrics;
  OCMVerify(never(), [mockEngine updateViewportMetrics:viewportMetrics]);
}
 
- (void)testUpdateViewportMetricsIfNeeded_DoesInvokeEngineWhenIsTheViewController {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  mockEngine.viewController = viewController;
  flutter::ViewportMetrics viewportMetrics;
  OCMExpect([mockEngine updateViewportMetrics:viewportMetrics]).ignoringNonObjectArgs();
  [viewController updateViewportMetricsIfNeeded];
  OCMVerifyAll(mockEngine);
}
 
- (void)testUpdatedViewportMetricsDoesResizeFlutterViewWhenAutoResizable {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
 
  FlutterViewController* realVC = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                        nibName:nil
                                                                         bundle:nil];
  id mockVC = OCMPartialMock(realVC);
  mockEngine.viewController = mockVC;
 
  OCMExpect([mockVC updateAutoResizeConstraints]);
 
  [mockVC setAutoResizable:YES];
 
  [mockVC viewDidLayoutSubviews];
 
  OCMVerifyAll(mockVC);
}
 
- (void)testUpdatedViewportMetricsDoesNotResizeFlutterViewWhenNotAutoResizable {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
 
  FlutterViewController* realVC = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                        nibName:nil
                                                                         bundle:nil];
  id mockVC = OCMPartialMock(realVC);
  mockEngine.viewController = mockVC;
 
  OCMReject([mockVC updateAutoResizeConstraints]);
 
  [mockVC setAutoResizable:NO];
 
  [mockVC viewDidLayoutSubviews];
 
  OCMVerifyAll(mockVC);
}
 
- (void)testUpdateViewportMetricsIfNeeded_DoesNotInvokeEngineWhenShouldBeIgnoredDuringRotation {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  UIScreen* screen = [self setUpMockScreen];
  OCMStub([viewControllerMock flutterScreenIfViewLoaded]).andReturn(screen);
  mockEngine.viewController = viewController;
 
  id mockCoordinator = OCMProtocolMock(@protocol(UIViewControllerTransitionCoordinator));
  OCMStub([mockCoordinator transitionDuration]).andReturn(0.5);
 
  // Mimic the device rotation.
  [viewController viewWillTransitionToSize:CGSizeZero withTransitionCoordinator:mockCoordinator];
  // Should not trigger the engine call when during rotation.
  [viewController updateViewportMetricsIfNeeded];
 
  OCMVerify(never(), [mockEngine updateViewportMetrics:flutter::ViewportMetrics()]);
}
 
- (void)testViewWillTransitionToSize_DoesDelayEngineCallIfNonZeroDuration {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  UIScreen* screen = [self setUpMockScreen];
  OCMStub([viewControllerMock flutterScreenIfViewLoaded]).andReturn(screen);
  mockEngine.viewController = viewController;
 
  // Mimic the device rotation with non-zero transition duration.
  NSTimeInterval transitionDuration = 0.5;
  id mockCoordinator = OCMProtocolMock(@protocol(UIViewControllerTransitionCoordinator));
  OCMStub([mockCoordinator transitionDuration]).andReturn(transitionDuration);
 
  flutter::ViewportMetrics viewportMetrics;
  OCMExpect([mockEngine updateViewportMetrics:viewportMetrics]).ignoringNonObjectArgs();
 
  [viewController viewWillTransitionToSize:CGSizeZero withTransitionCoordinator:mockCoordinator];
  // Should not immediately call the engine (this request should be ignored).
  [viewController updateViewportMetricsIfNeeded];
  OCMVerify(never(), [mockEngine updateViewportMetrics:flutter::ViewportMetrics()]);
 
  // Should delay the engine call for half of the transition duration.
  // Wait for additional transitionDuration to allow updateViewportMetrics calls if any.
  XCTWaiterResult result = [XCTWaiter
      waitForExpectations:@[ [self expectationWithDescription:@"Waiting for rotation duration"] ]
                  timeout:transitionDuration];
  XCTAssertEqual(result, XCTWaiterResultTimedOut);
 
  OCMVerifyAll(mockEngine);
}
 
- (void)testViewWillTransitionToSize_DoesNotDelayEngineCallIfZeroDuration {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  UIScreen* screen = [self setUpMockScreen];
  OCMStub([viewControllerMock flutterScreenIfViewLoaded]).andReturn(screen);
  mockEngine.viewController = viewController;
 
  // Mimic the device rotation with zero transition duration.
  id mockCoordinator = OCMProtocolMock(@protocol(UIViewControllerTransitionCoordinator));
  OCMStub([mockCoordinator transitionDuration]).andReturn(0);
 
  flutter::ViewportMetrics viewportMetrics;
  OCMExpect([mockEngine updateViewportMetrics:viewportMetrics]).ignoringNonObjectArgs();
 
  // Should immediately trigger the engine call, without delay.
  [viewController viewWillTransitionToSize:CGSizeZero withTransitionCoordinator:mockCoordinator];
  [viewController updateViewportMetricsIfNeeded];
 
  OCMVerifyAll(mockEngine);
}
 
- (void)testViewDidLoadDoesntInvokeEngineWhenNotTheViewController {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewControllerA = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                 nibName:nil
                                                                                  bundle:nil];
  mockEngine.viewController = nil;
  FlutterViewController* viewControllerB = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                 nibName:nil
                                                                                  bundle:nil];
  mockEngine.viewController = viewControllerB;
  UIView* view = viewControllerA.view;
  XCTAssertNotNil(view);
  OCMVerify(never(), [mockEngine attachView]);
}
 
- (void)testViewDidLoadDoesInvokeEngineWhenIsTheViewController {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  mockEngine.viewController = nil;
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  mockEngine.viewController = viewController;
  UIView* view = viewController.view;
  XCTAssertNotNil(view);
  OCMVerify(times(1), [mockEngine attachView]);
}
 
- (void)testViewDidLoadDoesntInvokeEngineAttachViewWhenEngineNeedsLaunch {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  mockEngine.viewController = nil;
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  // sharedSetupWithProject sets the engine needs to be launched.
  [viewController sharedSetupWithProject:nil initialRoute:nil];
  mockEngine.viewController = viewController;
  UIView* view = viewController.view;
  XCTAssertNotNil(view);
  OCMVerify(never(), [mockEngine attachView]);
}
 
- (void)testSplashScreenViewRemoveNotCrash {
  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"engine" project:nil];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  [flutterViewController setSplashScreenView:[[UIView alloc] init]];
  [flutterViewController setSplashScreenView:nil];
}
 
- (void)testInternalPluginsWeakPtrNotCrash {
  FlutterSendKeyEvent sendEvent;
  @autoreleasepool {
    FlutterViewController* vc = [[FlutterViewController alloc] initWithProject:nil
                                                                       nibName:nil
                                                                        bundle:nil];
    [vc addInternalPlugins];
    FlutterKeyboardManager* keyboardManager = vc.keyboardManager;
    FlutterEmbedderKeyResponder* keyPrimaryResponder = (FlutterEmbedderKeyResponder*)
        [(NSArray<id<FlutterKeyPrimaryResponder>>*)keyboardManager.primaryResponders firstObject];
    sendEvent = [keyPrimaryResponder sendEvent];
  }
 
  if (sendEvent) {
    sendEvent({}, nil, nil);
  }
}
 
// Regression test for https://github.com/flutter/engine/pull/32098.
- (void)testInternalPluginsInvokeInViewDidLoad {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  UIView* view = viewController.view;
  // The implementation in viewDidLoad requires the viewControllers.viewLoaded is true.
  // Accessing the view to make sure the view loads in the memory,
  // which makes viewControllers.viewLoaded true.
  XCTAssertNotNil(view);
  [viewController viewDidLoad];
  OCMVerify([viewController addInternalPlugins]);
}
 
- (void)testBinaryMessenger {
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
  XCTAssertNotNil(vc);
  id messenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
  OCMStub([self.mockEngine binaryMessenger]).andReturn(messenger);
  XCTAssertEqual(vc.binaryMessenger, messenger);
  OCMVerify([self.mockEngine binaryMessenger]);
}
 
- (void)testViewControllerIsReleased {
  __weak FlutterViewController* weakViewController;
  __weak UIView* weakView;
  @autoreleasepool {
    FlutterEngine* engine = [[FlutterEngine alloc] init];
 
    [engine runWithEntrypoint:nil];
    FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                  nibName:nil
                                                                                   bundle:nil];
    weakViewController = viewController;
    [viewController loadView];
    [viewController viewDidLoad];
    weakView = viewController.view;
    XCTAssertTrue([viewController.view isKindOfClass:[FlutterView class]]);
  }
  XCTAssertNil(weakViewController);
  XCTAssertNil(weakView);
}
 
#pragma mark - Platform Brightness
 
- (void)testItReportsLightPlatformBrightnessByDefault {
  // Setup test.
  id settingsChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  OCMStub([self.mockEngine settingsChannel]).andReturn(settingsChannel);
 
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
 
  // Exercise behavior under test.
  [vc traitCollectionDidChange:nil];
 
  // Verify behavior.
  OCMVerify([settingsChannel sendMessage:[OCMArg checkWithBlock:^BOOL(id message) {
                               return [message[@"platformBrightness"] isEqualToString:@"light"];
                             }]]);
 
  // Clean up mocks
  [settingsChannel stopMocking];
}
 
- (void)testItReportsPlatformBrightnessWhenViewWillAppear {
  // Setup test.
  id settingsChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  OCMStub([mockEngine settingsChannel]).andReturn(settingsChannel);
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
 
  // Exercise behavior under test.
  [vc viewWillAppear:false];
 
  // Verify behavior.
  OCMVerify([settingsChannel sendMessage:[OCMArg checkWithBlock:^BOOL(id message) {
                               return [message[@"platformBrightness"] isEqualToString:@"light"];
                             }]]);
 
  // Clean up mocks
  [settingsChannel stopMocking];
}
 
- (void)testItReportsDarkPlatformBrightnessWhenTraitCollectionRequestsIt {
  // Setup test.
  id settingsChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  OCMStub([self.mockEngine settingsChannel]).andReturn(settingsChannel);
  id mockTraitCollection =
      [self fakeTraitCollectionWithUserInterfaceStyle:UIUserInterfaceStyleDark];
 
  // We partially mock the real FlutterViewController to act as the OS and report
  // the UITraitCollection of our choice. Mocking the object under test is not
  // desirable, but given that the OS does not offer a DI approach to providing
  // our own UITraitCollection, this seems to be the least bad option.
  id partialMockVC = OCMPartialMock([[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                          nibName:nil
                                                                           bundle:nil]);
  OCMStub([partialMockVC traitCollection]).andReturn(mockTraitCollection);
 
  // Exercise behavior under test.
  [partialMockVC traitCollectionDidChange:nil];
 
  // Verify behavior.
  OCMVerify([settingsChannel sendMessage:[OCMArg checkWithBlock:^BOOL(id message) {
                               return [message[@"platformBrightness"] isEqualToString:@"dark"];
                             }]]);
 
  // Clean up mocks
  [partialMockVC stopMocking];
  [settingsChannel stopMocking];
  [mockTraitCollection stopMocking];
}
 
// Creates a mocked UITraitCollection with nil values for everything except userInterfaceStyle,
// which is set to the given "style".
- (UITraitCollection*)fakeTraitCollectionWithUserInterfaceStyle:(UIUserInterfaceStyle)style {
  id mockTraitCollection = OCMClassMock([UITraitCollection class]);
  OCMStub([mockTraitCollection userInterfaceStyle]).andReturn(style);
  return mockTraitCollection;
}
 
- (void)testTraitCollectionDidChangeCallsResetIntrinsicContentSizeWhenAutoResizable {
  // Setup test.
  id mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
 
  FlutterViewController* realVC = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                        nibName:nil
                                                                         bundle:nil];
  id partialMockVC = OCMPartialMock(realVC);
 
  id mockFlutterView = OCMClassMock([FlutterView class]);
  OCMStub([partialMockVC flutterView]).andReturn(mockFlutterView);
 
  // Ensure isAutoResizable is YES
  OCMStub([partialMockVC isAutoResizable]).andReturn(YES);
 
  // Expect resetIntrinsicContentSize to be called on mockFlutterView
  OCMExpect([mockFlutterView resetIntrinsicContentSize]);
 
  // Exercise behavior under test.
  [partialMockVC traitCollectionDidChange:nil];
 
  // Verify behavior.
  OCMVerifyAll(mockFlutterView);
 
  // Clean up mocks
  [partialMockVC stopMocking];
  [mockFlutterView stopMocking];
}
 
#pragma mark - Platform Contrast
 
- (void)testItReportsNormalPlatformContrastByDefault {
  // Setup test.
  id settingsChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  OCMStub([self.mockEngine settingsChannel]).andReturn(settingsChannel);
 
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
 
  // Exercise behavior under test.
  [vc traitCollectionDidChange:nil];
 
  // Verify behavior.
  OCMVerify([settingsChannel sendMessage:[OCMArg checkWithBlock:^BOOL(id message) {
                               return [message[@"platformContrast"] isEqualToString:@"normal"];
                             }]]);
 
  // Clean up mocks
  [settingsChannel stopMocking];
}
 
- (void)testItReportsPlatformContrastWhenViewWillAppear {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
 
  // Setup test.
  id settingsChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  OCMStub([mockEngine settingsChannel]).andReturn(settingsChannel);
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
 
  // Exercise behavior under test.
  [vc viewWillAppear:false];
 
  // Verify behavior.
  OCMVerify([settingsChannel sendMessage:[OCMArg checkWithBlock:^BOOL(id message) {
                               return [message[@"platformContrast"] isEqualToString:@"normal"];
                             }]]);
 
  // Clean up mocks
  [settingsChannel stopMocking];
}
 
- (void)testItReportsHighContrastWhenTraitCollectionRequestsIt {
  // Setup test.
  id settingsChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  OCMStub([self.mockEngine settingsChannel]).andReturn(settingsChannel);
 
  id mockTraitCollection = [self fakeTraitCollectionWithContrast:UIAccessibilityContrastHigh];
 
  // We partially mock the real FlutterViewController to act as the OS and report
  // the UITraitCollection of our choice. Mocking the object under test is not
  // desirable, but given that the OS does not offer a DI approach to providing
  // our own UITraitCollection, this seems to be the least bad option.
  id partialMockVC = OCMPartialMock([[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                          nibName:nil
                                                                           bundle:nil]);
  OCMStub([partialMockVC traitCollection]).andReturn(mockTraitCollection);
 
  // Exercise behavior under test.
  [partialMockVC traitCollectionDidChange:mockTraitCollection];
 
  // Verify behavior.
  OCMVerify([settingsChannel sendMessage:[OCMArg checkWithBlock:^BOOL(id message) {
                               return [message[@"platformContrast"] isEqualToString:@"high"];
                             }]]);
 
  // Clean up mocks
  [partialMockVC stopMocking];
  [settingsChannel stopMocking];
  [mockTraitCollection stopMocking];
}
 
- (void)testItReportsAlwaysUsed24HourFormat {
  // Setup test.
  id settingsChannel = OCMStrictClassMock([FlutterBasicMessageChannel class]);
  OCMStub([self.mockEngine settingsChannel]).andReturn(settingsChannel);
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
  // Test the YES case.
  id mockHourFormat = OCMClassMock([FlutterHourFormat class]);
  OCMStub([mockHourFormat isAlwaysUse24HourFormat]).andReturn(YES);
  OCMExpect([settingsChannel sendMessage:[OCMArg checkWithBlock:^BOOL(id message) {
                               return [message[@"alwaysUse24HourFormat"] isEqual:@(YES)];
                             }]]);
  [vc onUserSettingsChanged:nil];
  [mockHourFormat stopMocking];
 
  // Test the NO case.
  mockHourFormat = OCMClassMock([FlutterHourFormat class]);
  OCMStub([mockHourFormat isAlwaysUse24HourFormat]).andReturn(NO);
  OCMExpect([settingsChannel sendMessage:[OCMArg checkWithBlock:^BOOL(id message) {
                               return [message[@"alwaysUse24HourFormat"] isEqual:@(NO)];
                             }]]);
  [vc onUserSettingsChanged:nil];
  [mockHourFormat stopMocking];
 
  // Clean up mocks.
  [settingsChannel stopMocking];
}
 
- (void)testOnAccessibilityStatusChangedCallsEnableSemanticsWithFlags {
  FlutterViewController* viewController =
      [[FlutterViewController alloc] initWithEngine:self.mockEngine nibName:nil bundle:nil];
  id mockAccessibilityFeatures = OCMClassMock([FlutterAccessibilityFeatures class]);
  OCMStub([mockAccessibilityFeatures flags]).andReturn(333);
  id mockViewController = OCMPartialMock(viewController);
  OCMStub([mockViewController accessibilityFeatures]).andReturn(mockAccessibilityFeatures);
 
  [mockViewController onAccessibilityStatusChanged:nil];
  OCMVerify([self.mockEngine enableSemantics:[OCMArg any] withFlags:333]);
}
 
- (void)testHandleAccessibilityNotifications {
  FlutterViewController* viewController =
      [[FlutterViewController alloc] initWithEngine:self.mockEngine nibName:nil bundle:nil];
  id mockViewController = OCMPartialMock(viewController);
  __block NSUInteger callsCount = 0;
  OCMStub([mockViewController onAccessibilityStatusChanged:[OCMArg isNotNil]])
      .andDo(^(NSInvocation* invocation) {
        callsCount++;
      });
 
  FlutterAccessibilityFeatures* accessibilityFeatures = [[FlutterAccessibilityFeatures alloc] init];
  NSArray<NSString*>* accessibilityNotification = [accessibilityFeatures observedNotificationNames];
 
  for (NSUInteger i = 0; i < [accessibilityNotification count]; i++) {
    NSString* notificationName = [accessibilityNotification objectAtIndex:i];
    [[NSNotificationCenter defaultCenter] postNotificationName:notificationName object:nil];
    XCTAssertEqual(callsCount, i + 1);
  }
}
 
- (void)testAccessibilityPerformEscapePopsRoute {
  FlutterEngine* mockEngine = OCMPartialMock([[FlutterEngine alloc] init]);
  [mockEngine createShell:@"" libraryURI:@"" initialRoute:nil];
  id mockNavigationChannel = OCMClassMock([FlutterMethodChannel class]);
  OCMStub([mockEngine navigationChannel]).andReturn(mockNavigationChannel);
 
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  XCTAssertTrue([viewController accessibilityPerformEscape]);
 
  OCMVerify([mockNavigationChannel invokeMethod:@"popRoute" arguments:nil]);
 
  [mockNavigationChannel stopMocking];
}
 
- (void)testPerformOrientationUpdateForcesOrientationChange {
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskPortrait
                          currentOrientation:UIInterfaceOrientationLandscapeLeft
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationPortrait];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskPortrait
                          currentOrientation:UIInterfaceOrientationLandscapeRight
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationPortrait];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskPortrait
                          currentOrientation:UIInterfaceOrientationPortraitUpsideDown
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationPortrait];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskPortraitUpsideDown
                          currentOrientation:UIInterfaceOrientationLandscapeLeft
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationPortraitUpsideDown];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskPortraitUpsideDown
                          currentOrientation:UIInterfaceOrientationLandscapeRight
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationPortraitUpsideDown];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskPortraitUpsideDown
                          currentOrientation:UIInterfaceOrientationPortrait
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationPortraitUpsideDown];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscape
                          currentOrientation:UIInterfaceOrientationPortrait
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationLandscapeLeft];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscape
                          currentOrientation:UIInterfaceOrientationPortraitUpsideDown
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationLandscapeLeft];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscapeLeft
                          currentOrientation:UIInterfaceOrientationPortrait
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationLandscapeLeft];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscapeLeft
                          currentOrientation:UIInterfaceOrientationLandscapeRight
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationLandscapeLeft];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscapeLeft
                          currentOrientation:UIInterfaceOrientationPortraitUpsideDown
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationLandscapeLeft];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscapeRight
                          currentOrientation:UIInterfaceOrientationPortrait
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationLandscapeRight];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscapeRight
                          currentOrientation:UIInterfaceOrientationLandscapeLeft
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationLandscapeRight];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscapeRight
                          currentOrientation:UIInterfaceOrientationPortraitUpsideDown
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationLandscapeRight];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskAllButUpsideDown
                          currentOrientation:UIInterfaceOrientationPortraitUpsideDown
                        didChangeOrientation:YES
                        resultingOrientation:UIInterfaceOrientationPortrait];
}
 
- (void)testPerformOrientationUpdateDoesNotForceOrientationChange {
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskAll
                          currentOrientation:UIInterfaceOrientationPortrait
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskAll
                          currentOrientation:UIInterfaceOrientationPortraitUpsideDown
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskAll
                          currentOrientation:UIInterfaceOrientationLandscapeLeft
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskAll
                          currentOrientation:UIInterfaceOrientationLandscapeRight
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskAllButUpsideDown
                          currentOrientation:UIInterfaceOrientationPortrait
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskAllButUpsideDown
                          currentOrientation:UIInterfaceOrientationLandscapeLeft
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskAllButUpsideDown
                          currentOrientation:UIInterfaceOrientationLandscapeRight
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskPortrait
                          currentOrientation:UIInterfaceOrientationPortrait
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskPortraitUpsideDown
                          currentOrientation:UIInterfaceOrientationPortraitUpsideDown
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscape
                          currentOrientation:UIInterfaceOrientationLandscapeLeft
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscape
                          currentOrientation:UIInterfaceOrientationLandscapeRight
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscapeLeft
                          currentOrientation:UIInterfaceOrientationLandscapeLeft
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
 
  [self orientationTestWithOrientationUpdate:UIInterfaceOrientationMaskLandscapeRight
                          currentOrientation:UIInterfaceOrientationLandscapeRight
                        didChangeOrientation:NO
                        resultingOrientation:static_cast<UIInterfaceOrientation>(0)];
}
 
// Perform an orientation update test that fails when the expected outcome
// for an orientation update is not met
- (void)orientationTestWithOrientationUpdate:(UIInterfaceOrientationMask)mask
                          currentOrientation:(UIInterfaceOrientation)currentOrientation
                        didChangeOrientation:(BOOL)didChange
                        resultingOrientation:(UIInterfaceOrientation)resultingOrientation {
  id mockApplication = OCMClassMock([UIApplication class]);
  id mockWindowScene;
  id deviceMock;
  id mockVC;
  __block __weak id weakPreferences;
  @autoreleasepool {
    FlutterViewController* realVC = [[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                          nibName:nil
                                                                           bundle:nil];
 
    if (@available(iOS 16.0, *)) {
      mockWindowScene = OCMClassMock([UIWindowScene class]);
      mockVC = OCMPartialMock(realVC);
      OCMStub([mockVC flutterWindowSceneIfViewLoaded]).andReturn(mockWindowScene);
      if (realVC.supportedInterfaceOrientations == mask) {
        OCMReject([mockWindowScene requestGeometryUpdateWithPreferences:[OCMArg any]
                                                           errorHandler:[OCMArg any]]);
      } else {
        // iOS 16 will decide whether to rotate based on the new preference, so always set it
        // when it changes.
        OCMExpect([mockWindowScene
            requestGeometryUpdateWithPreferences:[OCMArg checkWithBlock:^BOOL(
                                                             UIWindowSceneGeometryPreferencesIOS*
                                                                 preferences) {
              weakPreferences = preferences;
              return preferences.interfaceOrientations == mask;
            }]
                                    errorHandler:[OCMArg any]]);
      }
      OCMStub([mockApplication sharedApplication]).andReturn(mockApplication);
      OCMStub([mockApplication connectedScenes]).andReturn([NSSet setWithObject:mockWindowScene]);
    } else {
      deviceMock = OCMPartialMock([UIDevice currentDevice]);
      if (!didChange) {
        OCMReject([deviceMock setValue:[OCMArg any] forKey:@"orientation"]);
      } else {
        OCMExpect([deviceMock setValue:@(resultingOrientation) forKey:@"orientation"]);
      }
      mockWindowScene = OCMClassMock([UIWindowScene class]);
      mockVC = OCMPartialMock(realVC);
      OCMStub([mockVC flutterWindowSceneIfViewLoaded]).andReturn(mockWindowScene);
      OCMStub(((UIWindowScene*)mockWindowScene).interfaceOrientation).andReturn(currentOrientation);
    }
 
    [realVC performOrientationUpdate:mask];
    if (@available(iOS 16.0, *)) {
      OCMVerifyAll(mockWindowScene);
    } else {
      OCMVerifyAll(deviceMock);
    }
  }
  [mockWindowScene stopMocking];
  [deviceMock stopMocking];
  [mockApplication stopMocking];
  XCTAssertNil(weakPreferences);
}
 
// Creates a mocked UITraitCollection with nil values for everything except accessibilityContrast,
// which is set to the given "contrast".
- (UITraitCollection*)fakeTraitCollectionWithContrast:(UIAccessibilityContrast)contrast {
  id mockTraitCollection = OCMClassMock([UITraitCollection class]);
  OCMStub([mockTraitCollection accessibilityContrast]).andReturn(contrast);
  return mockTraitCollection;
}
 
- (void)testWillDeallocNotification {
  XCTestExpectation* expectation =
      [[XCTestExpectation alloc] initWithDescription:@"notification called"];
  id engine = [[MockEngine alloc] init];
  @autoreleasepool {
    // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
    FlutterViewController* realVC = [[FlutterViewController alloc] initWithEngine:engine
                                                                          nibName:nil
                                                                           bundle:nil];
    [NSNotificationCenter.defaultCenter addObserverForName:FlutterViewControllerWillDealloc
                                                    object:nil
                                                     queue:[NSOperationQueue mainQueue]
                                                usingBlock:^(NSNotification* _Nonnull note) {
                                                  [expectation fulfill];
                                                }];
    XCTAssertNotNil(realVC);
    realVC = nil;
  }
  [self waitForExpectations:@[ expectation ] timeout:1.0];
}
 
- (void)testReleasesKeyboardManagerOnDealloc {
  __weak FlutterKeyboardManager* weakKeyboardManager = nil;
  @autoreleasepool {
    FlutterViewController* viewController = [[FlutterViewController alloc] init];
 
    [viewController addInternalPlugins];
    weakKeyboardManager = viewController.keyboardManager;
    XCTAssertNotNil(weakKeyboardManager);
    [viewController deregisterNotifications];
    viewController = nil;
  }
  // View controller has released the keyboard manager.
  XCTAssertNil(weakKeyboardManager);
}
 
- (void)testDoesntLoadViewInInit {
  FlutterDartProject* project = [[FlutterDartProject alloc] init];
  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"foobar" project:project];
  [engine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* realVC = [[FlutterViewController alloc] initWithEngine:engine
                                                                        nibName:nil
                                                                         bundle:nil];
  XCTAssertFalse([realVC isViewLoaded], @"shouldn't have loaded since it hasn't been shown");
  engine.viewController = nil;
}
 
- (void)testHideOverlay {
  FlutterDartProject* project = [[FlutterDartProject alloc] init];
  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"foobar" project:project];
  [engine createShell:@"" libraryURI:@"" initialRoute:nil];
  FlutterViewController* realVC = [[FlutterViewController alloc] initWithEngine:engine
                                                                        nibName:nil
                                                                         bundle:nil];
  XCTAssertFalse(realVC.prefersHomeIndicatorAutoHidden, @"");
  [NSNotificationCenter.defaultCenter postNotificationName:FlutterViewControllerHideHomeIndicator
                                                    object:nil];
  XCTAssertTrue(realVC.prefersHomeIndicatorAutoHidden, @"");
  engine.viewController = nil;
}
 
- (void)testNotifyLowMemory {
  FlutterEnginePartialMock* mockEngine = [[FlutterEnginePartialMock alloc] init];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  id viewControllerMock = OCMPartialMock(viewController);
  OCMStub([viewControllerMock surfaceUpdated:NO]);
  [viewController beginAppearanceTransition:NO animated:NO];
  [viewController endAppearanceTransition];
  XCTAssertTrue(mockEngine.didCallNotifyLowMemory);
}
 
- (void)sendMessage:(id _Nullable)message reply:(FlutterReply _Nullable)callback {
  NSMutableDictionary* replyMessage = [@{
    @"handled" : @YES,
  } mutableCopy];
  // Response is async, so we have to post it to the run loop instead of calling
  // it directly.
  self.messageSent = message;
  CFRunLoopPerformBlock(CFRunLoopGetCurrent(), fml::MessageLoopDarwin::kMessageLoopCFRunLoopMode,
                        ^() {
                          callback(replyMessage);
                        });
}
 
- (void)testValidKeyUpEvent API_AVAILABLE(ios(13.4)) {
  if (@available(iOS 13.4, *)) {
    // noop
  } else {
    return;
  }
  FlutterEnginePartialMock* mockEngine = [[FlutterEnginePartialMock alloc] init];
  mockEngine.keyEventChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  OCMStub([mockEngine.keyEventChannel sendMessage:[OCMArg any] reply:[OCMArg any]])
      .andCall(self, @selector(sendMessage:reply:));
  OCMStub([self.mockTextInputPlugin handlePress:[OCMArg any]]).andReturn(YES);
  mockEngine.textInputPlugin = self.mockTextInputPlugin;
 
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
 
  // Allocate the keyboard manager in the view controller by adding the internal
  // plugins.
  [vc addInternalPlugins];
 
  [vc handlePressEvent:keyUpEvent(UIKeyboardHIDUsageKeyboardA, UIKeyModifierShift, 123.0)
            nextAction:^(){
            }];
 
  XCTAssert(self.messageSent != nil);
  XCTAssert([self.messageSent[@"keymap"] isEqualToString:@"ios"]);
  XCTAssert([self.messageSent[@"type"] isEqualToString:@"keyup"]);
  XCTAssert([self.messageSent[@"keyCode"] isEqualToNumber:[NSNumber numberWithInt:4]]);
  XCTAssert([self.messageSent[@"modifiers"] isEqualToNumber:[NSNumber numberWithInt:0]]);
  XCTAssert([self.messageSent[@"characters"] isEqualToString:@""]);
  XCTAssert([self.messageSent[@"charactersIgnoringModifiers"] isEqualToString:@""]);
  [vc deregisterNotifications];
}
 
- (void)testValidKeyDownEvent API_AVAILABLE(ios(13.4)) {
  if (@available(iOS 13.4, *)) {
    // noop
  } else {
    return;
  }
 
  FlutterEnginePartialMock* mockEngine = [[FlutterEnginePartialMock alloc] init];
  mockEngine.keyEventChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  OCMStub([mockEngine.keyEventChannel sendMessage:[OCMArg any] reply:[OCMArg any]])
      .andCall(self, @selector(sendMessage:reply:));
  OCMStub([self.mockTextInputPlugin handlePress:[OCMArg any]]).andReturn(YES);
  mockEngine.textInputPlugin = self.mockTextInputPlugin;
 
  __strong FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                             nibName:nil
                                                                              bundle:nil];
  // Allocate the keyboard manager in the view controller by adding the internal
  // plugins.
  [vc addInternalPlugins];
 
  [vc handlePressEvent:keyDownEvent(UIKeyboardHIDUsageKeyboardA, UIKeyModifierShift, 123.0f, "A",
                                    "a")
            nextAction:^(){
            }];
 
  XCTAssert(self.messageSent != nil);
  XCTAssert([self.messageSent[@"keymap"] isEqualToString:@"ios"]);
  XCTAssert([self.messageSent[@"type"] isEqualToString:@"keydown"]);
  XCTAssert([self.messageSent[@"keyCode"] isEqualToNumber:[NSNumber numberWithInt:4]]);
  XCTAssert([self.messageSent[@"modifiers"] isEqualToNumber:[NSNumber numberWithInt:0]]);
  XCTAssert([self.messageSent[@"characters"] isEqualToString:@"A"]);
  XCTAssert([self.messageSent[@"charactersIgnoringModifiers"] isEqualToString:@"a"]);
  [vc deregisterNotifications];
  vc = nil;
}
 
- (void)testIgnoredKeyEvents API_AVAILABLE(ios(13.4)) {
  if (@available(iOS 13.4, *)) {
    // noop
  } else {
    return;
  }
  id keyEventChannel = OCMClassMock([FlutterBasicMessageChannel class]);
  OCMStub([keyEventChannel sendMessage:[OCMArg any] reply:[OCMArg any]])
      .andCall(self, @selector(sendMessage:reply:));
  OCMStub([self.mockTextInputPlugin handlePress:[OCMArg any]]).andReturn(YES);
  OCMStub([self.mockEngine keyEventChannel]).andReturn(keyEventChannel);
 
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
 
  // Allocate the keyboard manager in the view controller by adding the internal
  // plugins.
  [vc addInternalPlugins];
 
  [vc handlePressEvent:keyEventWithPhase(UIPressPhaseStationary, UIKeyboardHIDUsageKeyboardA,
                                         UIKeyModifierShift, 123.0)
            nextAction:^(){
            }];
  [vc handlePressEvent:keyEventWithPhase(UIPressPhaseCancelled, UIKeyboardHIDUsageKeyboardA,
                                         UIKeyModifierShift, 123.0)
            nextAction:^(){
            }];
  [vc handlePressEvent:keyEventWithPhase(UIPressPhaseChanged, UIKeyboardHIDUsageKeyboardA,
                                         UIKeyModifierShift, 123.0)
            nextAction:^(){
            }];
 
  XCTAssert(self.messageSent == nil);
  OCMVerify(never(), [keyEventChannel sendMessage:[OCMArg any]]);
  [vc deregisterNotifications];
}
 
- (void)testPanGestureRecognizer API_AVAILABLE(ios(13.4)) {
  if (@available(iOS 13.4, *)) {
    // noop
  } else {
    return;
  }
 
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
  XCTAssertNotNil(vc);
  UIView* view = vc.view;
  XCTAssertNotNil(view);
  NSArray* gestureRecognizers = view.gestureRecognizers;
  XCTAssertNotNil(gestureRecognizers);
 
  BOOL found = NO;
  for (id gesture in gestureRecognizers) {
    if ([gesture isKindOfClass:[UIPanGestureRecognizer class]]) {
      found = YES;
      break;
    }
  }
  XCTAssertTrue(found);
}
 
- (void)testMouseSupport API_AVAILABLE(ios(13.4)) {
  if (@available(iOS 13.4, *)) {
    // noop
  } else {
    return;
  }
 
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
  XCTAssertNotNil(vc);
 
  id mockPanGestureRecognizer = OCMClassMock([UIPanGestureRecognizer class]);
  XCTAssertNotNil(mockPanGestureRecognizer);
 
  [vc discreteScrollEvent:mockPanGestureRecognizer];
 
  // The mouse position within panGestureRecognizer should be checked
  [[mockPanGestureRecognizer verify] locationInView:[OCMArg any]];
  [[[self.mockEngine verify] ignoringNonObjectArgs]
      dispatchPointerDataPacket:std::make_unique<flutter::PointerDataPacket>(0)];
}
 
- (void)testFakeEventTimeStamp {
  FlutterViewController* vc = [[FlutterViewController alloc] initWithEngine:self.mockEngine
                                                                    nibName:nil
                                                                     bundle:nil];
  XCTAssertNotNil(vc);
 
  flutter::PointerData pointer_data = [vc generatePointerDataForFake];
  int64_t current_micros = [[NSProcessInfo processInfo] systemUptime] * 1000 * 1000;
  int64_t interval_micros = current_micros - pointer_data.time_stamp;
  const int64_t tolerance_millis = 2;
  XCTAssertTrue(interval_micros / 1000 < tolerance_millis,
                @"PointerData.time_stamp should be equal to NSProcessInfo.systemUptime");
}
 
- (void)testSplashScreenViewCanSetNil {
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithProject:nil nibName:nil bundle:nil];
  [flutterViewController setSplashScreenView:nil];
}
 
- (void)testLifeCycleNotificationApplicationBecameActive {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  UIWindow* window = [[UIWindow alloc] init];
  [window addSubview:flutterViewController.view];
  flutterViewController.view.bounds = CGRectMake(0, 0, 100, 100);
  [flutterViewController viewDidLayoutSubviews];
  NSNotification* sceneNotification =
      [NSNotification notificationWithName:UISceneDidActivateNotification object:nil userInfo:nil];
  NSNotification* applicationNotification =
      [NSNotification notificationWithName:UIApplicationDidBecomeActiveNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  [NSNotificationCenter.defaultCenter postNotification:sceneNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationNotification];
  OCMReject([mockVC sceneBecameActive:[OCMArg any]]);
  OCMVerify([mockVC applicationBecameActive:[OCMArg any]]);
  XCTAssertFalse(
      flutterViewController.keyboardInsetManager.isKeyboardInOrTransitioningFromBackground);
  OCMVerify([mockVC surfaceUpdated:YES]);
  XCTestExpectation* timeoutApplicationLifeCycle =
      [self expectationWithDescription:@"timeoutApplicationLifeCycle"];
  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)),
                 dispatch_get_main_queue(), ^{
                   [timeoutApplicationLifeCycle fulfill];
                   OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.resumed"]);
                   [flutterViewController deregisterNotifications];
                 });
  [self waitForExpectationsWithTimeout:5.0 handler:nil];
}
 
- (void)testLifeCycleNotificationSceneBecameActive {
  id mockBundle = OCMPartialMock([NSBundle mainBundle]);
  OCMStub([mockBundle objectForInfoDictionaryKey:@"NSExtension"]).andReturn(@{
    @"NSExtensionPointIdentifier" : @"com.apple.share-services"
  });
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  UIWindow* window = [[UIWindow alloc] init];
  [window addSubview:flutterViewController.view];
  flutterViewController.view.bounds = CGRectMake(0, 0, 100, 100);
  [flutterViewController viewDidLayoutSubviews];
  NSNotification* sceneNotification =
      [NSNotification notificationWithName:UISceneDidActivateNotification object:nil userInfo:nil];
  NSNotification* applicationNotification =
      [NSNotification notificationWithName:UIApplicationDidBecomeActiveNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  [NSNotificationCenter.defaultCenter postNotification:sceneNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationNotification];
  OCMVerify([mockVC sceneBecameActive:[OCMArg any]]);
  OCMReject([mockVC applicationBecameActive:[OCMArg any]]);
  XCTAssertFalse(
      flutterViewController.keyboardInsetManager.isKeyboardInOrTransitioningFromBackground);
  OCMVerify([mockVC surfaceUpdated:YES]);
  XCTestExpectation* timeoutApplicationLifeCycle =
      [self expectationWithDescription:@"timeoutApplicationLifeCycle"];
  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)),
                 dispatch_get_main_queue(), ^{
                   [timeoutApplicationLifeCycle fulfill];
                   OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.resumed"]);
                   [flutterViewController deregisterNotifications];
                 });
  [self waitForExpectationsWithTimeout:5.0 handler:nil];
  [mockBundle stopMocking];
}
 
- (void)testLifeCycleNotificationApplicationWillResignActive {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  NSNotification* sceneNotification =
      [NSNotification notificationWithName:UISceneWillDeactivateNotification
                                    object:nil
                                  userInfo:nil];
  NSNotification* applicationNotification =
      [NSNotification notificationWithName:UIApplicationWillResignActiveNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  [NSNotificationCenter.defaultCenter postNotification:sceneNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationNotification];
  OCMReject([mockVC sceneWillResignActive:[OCMArg any]]);
  OCMVerify([mockVC applicationWillResignActive:[OCMArg any]]);
  OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.inactive"]);
  [flutterViewController deregisterNotifications];
}
 
- (void)testLifeCycleNotificationSceneWillResignActive {
  id mockBundle = OCMPartialMock([NSBundle mainBundle]);
  OCMStub([mockBundle objectForInfoDictionaryKey:@"NSExtension"]).andReturn(@{
    @"NSExtensionPointIdentifier" : @"com.apple.share-services"
  });
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  NSNotification* sceneNotification =
      [NSNotification notificationWithName:UISceneWillDeactivateNotification
                                    object:nil
                                  userInfo:nil];
  NSNotification* applicationNotification =
      [NSNotification notificationWithName:UIApplicationWillResignActiveNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  [NSNotificationCenter.defaultCenter postNotification:sceneNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationNotification];
  OCMVerify([mockVC sceneWillResignActive:[OCMArg any]]);
  OCMReject([mockVC applicationWillResignActive:[OCMArg any]]);
  OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.inactive"]);
  [flutterViewController deregisterNotifications];
  [mockBundle stopMocking];
}
 
- (void)testLifeCycleNotificationApplicationWillTerminate {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  NSNotification* sceneNotification =
      [NSNotification notificationWithName:UISceneDidDisconnectNotification
                                    object:nil
                                  userInfo:nil];
  NSNotification* applicationNotification =
      [NSNotification notificationWithName:UIApplicationWillTerminateNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  id mockEngine = OCMPartialMock(engine);
  OCMStub([mockVC engine]).andReturn(mockEngine);
  [NSNotificationCenter.defaultCenter postNotification:sceneNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationNotification];
  OCMReject([mockVC sceneWillDisconnect:[OCMArg any]]);
  OCMVerify([mockVC applicationWillTerminate:[OCMArg any]]);
  OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.detached"]);
  OCMVerify([mockEngine destroyContext]);
  [flutterViewController deregisterNotifications];
}
 
- (void)testLifeCycleNotificationSceneWillTerminate {
  id mockBundle = OCMPartialMock([NSBundle mainBundle]);
  OCMStub([mockBundle objectForInfoDictionaryKey:@"NSExtension"]).andReturn(@{
    @"NSExtensionPointIdentifier" : @"com.apple.share-services"
  });
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  NSNotification* sceneNotification =
      [NSNotification notificationWithName:UISceneDidDisconnectNotification
                                    object:nil
                                  userInfo:nil];
  NSNotification* applicationNotification =
      [NSNotification notificationWithName:UIApplicationWillTerminateNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  id mockEngine = OCMPartialMock(engine);
  OCMStub([mockVC engine]).andReturn(mockEngine);
  [NSNotificationCenter.defaultCenter postNotification:sceneNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationNotification];
  OCMVerify([mockVC sceneWillDisconnect:[OCMArg any]]);
  OCMReject([mockVC applicationWillTerminate:[OCMArg any]]);
  OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.detached"]);
  OCMVerify([mockEngine destroyContext]);
  [flutterViewController deregisterNotifications];
  [mockBundle stopMocking];
}
 
- (void)testLifeCycleNotificationApplicationDidEnterBackground {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  NSNotification* sceneNotification =
      [NSNotification notificationWithName:UISceneDidEnterBackgroundNotification
                                    object:nil
                                  userInfo:nil];
  NSNotification* applicationNotification =
      [NSNotification notificationWithName:UIApplicationDidEnterBackgroundNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  [NSNotificationCenter.defaultCenter postNotification:sceneNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationNotification];
  OCMReject([mockVC sceneDidEnterBackground:[OCMArg any]]);
  OCMVerify([mockVC applicationDidEnterBackground:[OCMArg any]]);
  XCTAssertTrue(
      flutterViewController.keyboardInsetManager.isKeyboardInOrTransitioningFromBackground);
  OCMVerify([mockVC surfaceUpdated:NO]);
  OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.paused"]);
  [flutterViewController deregisterNotifications];
}
 
- (void)testLifeCycleNotificationSceneDidEnterBackground {
  id mockBundle = OCMPartialMock([NSBundle mainBundle]);
  OCMStub([mockBundle objectForInfoDictionaryKey:@"NSExtension"]).andReturn(@{
    @"NSExtensionPointIdentifier" : @"com.apple.share-services"
  });
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  NSNotification* sceneNotification =
      [NSNotification notificationWithName:UISceneDidEnterBackgroundNotification
                                    object:nil
                                  userInfo:nil];
  NSNotification* applicationNotification =
      [NSNotification notificationWithName:UIApplicationDidEnterBackgroundNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  [NSNotificationCenter.defaultCenter postNotification:sceneNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationNotification];
  OCMVerify([mockVC sceneDidEnterBackground:[OCMArg any]]);
  OCMReject([mockVC applicationDidEnterBackground:[OCMArg any]]);
  XCTAssertTrue(
      flutterViewController.keyboardInsetManager.isKeyboardInOrTransitioningFromBackground);
  OCMVerify([mockVC surfaceUpdated:NO]);
  OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.paused"]);
  [flutterViewController deregisterNotifications];
  [mockBundle stopMocking];
}
 
/**
 * Verifies that scene lifecycle notifications (specifically UISceneDidEnterBackgroundNotification)
 * originating from a different scene (e.g. out-of-process system keyboard scene on iOS 27 Beta)
 * are ignored, while notifications for the matching scene hosting the view controller are
 * processed.
 *
 * Prevents regressions where global scene notifications trigger pausing the app's rendering.
 * See: https://github.com/flutter/flutter/issues/187844
 */
- (void)
    testLifeCycleNotificationSceneDidEnterBackgroundIgnoresOtherScenes API_AVAILABLE(ios(13.0)) {
  id mockBundle = OCMPartialMock([NSBundle mainBundle]);
  OCMStub([mockBundle objectForInfoDictionaryKey:@"NSExtension"]).andReturn(@{
    @"NSExtensionPointIdentifier" : @"com.apple.share-services"
  });
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  id mockVC = OCMPartialMock(flutterViewController);
 
  // Mock the active window scene that hosts the FlutterViewController.
  id flutterWindowScene = OCMClassMock([UIWindowScene class]);
  OCMStub([mockVC flutterWindowSceneIfViewLoaded]).andReturn(flutterWindowScene);
 
  // Create an auxiliary scene (e.g. the system keyboard) unrelated to the Flutter window.
  id auxiliaryScene = OCMClassMock([UIWindowScene class]);
 
  // Post a notification from the auxiliary (non-Flutter) scene and ensure it is ignored.
  // It should not trigger surface update removal or affect keyboard transitioning state.
  NSNotification* auxiliarySceneNotification =
      [NSNotification notificationWithName:UISceneDidEnterBackgroundNotification
                                    object:auxiliaryScene
                                  userInfo:nil];
  [NSNotificationCenter.defaultCenter postNotification:auxiliarySceneNotification];
  OCMVerify(never(), [mockVC surfaceUpdated:[OCMArg any]]);
  OCMVerify(never(), [mockVC goToApplicationLifecycle:@"AppLifecycleState.paused"]);
  XCTAssertFalse(
      flutterViewController.keyboardInsetManager.isKeyboardInOrTransitioningFromBackground);
 
  // Post a notification from the Flutter scene and assert it is processed.
  // It should trigger surface update removal and transition lifecycle state to paused.
  NSNotification* flutterSceneNotification =
      [NSNotification notificationWithName:UISceneDidEnterBackgroundNotification
                                    object:flutterWindowScene
                                  userInfo:nil];
  [NSNotificationCenter.defaultCenter postNotification:flutterSceneNotification];
  OCMVerify([mockVC surfaceUpdated:NO]);
  OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.paused"]);
  XCTAssertTrue(
      flutterViewController.keyboardInsetManager.isKeyboardInOrTransitioningFromBackground);
 
  [flutterViewController deregisterNotifications];
  [mockBundle stopMocking];
}
 
- (void)testLifeCycleNotificationApplicationWillEnterForeground {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  NSNotification* sceneNotification =
      [NSNotification notificationWithName:UISceneWillEnterForegroundNotification
                                    object:nil
                                  userInfo:nil];
  NSNotification* applicationNotification =
      [NSNotification notificationWithName:UIApplicationWillEnterForegroundNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  [NSNotificationCenter.defaultCenter postNotification:sceneNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationNotification];
  OCMReject([mockVC sceneWillEnterForeground:[OCMArg any]]);
  OCMVerify([mockVC applicationWillEnterForeground:[OCMArg any]]);
  OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.inactive"]);
  [flutterViewController deregisterNotifications];
}
 
- (void)testLifeCycleNotificationSceneWillEnterForeground {
  id mockBundle = OCMPartialMock([NSBundle mainBundle]);
  OCMStub([mockBundle objectForInfoDictionaryKey:@"NSExtension"]).andReturn(@{
    @"NSExtensionPointIdentifier" : @"com.apple.share-services"
  });
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  NSNotification* sceneNotification =
      [NSNotification notificationWithName:UISceneWillEnterForegroundNotification
                                    object:nil
                                  userInfo:nil];
  NSNotification* applicationNotification =
      [NSNotification notificationWithName:UIApplicationWillEnterForegroundNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  [NSNotificationCenter.defaultCenter postNotification:sceneNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationNotification];
  OCMVerify([mockVC sceneWillEnterForeground:[OCMArg any]]);
  OCMReject([mockVC applicationWillEnterForeground:[OCMArg any]]);
  OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.inactive"]);
  [flutterViewController deregisterNotifications];
  [mockBundle stopMocking];
}
 
- (void)testLifeCycleNotificationCancelledInvalidResumed {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* flutterViewController =
      [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
  NSNotification* applicationDidBecomeActiveNotification =
      [NSNotification notificationWithName:UIApplicationDidBecomeActiveNotification
                                    object:nil
                                  userInfo:nil];
  NSNotification* applicationWillResignActiveNotification =
      [NSNotification notificationWithName:UIApplicationWillResignActiveNotification
                                    object:nil
                                  userInfo:nil];
  id mockVC = OCMPartialMock(flutterViewController);
  [NSNotificationCenter.defaultCenter postNotification:applicationDidBecomeActiveNotification];
  [NSNotificationCenter.defaultCenter postNotification:applicationWillResignActiveNotification];
  OCMVerify([mockVC goToApplicationLifecycle:@"AppLifecycleState.inactive"]);
 
  XCTestExpectation* timeoutApplicationLifeCycle =
      [self expectationWithDescription:@"timeoutApplicationLifeCycle"];
  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)),
                 dispatch_get_main_queue(), ^{
                   OCMReject([mockVC goToApplicationLifecycle:@"AppLifecycleState.resumed"]);
                   [timeoutApplicationLifeCycle fulfill];
                   [flutterViewController deregisterNotifications];
                 });
  [self waitForExpectationsWithTimeout:5.0 handler:nil];
}
 
- (void)testSetupKeyboardAnimationVsyncClientWillCreateNewVsyncClientForFlutterViewController {
  id bundleMock = OCMPartialMock([NSBundle mainBundle]);
  OCMStub([bundleMock objectForInfoDictionaryKey:@"CADisableMinimumFrameDurationOnPhone"])
      .andReturn(@YES);
  id mockDisplayLinkManager = OCMPartialMock([FlutterDisplayLinkManager shared]);
  [self addTeardownBlock:^{
    [mockDisplayLinkManager stopMocking];
  }];
  double maxFrameRate = 120;
  (void)[[[mockDisplayLinkManager stub] andReturnValue:@(maxFrameRate)] displayRefreshRate];
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterKeyboardAnimationCallback callback = ^(NSTimeInterval targetTime) {
  };
  [viewController.keyboardInsetManager setUpKeyboardAnimationVsyncClient:callback];
  XCTAssertNotNil(viewController.keyboardInsetManager.keyboardAnimationVSyncClient);
  CADisplayLink* link =
      viewController.keyboardInsetManager.keyboardAnimationVSyncClient.displayLink;
  XCTAssertNotNil(link);
  CADisplayLink* linkMock = OCMPartialMock(link);
  if (@available(iOS 15.0, *)) {
    CAFrameRateRange range = CAFrameRateRangeMake(maxFrameRate / 2, maxFrameRate, maxFrameRate);
    NSValue* rangeValue = [NSValue valueWithBytes:&range objCType:@encode(CAFrameRateRange)];
    [[[(id)linkMock stub] andReturnValue:rangeValue] preferredFrameRateRange];
 
    XCTAssertEqual(linkMock.preferredFrameRateRange.maximum, maxFrameRate);
    XCTAssertEqual(linkMock.preferredFrameRateRange.preferred, maxFrameRate);
    XCTAssertEqual(linkMock.preferredFrameRateRange.minimum, maxFrameRate / 2);
  } else {
    [[[(id)linkMock stub] andReturnValue:@(maxFrameRate)] preferredFramesPerSecond];
    XCTAssertEqual(linkMock.preferredFramesPerSecond, maxFrameRate);
  }
}
 
- (void)
    testCreateTouchRateCorrectionVSyncClientWillCreateVsyncClientWhenRefreshRateIsLargerThan60HZ {
  id mockDisplayLinkManager = OCMPartialMock([FlutterDisplayLinkManager shared]);
  [self addTeardownBlock:^{
    [mockDisplayLinkManager stopMocking];
  }];
  double maxFrameRate = 120;
  (void)[[[mockDisplayLinkManager stub] andReturnValue:@(maxFrameRate)] displayRefreshRate];
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController createTouchRateCorrectionVSyncClientIfNeeded];
  XCTAssertNotNil(viewController.touchRateCorrectionVSyncClient);
}
 
- (void)testCreateTouchRateCorrectionVSyncClientWillNotCreateNewVSyncClientWhenClientAlreadyExists {
  id mockDisplayLinkManager = OCMPartialMock([FlutterDisplayLinkManager shared]);
  [self addTeardownBlock:^{
    [mockDisplayLinkManager stopMocking];
  }];
  double maxFrameRate = 120;
  (void)[[[mockDisplayLinkManager stub] andReturnValue:@(maxFrameRate)] displayRefreshRate];
 
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController createTouchRateCorrectionVSyncClientIfNeeded];
  FlutterVSyncClient* clientBefore = viewController.touchRateCorrectionVSyncClient;
  XCTAssertNotNil(clientBefore);
 
  [viewController createTouchRateCorrectionVSyncClientIfNeeded];
  FlutterVSyncClient* clientAfter = viewController.touchRateCorrectionVSyncClient;
  XCTAssertNotNil(clientAfter);
 
  XCTAssertTrue(clientBefore == clientAfter);
}
 
- (void)testCreateTouchRateCorrectionVSyncClientWillNotCreateVsyncClientWhenRefreshRateIs60HZ {
  id mockDisplayLinkManager = OCMPartialMock([FlutterDisplayLinkManager shared]);
  [self addTeardownBlock:^{
    [mockDisplayLinkManager stopMocking];
  }];
  double maxFrameRate = 60;
  (void)[[[mockDisplayLinkManager stub] andReturnValue:@(maxFrameRate)] displayRefreshRate];
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController createTouchRateCorrectionVSyncClientIfNeeded];
  XCTAssertNil(viewController.touchRateCorrectionVSyncClient);
}
 
- (void)testTriggerTouchRateCorrectionVSyncClientCorrectly {
  id mockDisplayLinkManager = OCMPartialMock([FlutterDisplayLinkManager shared]);
  [self addTeardownBlock:^{
    [mockDisplayLinkManager stopMocking];
  }];
  double maxFrameRate = 120;
  (void)[[[mockDisplayLinkManager stub] andReturnValue:@(maxFrameRate)] displayRefreshRate];
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
  [viewController viewDidLoad];
 
  FlutterVSyncClient* client = viewController.touchRateCorrectionVSyncClient;
  CADisplayLink* link = client.displayLink;
 
  UITouch* fakeTouchBegan = [[UITouch alloc] init];
  fakeTouchBegan.phase = UITouchPhaseBegan;
 
  UITouch* fakeTouchMove = [[UITouch alloc] init];
  fakeTouchMove.phase = UITouchPhaseMoved;
 
  UITouch* fakeTouchEnd = [[UITouch alloc] init];
  fakeTouchEnd.phase = UITouchPhaseEnded;
 
  UITouch* fakeTouchCancelled = [[UITouch alloc] init];
  fakeTouchCancelled.phase = UITouchPhaseCancelled;
 
  [viewController
      triggerTouchRateCorrectionIfNeeded:[[NSSet alloc] initWithObjects:fakeTouchBegan, nil]];
  XCTAssertFalse(link.isPaused);
 
  [viewController
      triggerTouchRateCorrectionIfNeeded:[[NSSet alloc] initWithObjects:fakeTouchEnd, nil]];
  XCTAssertTrue(link.isPaused);
 
  [viewController
      triggerTouchRateCorrectionIfNeeded:[[NSSet alloc] initWithObjects:fakeTouchMove, nil]];
  XCTAssertFalse(link.isPaused);
 
  [viewController
      triggerTouchRateCorrectionIfNeeded:[[NSSet alloc] initWithObjects:fakeTouchCancelled, nil]];
  XCTAssertTrue(link.isPaused);
 
  [viewController
      triggerTouchRateCorrectionIfNeeded:[[NSSet alloc]
                                             initWithObjects:fakeTouchBegan, fakeTouchEnd, nil]];
  XCTAssertFalse(link.isPaused);
 
  [viewController
      triggerTouchRateCorrectionIfNeeded:[[NSSet alloc] initWithObjects:fakeTouchEnd,
                                                                        fakeTouchCancelled, nil]];
  XCTAssertTrue(link.isPaused);
 
  [viewController
      triggerTouchRateCorrectionIfNeeded:[[NSSet alloc]
                                             initWithObjects:fakeTouchMove, fakeTouchEnd, nil]];
  XCTAssertFalse(link.isPaused);
}
 
- (void)testFlutterViewControllerStartKeyboardAnimationWillCreateVsyncClientCorrectly {
  id mockDisplayLink = OCMClassMock([CADisplayLink class]);
  OCMStub(ClassMethod([mockDisplayLink displayLinkWithTarget:[OCMArg any]
                                                    selector:sel_registerName("onDisplayLink:")]))
      .andReturn(mockDisplayLink);
 
  TestKeyboardInsetDelegate* delegate = [[TestKeyboardInsetDelegate alloc] init];
  delegate.isViewLoaded = YES;
  FlutterEnginePartialMock* engine = [[FlutterEnginePartialMock alloc] init];
  delegate.mockEngine = engine;
 
  FlutterKeyboardInsetManager* manager =
      [[FlutterKeyboardInsetManager alloc] initWithDelegate:delegate
                                         displayLinkManager:FlutterDisplayLinkManager.shared];
  manager.targetViewInsetBottom = 100;
  [manager startKeyBoardAnimation:0.25];
 
  XCTAssertNotNil(manager.keyboardAnimationVSyncClient);
  fml::MessageLoop::GetCurrent().RunExpiredTasksNow();
  [manager invalidate];
  [mockDisplayLink stopMocking];
}
 
- (void)
    testSetupKeyboardAnimationVsyncClientWillNotCreateNewVsyncClientWhenKeyboardAnimationCallbackIsNil {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController.keyboardInsetManager setUpKeyboardAnimationVsyncClient:nil];
  XCTAssertNil(viewController.keyboardInsetManager.keyboardAnimationVSyncClient);
}
 
- (void)testSupportsShowingSystemContextMenuForIOS16AndAbove {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  BOOL supportsShowingSystemContextMenu = [viewController supportsShowingSystemContextMenu];
  if (@available(iOS 16.0, *)) {
    XCTAssertTrue(supportsShowingSystemContextMenu);
  } else {
    XCTAssertFalse(supportsShowingSystemContextMenu);
  }
}
 
- (void)testStateIsActiveAndBackgroundWhenApplicationStateIsActive {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  id mockApplication = OCMClassMock([UIApplication class]);
  OCMStub([mockApplication applicationState]).andReturn(UIApplicationStateActive);
  OCMStub([mockApplication sharedApplication]).andReturn(mockApplication);
  XCTAssertTrue(viewController.stateIsActive);
  XCTAssertFalse(viewController.stateIsBackground);
}
 
- (void)testStateIsActiveAndBackgroundWhenApplicationStateIsBackground {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  id mockApplication = OCMClassMock([UIApplication class]);
  OCMStub([mockApplication applicationState]).andReturn(UIApplicationStateBackground);
  OCMStub([mockApplication sharedApplication]).andReturn(mockApplication);
  XCTAssertFalse(viewController.stateIsActive);
  XCTAssertTrue(viewController.stateIsBackground);
}
 
- (void)testStateIsActiveAndBackgroundWhenApplicationStateIsInactive {
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  id mockApplication = OCMClassMock([UIApplication class]);
  OCMStub([mockApplication applicationState]).andReturn(UIApplicationStateInactive);
  OCMStub([mockApplication sharedApplication]).andReturn(mockApplication);
  XCTAssertFalse(viewController.stateIsActive);
  XCTAssertFalse(viewController.stateIsBackground);
}
 
- (void)testStateIsActiveAndBackgroundWhenSceneStateIsActive {
  id mockBundle = OCMPartialMock([NSBundle mainBundle]);
  OCMStub([mockBundle objectForInfoDictionaryKey:@"NSExtension"]).andReturn(@{
    @"NSExtensionPointIdentifier" : @"com.apple.share-services"
  });
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  id mockVC = OCMPartialMock(viewController);
  OCMStub([mockVC activationState]).andReturn(UISceneActivationStateForegroundActive);
  XCTAssertTrue(viewController.stateIsActive);
  XCTAssertFalse(viewController.stateIsBackground);
 
  [mockBundle stopMocking];
  [mockVC stopMocking];
}
 
- (void)testStateIsActiveAndBackgroundWhenSceneStateIsBackground {
  id mockBundle = OCMPartialMock([NSBundle mainBundle]);
  OCMStub([mockBundle objectForInfoDictionaryKey:@"NSExtension"]).andReturn(@{
    @"NSExtensionPointIdentifier" : @"com.apple.share-services"
  });
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  id mockVC = OCMPartialMock(viewController);
  OCMStub([mockVC activationState]).andReturn(UISceneActivationStateBackground);
  XCTAssertFalse(viewController.stateIsActive);
  XCTAssertTrue(viewController.stateIsBackground);
 
  [mockBundle stopMocking];
  [mockVC stopMocking];
}
 
- (void)testStateIsActiveAndBackgroundWhenSceneStateIsInactive {
  id mockBundle = OCMPartialMock([NSBundle mainBundle]);
  OCMStub([mockBundle objectForInfoDictionaryKey:@"NSExtension"]).andReturn(@{
    @"NSExtensionPointIdentifier" : @"com.apple.share-services"
  });
  FlutterEngine* engine = [[FlutterEngine alloc] init];
  [engine runWithEntrypoint:nil];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  id mockVC = OCMPartialMock(viewController);
  OCMStub([mockVC activationState]).andReturn(UISceneActivationStateForegroundInactive);
  XCTAssertFalse(viewController.stateIsActive);
  XCTAssertFalse(viewController.stateIsBackground);
 
  [mockBundle stopMocking];
  [mockVC stopMocking];
}
 
- (void)testPerformImplicitEngineCallbacks {
  id mockRegistrant = OCMProtocolMock(@protocol(FlutterPluginRegistrant));
  id appDelegate = [[UIApplication sharedApplication] delegate];
  [appDelegate setMockLaunchEngine:self.mockEngine];
  UIStoryboard* storyboard = [UIStoryboard storyboardWithName:@"Flutter" bundle:nil];
  XCTAssertTrue([appDelegate respondsToSelector:@selector(setPluginRegistrant:)]);
  [appDelegate setPluginRegistrant:mockRegistrant];
  FlutterViewController* viewController =
      (FlutterViewController*)[storyboard instantiateInitialViewController];
  [appDelegate setPluginRegistrant:nil];
  OCMVerify([mockRegistrant registerWithRegistry:viewController]);
  OCMVerify([self.mockEngine performImplicitEngineCallback]);
  [appDelegate setMockLaunchEngine:nil];
}
 
- (void)testPerformImplicitEngineCallbacksUsesAppLaunchEventFallbacks {
  id mockEngine = OCMClassMock([FlutterEngine class]);
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  OCMStub([mockEngine performImplicitEngineCallback]).andReturn(YES);
  OCMStub([viewControllerMock awokenFromNib]).andReturn(YES);
 
  id mockApplication = OCMClassMock([UIApplication class]);
  OCMStub([mockApplication sharedApplication]).andReturn(mockApplication);
  FlutterAppDelegate* mockApplicationDelegate = OCMClassMock([FlutterAppDelegate class]);
  OCMStub([mockApplication delegate]).andReturn(mockApplicationDelegate);
  OCMStub([mockApplicationDelegate takeLaunchEngine]).andReturn(mockEngine);
 
  id mockScene = OCMClassMock([UIScene class]);
  id mockSceneDelegate = OCMProtocolMock(@protocol(UISceneDelegate));
  OCMStub([mockScene delegate]).andReturn(mockSceneDelegate);
  OCMStub([mockApplication connectedScenes]).andReturn([NSSet setWithObject:mockScene]);
 
  FlutterPluginAppLifeCycleDelegate* mockLifecycleDelegate =
      OCMClassMock([FlutterPluginAppLifeCycleDelegate class]);
  OCMStub([mockApplicationDelegate lifeCycleDelegate]).andReturn(mockLifecycleDelegate);
 
  [viewControllerMock sharedSetupWithProject:nil initialRoute:nil];
  OCMVerify([mockLifecycleDelegate sceneFallbackWillFinishLaunchingApplication:mockApplication]);
  OCMVerify([mockLifecycleDelegate sceneFallbackDidFinishLaunchingApplication:mockApplication]);
}
 
- (void)testPerformImplicitEngineCallbacksNoAppLaunchEventFallbacksWhenNoStoryboard {
  id mockEngine = OCMClassMock([FlutterEngine class]);
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  OCMStub([mockEngine performImplicitEngineCallback]).andReturn(YES);
  OCMStub([viewControllerMock awokenFromNib]).andReturn(NO);
 
  id mockApplication = OCMClassMock([UIApplication class]);
  OCMStub([mockApplication sharedApplication]).andReturn(mockApplication);
  FlutterAppDelegate* mockApplicationDelegate = OCMClassMock([FlutterAppDelegate class]);
  OCMStub([mockApplication delegate]).andReturn(mockApplicationDelegate);
  OCMStub([mockApplicationDelegate takeLaunchEngine]).andReturn(mockEngine);
 
  id mockScene = OCMClassMock([UIScene class]);
  id mockSceneDelegate = OCMProtocolMock(@protocol(UISceneDelegate));
  OCMStub([mockScene delegate]).andReturn(mockSceneDelegate);
  OCMStub([mockApplication connectedScenes]).andReturn([NSSet setWithObject:mockScene]);
 
  FlutterPluginAppLifeCycleDelegate* mockLifecycleDelegate =
      OCMClassMock([FlutterPluginAppLifeCycleDelegate class]);
  OCMStub([mockApplicationDelegate lifeCycleDelegate]).andReturn(mockLifecycleDelegate);
 
  [viewControllerMock sharedSetupWithProject:nil initialRoute:nil];
  OCMReject([mockLifecycleDelegate sceneFallbackWillFinishLaunchingApplication:mockApplication]);
  OCMReject([mockLifecycleDelegate sceneFallbackDidFinishLaunchingApplication:mockApplication]);
}
 
- (void)testPerformImplicitEngineCallbacksNoAppLaunchEventFallbacksWhenNoScenes {
  id mockEngine = OCMClassMock([FlutterEngine class]);
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:mockEngine
                                                                                nibName:nil
                                                                                 bundle:nil];
  FlutterViewController* viewControllerMock = OCMPartialMock(viewController);
  OCMStub([mockEngine performImplicitEngineCallback]).andReturn(YES);
  OCMStub([viewControllerMock awokenFromNib]).andReturn(YES);
 
  id mockApplication = OCMClassMock([UIApplication class]);
  OCMStub([mockApplication sharedApplication]).andReturn(mockApplication);
  FlutterAppDelegate* mockApplicationDelegate = OCMClassMock([FlutterAppDelegate class]);
  OCMStub([mockApplication delegate]).andReturn(mockApplicationDelegate);
  OCMStub([mockApplicationDelegate takeLaunchEngine]).andReturn(mockEngine);
 
  FlutterPluginAppLifeCycleDelegate* mockLifecycleDelegate =
      OCMClassMock([FlutterPluginAppLifeCycleDelegate class]);
  OCMStub([mockApplicationDelegate lifeCycleDelegate]).andReturn(mockLifecycleDelegate);
 
  [viewControllerMock sharedSetupWithProject:nil initialRoute:nil];
  OCMReject([mockLifecycleDelegate sceneFallbackWillFinishLaunchingApplication:mockApplication]);
  OCMReject([mockLifecycleDelegate sceneFallbackDidFinishLaunchingApplication:mockApplication]);
}
 
- (void)testGrabLaunchEngine {
  id appDelegate = [[UIApplication sharedApplication] delegate];
  XCTAssertTrue([appDelegate respondsToSelector:@selector(setMockLaunchEngine:)]);
  [appDelegate setMockLaunchEngine:self.mockEngine];
  UIStoryboard* storyboard = [UIStoryboard storyboardWithName:@"Flutter" bundle:nil];
  XCTAssertTrue(storyboard);
  FlutterViewController* viewController =
      (FlutterViewController*)[storyboard instantiateInitialViewController];
  XCTAssertTrue(viewController);
  XCTAssertTrue([viewController isKindOfClass:[FlutterViewController class]]);
  XCTAssertEqual(viewController.engine, self.mockEngine);
  [appDelegate setMockLaunchEngine:nil];
}
 
- (void)testDoesntGrabLaunchEngine {
  id appDelegate = [[UIApplication sharedApplication] delegate];
  XCTAssertTrue([appDelegate respondsToSelector:@selector(setMockLaunchEngine:)]);
  [appDelegate setMockLaunchEngine:self.mockEngine];
  FlutterViewController* flutterViewController = [[FlutterViewController alloc] init];
  XCTAssertNotNil(flutterViewController.engine);
  XCTAssertNotEqual(flutterViewController.engine, self.mockEngine);
  [appDelegate setMockLaunchEngine:nil];
}
 
@end