#include <Carbon/Carbon.h>
import <Foundation/Foundation.h>
import <OCMock/OCMock.h>
import "flutter/shell/platform/darwin/macos/framework/Source/FlutterEngine_Internal.h"
import "flutter/shell/platform/darwin/macos/framework/Source/FlutterKeyPrimaryResponder.h"
import "flutter/shell/platform/darwin/macos/framework/Source/FlutterKeyboardLayout.h"
import "flutter/shell/platform/darwin/macos/framework/Source/FlutterKeyboardManager.h"
#include "flutter/shell/platform/embedder/test_utils/key_codes.g.h"
import "flutter/testing/testing.h"
#include "third_party/googletest/googletest/include/gtest/gtest.h"

Classes
class	KeyboardTester

class	FlutterKeyboardManagerUnittestsObjC

Namespaces
namespace	flutter

namespace	flutter::testing

Macros
#define	VERIFY_DOWN(OUT_LOGICAL, OUT_CHAR)

Functions
	flutter::testing::TEST (FlutterKeyboardManagerUnittests, SinglePrimaryResponder)

	flutter::testing::TEST (FlutterKeyboardManagerUnittests, DoublePrimaryResponder)

	flutter::testing::TEST (FlutterKeyboardManagerUnittests, SingleFinalResponder)

	flutter::testing::TEST (FlutterKeyboardManagerUnittests, EmptyNextResponder)

	flutter::testing::TEST (FlutterKeyboardManagerUnittests, GetPressedState)

	flutter::testing::TEST (FlutterKeyboardManagerUnittests, KeyboardChannelGetPressedState)

	flutter::testing::TEST (FlutterKeyboardManagerUnittests, RacingConditionBetweenKeyAndText)

	flutter::testing::TEST (FlutterKeyboardManagerUnittests, CorrectLogicalKeyForLayouts)

	flutter::testing::TEST (FlutterKeyboardManagerUnittests, ShouldNotHoldStrongReferenceToDelegate)

Variables
AsyncKeyCallbackHandler	_channelHandler

TextInputCallback	_textCallback

NSMutableArray< NSNumber * > *	_typeStorage

uint32_t	_typeStorageMask

__weak id< FlutterKeyboardLayoutDelegate >	_keyboardLayoutDelegate

const MockLayoutData *	_currentLayout

id	_keyboardChannelResult

NSObject< FlutterBinaryMessenger > *	_messengerMock

FlutterBinaryMessageHandler	_keyboardHandler

NSObject< FlutterKeyboardManagerEventContext > *	_eventContextMock

Macro Definition Documentation

◆ VERIFY_DOWN

#define VERIFY_DOWN	(	OUT_LOGICAL,
		OUT_CHAR
	)

Value:

  EXPECT_EQ(events[0].type, kFlutterKeyEventTypeDown);              \
  EXPECT_EQ(events[0].logical, static_cast<uint64_t>(OUT_LOGICAL)); \
  EXPECT_STREQ(events[0].character, (OUT_CHAR));                    \
  clearEvents(events);

Definition at line 173 of file FlutterKeyboardManagerTest.mm.

                          : NSObject
- (nonnull instancetype)init;
 
// Set embedder calls to respond immediately with the given response.
- (void)respondEmbedderCallsWith:(BOOL)response;
 
// Record embedder calls to the given storage.
//
// They are not responded to until the stored callbacks are manually called.
- (void)recordEmbedderCallsTo:(nonnull NSMutableArray<FlutterAsyncKeyCallback>*)storage;
 
- (void)recordEmbedderEventsTo:(nonnull std::vector<FlutterKeyEvent>*)storage
                     returning:(bool)handled;
 
// Set channel calls to respond immediately with the given response.
- (void)respondChannelCallsWith:(BOOL)response;
 
// Record channel calls to the given storage.
//
// They are not responded to until the stored callbacks are manually called.
- (void)recordChannelCallsTo:(nonnull NSMutableArray<FlutterAsyncKeyCallback>*)storage;
 
// Set text calls to respond with the given response.
- (void)respondTextInputWith:(BOOL)response;
 
// At the start of any kind of call, record the call type to the given storage.
//
// Only calls that are included in `typeMask` will be added. Options are
// kEmbedderCall, kChannelCall, and kTextCall.
//
// This method does not conflict with other call settings, and the recording
// takes place before the callbacks are (or are not) invoked.
- (void)recordCallTypesTo:(nonnull NSMutableArray<NSNumber*>*)typeStorage
                 forTypes:(uint32_t)typeMask;
 
- (id)lastKeyboardChannelResult;
 
- (void)sendKeyboardChannelMessage:(NSData* _Nullable)message;
 
@property(readonly, nonatomic, strong) FlutterKeyboardManager* manager;
@property(readonly, nonatomic, strong) id<FlutterKeyboardManagerEventContext> eventContextMock;
@property(nonatomic, nullable, strong) NSResponder* nextResponder;
 
#pragma mark - Private
 
- (void)handleEmbedderEvent:(const FlutterKeyEvent&)event
                   callback:(nullable FlutterKeyEventCallback)callback
                   userData:(nullable void*)userData;
 
- (void)handleChannelMessage:(NSString*)channel
                     message:(NSData* _Nullable)message
                 binaryReply:(FlutterBinaryReply _Nullable)callback;
 
- (BOOL)handleTextInputKeyEvent:(NSEvent*)event;
@end
 
@implementation KeyboardTester {
  AsyncEmbedderCallbackHandler _embedderHandler;
  AsyncKeyCallbackHandler _channelHandler;
  TextInputCallback _textCallback;
 
  NSMutableArray<NSNumber*>* _typeStorage;
  uint32_t _typeStorageMask;
 
  __weak id<FlutterKeyboardLayoutDelegate> _keyboardLayoutDelegate;
  const MockLayoutData* _currentLayout;
 
  id _keyboardChannelResult;
  NSObject<FlutterBinaryMessenger>* _messengerMock;
  FlutterBinaryMessageHandler _keyboardHandler;
 
  NSObject<FlutterKeyboardManagerEventContext>* _eventContextMock;
}
 
- (nonnull instancetype)init {
  self = [super init];
  if (self == nil) {
    return nil;
  }
 
  _nextResponder = OCMClassMock([NSResponder class]);
  [self respondChannelCallsWith:FALSE];
  [self respondEmbedderCallsWith:FALSE];
  [self respondTextInputWith:FALSE];
 
  _currentLayout = &kUsLayout;
 
  _messengerMock = OCMStrictProtocolMock(@protocol(FlutterBinaryMessenger));
  OCMStub([_messengerMock sendOnChannel:@"flutter/keyevent"
                                message:[OCMArg any]
                            binaryReply:[OCMArg any]])
      .andCall(self, @selector(handleChannelMessage:message:binaryReply:));
  OCMStub([_messengerMock setMessageHandlerOnChannel:@"flutter/keyboard"
                                binaryMessageHandler:[OCMArg any]])
      .andCall(self, @selector(setKeyboardChannelHandler:handler:));
  OCMStub([_messengerMock sendOnChannel:@"flutter/keyboard" message:[OCMArg any]])
      .andCall(self, @selector(handleKeyboardChannelMessage:message:));
  id managerDelegateMock = OCMStrictProtocolMock(@protocol(FlutterKeyboardManagerDelegate));
  OCMStub([managerDelegateMock binaryMessenger]).andReturn(_messengerMock);
  OCMStub([managerDelegateMock sendKeyEvent:*(const FlutterKeyEvent*)[OCMArg anyPointer]
                                   callback:nil
                                   userData:nil])
      .ignoringNonObjectArgs()
      .andCall(self, @selector(handleEmbedderEvent:callback:userData:));
 
  _eventContextMock = OCMStrictProtocolMock(@protocol(FlutterKeyboardManagerEventContext));
  OCMStub([_eventContextMock nextResponder]).andReturn(_nextResponder);
  OCMStub([_eventContextMock onTextInputKeyEvent:[OCMArg any]])
      .andCall(self, @selector(handleTextInputKeyEvent:));
 
  id keyboardLayoutMock = OCMStrictClassMock([FlutterKeyboardLayout class]);
  OCMStub([keyboardLayoutMock lookUpLayoutForKeyCode:0 shift:false])
      .ignoringNonObjectArgs()
      .andCall(self, @selector(lookUpLayoutForKeyCode:shift:));
  OCMStub([keyboardLayoutMock setDelegate:[OCMArg any]])
      .andCall(self, @selector(onSetKeyboardLayoutDelegate:));
 
  _manager = [[FlutterKeyboardManager alloc] initWithDelegate:managerDelegateMock
                                               keyboardLayout:keyboardLayoutMock];
  return self;
}
 
- (id)lastKeyboardChannelResult {
  return _keyboardChannelResult;
}
 
- (void)respondEmbedderCallsWith:(BOOL)response {
  _embedderHandler = ^(const FlutterKeyEvent* event, FlutterAsyncKeyCallback callback) {
    callback(response);
  };
}
 
- (void)recordEmbedderCallsTo:(nonnull NSMutableArray<FlutterAsyncKeyCallback>*)storage {
  _embedderHandler = ^(const FlutterKeyEvent* event, FlutterAsyncKeyCallback callback) {
    [storage addObject:callback];
  };
}
 
- (void)recordEmbedderEventsTo:(nonnull std::vector<FlutterKeyEvent>*)storage
                     returning:(bool)handled {
  _embedderHandler = ^(const FlutterKeyEvent* event, FlutterAsyncKeyCallback callback) {
    FlutterKeyEvent newEvent = *event;
    if (event->character != nullptr) {
      size_t charLen = strlen(event->character);
      char* newCharacter = new char[charLen + 1];
      strlcpy(newCharacter, event->character, charLen + 1);
      newEvent.character = newCharacter;
    }
    storage->push_back(newEvent);
    callback(handled);
  };
}
 
- (void)respondChannelCallsWith:(BOOL)response {
  _channelHandler = ^(FlutterAsyncKeyCallback callback) {
    callback(response);
  };
}
 
- (void)recordChannelCallsTo:(nonnull NSMutableArray<FlutterAsyncKeyCallback>*)storage {
  _channelHandler = ^(FlutterAsyncKeyCallback callback) {
    [storage addObject:callback];
  };
}
 
- (void)respondTextInputWith:(BOOL)response {
  _textCallback = ^(NSEvent* event) {
    return response;
  };
}
 
- (void)recordCallTypesTo:(nonnull NSMutableArray<NSNumber*>*)typeStorage
                 forTypes:(uint32_t)typeMask {
  _typeStorage = typeStorage;
  _typeStorageMask = typeMask;
}
 
- (void)sendKeyboardChannelMessage:(NSData* _Nullable)message {
  [_messengerMock sendOnChannel:@"flutter/keyboard" message:message];
}
 
- (void)setLayout:(const MockLayoutData&)layout {
  _currentLayout = &layout;
  [_keyboardLayoutDelegate keyboardLayoutDidChange];
}
 
#pragma mark - Private
 
- (void)handleEmbedderEvent:(const FlutterKeyEvent&)event
                   callback:(nullable FlutterKeyEventCallback)callback
                   userData:(nullable void*)userData {
  if (_typeStorage != nil && (_typeStorageMask & kEmbedderCall) != 0) {
    [_typeStorage addObject:@(kEmbedderCall)];
  }
  if (callback != nullptr) {
    _embedderHandler(&event, ^(BOOL handled) {
      callback(handled, userData);
    });
  }
}
 
- (void)handleChannelMessage:(NSString*)channel
                     message:(NSData* _Nullable)message
                 binaryReply:(FlutterBinaryReply _Nullable)callback {
  if (_typeStorage != nil && (_typeStorageMask & kChannelCall) != 0) {
    [_typeStorage addObject:@(kChannelCall)];
  }
  _channelHandler(^(BOOL handled) {
    NSDictionary* result = @{
      @"handled" : @(handled),
    };
    NSData* encodedKeyEvent = [[FlutterJSONMessageCodec sharedInstance] encode:result];
    callback(encodedKeyEvent);
  });
}
 
- (void)handleKeyboardChannelMessage:(NSString*)channel message:(NSData* _Nullable)message {
  _keyboardHandler(message, ^(id result) {
    _keyboardChannelResult = result;
  });
}
 
- (BOOL)handleTextInputKeyEvent:(NSEvent*)event {
  if (_typeStorage != nil && (_typeStorageMask & kTextCall) != 0) {
    [_typeStorage addObject:@(kTextCall)];
  }
  return _textCallback(event);
}
 
- (void)onSetKeyboardLayoutDelegate:(id<FlutterKeyboardLayoutDelegate>)delegate {
  _keyboardLayoutDelegate = delegate;
}
 
- (LayoutClue)lookUpLayoutForKeyCode:(uint16_t)keyCode shift:(BOOL)shift {
  uint32_t cluePair = (*_currentLayout)[(keyCode * 2) + (shift ? 1 : 0)];
  const uint32_t kCharMask = 0xffff;
  const uint32_t kDeadKeyMask = 0x10000;
  return LayoutClue{cluePair & kCharMask, (cluePair & kDeadKeyMask) != 0};
}
 
- (void)setKeyboardChannelHandler:(NSString*)channel handler:(FlutterBinaryMessageHandler)handler {
  _keyboardHandler = handler;
}
 
@end
 
@interface FlutterKeyboardManagerUnittestsObjC : NSObject
- (bool)singlePrimaryResponder;
- (bool)doublePrimaryResponder;
- (bool)textInputPlugin;
- (bool)emptyNextResponder;
- (bool)getPressedState;
- (bool)keyboardChannelGetPressedState;
- (bool)racingConditionBetweenKeyAndText;
- (bool)correctLogicalKeyForLayouts;
- (bool)shouldNotHoldStrongReferenceToDelegate;
@end
 
namespace flutter::testing {
 
TEST(FlutterKeyboardManagerUnittests, SinglePrimaryResponder) {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] singlePrimaryResponder]);
}
 
TEST(FlutterKeyboardManagerUnittests, DoublePrimaryResponder) {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] doublePrimaryResponder]);
}
 
TEST(FlutterKeyboardManagerUnittests, SingleFinalResponder) {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] textInputPlugin]);
}
 
TEST(FlutterKeyboardManagerUnittests, EmptyNextResponder) {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] emptyNextResponder]);
}
 
TEST(FlutterKeyboardManagerUnittests, GetPressedState) {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] getPressedState]);
}
 
TEST(FlutterKeyboardManagerUnittests, KeyboardChannelGetPressedState) {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] keyboardChannelGetPressedState]);
}
 
TEST(FlutterKeyboardManagerUnittests, RacingConditionBetweenKeyAndText) {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] racingConditionBetweenKeyAndText]);
}
 
TEST(FlutterKeyboardManagerUnittests, CorrectLogicalKeyForLayouts) {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] correctLogicalKeyForLayouts]);
}
 
TEST(FlutterKeyboardManagerUnittests, ShouldNotHoldStrongReferenceToDelegate) {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] shouldNotHoldStrongReferenceToDelegate]);
}
 
}  // namespace flutter::testing
 
@implementation FlutterKeyboardManagerUnittestsObjC
 
- (bool)singlePrimaryResponder {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
  NSMutableArray<FlutterAsyncKeyCallback>* embedderCallbacks =
      [NSMutableArray<FlutterAsyncKeyCallback> array];
  [tester recordEmbedderCallsTo:embedderCallbacks];
 
  // Case: The responder reports FALSE
  [tester.manager handleEvent:keyDownEvent(0x50) withContext:tester.eventContextMock];
  EXPECT_EQ([embedderCallbacks count], 1u);
  embedderCallbacks[0](FALSE);
  OCMVerify([tester.nextResponder keyDown:checkKeyDownEvent(0x50)]);
  [embedderCallbacks removeAllObjects];
 
  // Case: The responder reports TRUE
  [tester.manager handleEvent:keyUpEvent(0x50) withContext:tester.eventContextMock];
  EXPECT_EQ([embedderCallbacks count], 1u);
  embedderCallbacks[0](TRUE);
  // [owner.nextResponder keyUp:] should not be called, otherwise an error will be thrown.
 
  return true;
}
 
- (bool)doublePrimaryResponder {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
 
  // Send a down event first so we can send an up event later.
  [tester respondEmbedderCallsWith:false];
  [tester respondChannelCallsWith:false];
  [tester.manager handleEvent:keyDownEvent(0x50) withContext:tester.eventContextMock];
 
  NSMutableArray<FlutterAsyncKeyCallback>* embedderCallbacks =
      [NSMutableArray<FlutterAsyncKeyCallback> array];
  NSMutableArray<FlutterAsyncKeyCallback>* channelCallbacks =
      [NSMutableArray<FlutterAsyncKeyCallback> array];
  [tester recordEmbedderCallsTo:embedderCallbacks];
  [tester recordChannelCallsTo:channelCallbacks];
 
  // Case: Both responders report TRUE.
  [tester.manager handleEvent:keyUpEvent(0x50) withContext:tester.eventContextMock];
  EXPECT_EQ([embedderCallbacks count], 1u);
  EXPECT_EQ([channelCallbacks count], 1u);
  embedderCallbacks[0](TRUE);
  channelCallbacks[0](TRUE);
  EXPECT_EQ([embedderCallbacks count], 1u);
  EXPECT_EQ([channelCallbacks count], 1u);
  // [tester.nextResponder keyUp:] should not be called, otherwise an error will be thrown.
  [embedderCallbacks removeAllObjects];
  [channelCallbacks removeAllObjects];
 
  // Case: One responder reports TRUE.
  [tester respondEmbedderCallsWith:false];
  [tester respondChannelCallsWith:false];
  [tester.manager handleEvent:keyDownEvent(0x50) withContext:tester.eventContextMock];
 
  [tester recordEmbedderCallsTo:embedderCallbacks];
  [tester recordChannelCallsTo:channelCallbacks];
  [tester.manager handleEvent:keyUpEvent(0x50) withContext:tester.eventContextMock];
  EXPECT_EQ([embedderCallbacks count], 1u);
  EXPECT_EQ([channelCallbacks count], 1u);
  embedderCallbacks[0](FALSE);
  channelCallbacks[0](TRUE);
  EXPECT_EQ([embedderCallbacks count], 1u);
  EXPECT_EQ([channelCallbacks count], 1u);
  // [tester.nextResponder keyUp:] should not be called, otherwise an error will be thrown.
  [embedderCallbacks removeAllObjects];
  [channelCallbacks removeAllObjects];
 
  // Case: Both responders report FALSE.
  [tester.manager handleEvent:keyDownEvent(0x53) withContext:tester.eventContextMock];
  EXPECT_EQ([embedderCallbacks count], 1u);
  EXPECT_EQ([channelCallbacks count], 1u);
  embedderCallbacks[0](FALSE);
  channelCallbacks[0](FALSE);
  EXPECT_EQ([embedderCallbacks count], 1u);
  EXPECT_EQ([channelCallbacks count], 1u);
  OCMVerify([tester.nextResponder keyDown:checkKeyDownEvent(0x53)]);
  [embedderCallbacks removeAllObjects];
  [channelCallbacks removeAllObjects];
 
  return true;
}
 
- (bool)textInputPlugin {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
 
  // Send a down event first so we can send an up event later.
  [tester respondEmbedderCallsWith:false];
  [tester respondChannelCallsWith:false];
  [tester.manager handleEvent:keyDownEvent(0x50) withContext:tester.eventContextMock];
 
  NSMutableArray<FlutterAsyncKeyCallback>* callbacks =
      [NSMutableArray<FlutterAsyncKeyCallback> array];
  [tester recordEmbedderCallsTo:callbacks];
 
  // Case: Primary responder responds TRUE. The event shouldn't be handled by
  // the secondary responder.
  [tester respondTextInputWith:FALSE];
  [tester.manager handleEvent:keyUpEvent(0x50) withContext:tester.eventContextMock];
  EXPECT_EQ([callbacks count], 1u);
  callbacks[0](TRUE);
  // [owner.nextResponder keyUp:] should not be called, otherwise an error will be thrown.
  [callbacks removeAllObjects];
 
  // Send a down event first so we can send an up event later.
  [tester respondEmbedderCallsWith:false];
  [tester.manager handleEvent:keyDownEvent(0x50) withContext:tester.eventContextMock];
 
  // Case: Primary responder responds FALSE. The secondary responder returns
  // TRUE.
  [tester recordEmbedderCallsTo:callbacks];
  [tester respondTextInputWith:TRUE];
  [tester.manager handleEvent:keyUpEvent(0x50) withContext:tester.eventContextMock];
  EXPECT_EQ([callbacks count], 1u);
  callbacks[0](FALSE);
  // [owner.nextResponder keyUp:] should not be called, otherwise an error will be thrown.
  [callbacks removeAllObjects];
 
  // Case: Primary responder responds FALSE. The secondary responder returns FALSE.
  [tester respondTextInputWith:FALSE];
  [tester.manager handleEvent:keyDownEvent(0x50) withContext:tester.eventContextMock];
  EXPECT_EQ([callbacks count], 1u);
  callbacks[0](FALSE);
  OCMVerify([tester.nextResponder keyDown:checkKeyDownEvent(0x50)]);
  [callbacks removeAllObjects];
 
  return true;
}
 
- (bool)emptyNextResponder {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
  tester.nextResponder = nil;
 
  [tester respondEmbedderCallsWith:false];
  [tester respondChannelCallsWith:false];
  [tester respondTextInputWith:false];
  [tester.manager handleEvent:keyDownEvent(0x50) withContext:tester.eventContextMock];
 
  // Passes if no error is thrown.
  return true;
}
 
- (bool)getPressedState {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
 
  [tester respondEmbedderCallsWith:false];
  [tester respondChannelCallsWith:false];
  [tester respondTextInputWith:false];
  [tester.manager handleEvent:keyDownEvent(kVK_ANSI_A) withContext:tester.eventContextMock];
 
  NSDictionary* pressingRecords = [tester.manager getPressedState];
  EXPECT_EQ([pressingRecords count], 1u);
  EXPECT_EQ(pressingRecords[@(kPhysicalKeyA)], @(kLogicalKeyA));
 
  return true;
}
 
- (bool)keyboardChannelGetPressedState {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
 
  [tester respondEmbedderCallsWith:false];
  [tester respondChannelCallsWith:false];
  [tester respondTextInputWith:false];
  [tester.manager handleEvent:keyDownEvent(kVK_ANSI_A) withContext:tester.eventContextMock];
 
  FlutterMethodCall* getKeyboardStateMethodCall =
      [FlutterMethodCall methodCallWithMethodName:@"getKeyboardState" arguments:nil];
  NSData* getKeyboardStateMessage =
      [[FlutterStandardMethodCodec sharedInstance] encodeMethodCall:getKeyboardStateMethodCall];
  [tester sendKeyboardChannelMessage:getKeyboardStateMessage];
 
  id encodedResult = [tester lastKeyboardChannelResult];
  id decoded = [[FlutterStandardMethodCodec sharedInstance] decodeEnvelope:encodedResult];
 
  EXPECT_EQ([decoded count], 1u);
  EXPECT_EQ(decoded[@(kPhysicalKeyA)], @(kLogicalKeyA));
 
  return true;
}
 
// Regression test for https://github.com/flutter/flutter/issues/82673.
- (bool)racingConditionBetweenKeyAndText {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
 
  // Use Vietnamese IME (GoTiengViet, Telex mode) to type "uco".
 
  // The events received by the framework. The engine might receive
  // a channel message "setEditingState" from the framework.
  NSMutableArray<FlutterAsyncKeyCallback>* keyCallbacks =
      [NSMutableArray<FlutterAsyncKeyCallback> array];
  [tester recordEmbedderCallsTo:keyCallbacks];
 
  NSMutableArray<NSNumber*>* allCalls = [NSMutableArray<NSNumber*> array];
  [tester recordCallTypesTo:allCalls forTypes:(kEmbedderCall | kTextCall)];
 
  // Tap key U, which is converted by IME into a pure text message "ư".
 
  [tester.manager handleEvent:keyDownEvent(kKeyCodeEmpty, @"ư", @"ư")
                  withContext:tester.eventContextMock];
  EXPECT_EQ([keyCallbacks count], 1u);
  EXPECT_EQ([allCalls count], 1u);
  EXPECT_EQ(allCalls[0], @(kEmbedderCall));
  keyCallbacks[0](false);
  EXPECT_EQ([keyCallbacks count], 1u);
  EXPECT_EQ([allCalls count], 2u);
  EXPECT_EQ(allCalls[1], @(kTextCall));
  [keyCallbacks removeAllObjects];
  [allCalls removeAllObjects];
 
  [tester.manager handleEvent:keyUpEvent(kKeyCodeEmpty) withContext:tester.eventContextMock];
  EXPECT_EQ([keyCallbacks count], 1u);
  keyCallbacks[0](false);
  EXPECT_EQ([keyCallbacks count], 1u);
  EXPECT_EQ([allCalls count], 2u);
  [keyCallbacks removeAllObjects];
  [allCalls removeAllObjects];
 
  // Tap key O, which is converted to normal KeyO events, but the responses are
  // slow.
 
  [tester.manager handleEvent:keyDownEvent(kVK_ANSI_O, @"o", @"o")
                  withContext:tester.eventContextMock];
  [tester.manager handleEvent:keyUpEvent(kVK_ANSI_O) withContext:tester.eventContextMock];
  EXPECT_EQ([keyCallbacks count], 1u);
  EXPECT_EQ([allCalls count], 1u);
  EXPECT_EQ(allCalls[0], @(kEmbedderCall));
 
  // Tap key C, which results in two Backspace messages first - and here they
  // arrive before the key O messages are responded.
 
  [tester.manager handleEvent:keyDownEvent(kVK_Delete) withContext:tester.eventContextMock];
  [tester.manager handleEvent:keyUpEvent(kVK_Delete) withContext:tester.eventContextMock];
  EXPECT_EQ([keyCallbacks count], 1u);
  EXPECT_EQ([allCalls count], 1u);
 
  // The key O down is responded, which releases a text call (for KeyO down) and
  // an embedder call (for KeyO up) immediately.
  keyCallbacks[0](false);
  EXPECT_EQ([keyCallbacks count], 2u);
  EXPECT_EQ([allCalls count], 3u);
  EXPECT_EQ(allCalls[1], @(kTextCall));  // The order is important!
  EXPECT_EQ(allCalls[2], @(kEmbedderCall));
 
  // The key O up is responded, which releases a text call (for KeyO up) and
  // an embedder call (for Backspace down) immediately.
  keyCallbacks[1](false);
  EXPECT_EQ([keyCallbacks count], 3u);
  EXPECT_EQ([allCalls count], 5u);
  EXPECT_EQ(allCalls[3], @(kTextCall));  // The order is important!
  EXPECT_EQ(allCalls[4], @(kEmbedderCall));
 
  // Finish up callbacks.
  keyCallbacks[2](false);
  keyCallbacks[3](false);
 
  return true;
}
 
- (bool)correctLogicalKeyForLayouts {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
  tester.nextResponder = nil;
 
  std::vector<FlutterKeyEvent> events;
  [tester recordEmbedderEventsTo:&events returning:true];
  [tester respondChannelCallsWith:false];
  [tester respondTextInputWith:false];
 
  auto sendTap = [&](uint16_t keyCode, NSString* chars, NSString* charsUnmod) {
    [tester.manager handleEvent:keyDownEvent(keyCode, chars, charsUnmod)
                    withContext:tester.eventContextMock];
    [tester.manager handleEvent:keyUpEvent(keyCode) withContext:tester.eventContextMock];
  };
 
  /* US keyboard layout */
 
  sendTap(kVK_ANSI_A, @"a", @"a");  // KeyA
  VERIFY_DOWN(kLogicalKeyA, "a");
 
  sendTap(kVK_ANSI_A, @"A", @"A");  // Shift-KeyA
  VERIFY_DOWN(kLogicalKeyA, "A");
 
  sendTap(kVK_ANSI_A, @"å", @"a");  // Option-KeyA
  VERIFY_DOWN(kLogicalKeyA, "å");
 
  sendTap(kVK_ANSI_T, @"t", @"t");  // KeyT
  VERIFY_DOWN(kLogicalKeyT, "t");
 
  sendTap(kVK_ANSI_1, @"1", @"1");  // Digit1
  VERIFY_DOWN(kLogicalDigit1, "1");
 
  sendTap(kVK_ANSI_1, @"!", @"!");  // Shift-Digit1
  VERIFY_DOWN(kLogicalDigit1, "!");
 
  sendTap(kVK_ANSI_Minus, @"-", @"-");  // Minus
  VERIFY_DOWN('-', "-");
 
  sendTap(kVK_ANSI_Minus, @"=", @"=");  // Shift-Minus
  VERIFY_DOWN('=', "=");
 
  /* French keyboard layout */
  [tester setLayout:kFrenchLayout];
 
  sendTap(kVK_ANSI_A, @"q", @"q");  // KeyA
  VERIFY_DOWN(kLogicalKeyQ, "q");
 
  sendTap(kVK_ANSI_A, @"Q", @"Q");  // Shift-KeyA
  VERIFY_DOWN(kLogicalKeyQ, "Q");
 
  sendTap(kVK_ANSI_Semicolon, @"m", @"m");  // ; but prints M
  VERIFY_DOWN(kLogicalKeyM, "m");
 
  sendTap(kVK_ANSI_M, @",", @",");  // M but prints ,
  VERIFY_DOWN(',', ",");
 
  sendTap(kVK_ANSI_1, @"&", @"&");  // Digit1
  VERIFY_DOWN(kLogicalDigit1, "&");
 
  sendTap(kVK_ANSI_1, @"1", @"1");  // Shift-Digit1
  VERIFY_DOWN(kLogicalDigit1, "1");
 
  sendTap(kVK_ANSI_Minus, @")", @")");  // Minus
  VERIFY_DOWN(')', ")");
 
  sendTap(kVK_ANSI_Minus, @"°", @"°");  // Shift-Minus
  VERIFY_DOWN(L'°', "°");
 
  /* Russian keyboard layout */
  [tester setLayout:kRussianLayout];
 
  sendTap(kVK_ANSI_A, @"ф", @"ф");  // KeyA
  VERIFY_DOWN(kLogicalKeyA, "ф");
 
  sendTap(kVK_ANSI_1, @"1", @"1");  // Digit1
  VERIFY_DOWN(kLogicalDigit1, "1");
 
  sendTap(kVK_ANSI_LeftBracket, @"х", @"х");
  VERIFY_DOWN(kLogicalBracketLeft, "х");
 
  /* Khmer keyboard layout */
  // Regression test for https://github.com/flutter/flutter/issues/108729
  [tester setLayout:kKhmerLayout];
 
  sendTap(kVK_ANSI_2, @"២", @"២");  // Digit2
  VERIFY_DOWN(kLogicalDigit2, "២");
 
  return TRUE;
}
 
- (bool)shouldNotHoldStrongReferenceToDelegate {
  __strong FlutterKeyboardManager* strongKeyboardManager;
  __weak id weakDelegate;
 
  @autoreleasepool {
    id binaryMessengerMock = OCMStrictProtocolMock(@protocol(FlutterBinaryMessenger));
    OCMStub([binaryMessengerMock setMessageHandlerOnChannel:[OCMArg any]
                                       binaryMessageHandler:[OCMArg any]]);
 
    id delegateMock = OCMStrictProtocolMock(@protocol(FlutterKeyboardManagerDelegate));
    OCMStub([delegateMock binaryMessenger]).andReturn(binaryMessengerMock);
 
    FlutterKeyboardManager* keyboardManager =
        [[FlutterKeyboardManager alloc] initWithDelegate:delegateMock];
    strongKeyboardManager = keyboardManager;
    weakDelegate = delegateMock;
  }
 
  return weakDelegate == nil;
}
 
@end