FlutterKeyboardManagerUnittestsObjC Class Reference

Inheritance diagram for FlutterKeyboardManagerUnittestsObjC:

Instance Methods
(bool)	- singlePrimaryResponder
(bool)	- doublePrimaryResponder
(bool)	- textInputPlugin
(bool)	- emptyNextResponder
(bool)	- getPressedState
(bool)	- keyboardChannelGetPressedState
(bool)	- racingConditionBetweenKeyAndText
(bool)	- correctLogicalKeyForLayouts
(bool)	- shouldNotHoldStrongReferenceToViewDelegate

Detailed Description

Definition at line 420 of file FlutterKeyboardManagerTest.mm.

Method Documentation

correctLogicalKeyForLayouts

- (bool) correctLogicalKeyForLayouts

Definition at line 466 of file FlutterKeyboardManagerTest.mm.

                                    {
  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)];
    [tester.manager handleEvent:keyUpEvent(keyCode)];
  };
 
  /* 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;
}

doublePrimaryResponder

- (bool) doublePrimaryResponder

Definition at line 466 of file FlutterKeyboardManagerTest.mm.

                               {
  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)];
 
  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)];
  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)];
 
  [tester recordEmbedderCallsTo:embedderCallbacks];
  [tester recordChannelCallsTo:channelCallbacks];
  [tester.manager handleEvent:keyUpEvent(0x50)];
  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)];
  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;
}

emptyNextResponder

- (bool) emptyNextResponder

Definition at line 466 of file FlutterKeyboardManagerTest.mm.

                           {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
  tester.nextResponder = nil;
 
  [tester respondEmbedderCallsWith:false];
  [tester respondChannelCallsWith:false];
  [tester respondTextInputWith:false];
  [tester.manager handleEvent:keyDownEvent(0x50)];
 
  // Passes if no error is thrown.
  return true;
}

getPressedState

- (bool) getPressedState

Definition at line 466 of file FlutterKeyboardManagerTest.mm.

                        {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
 
  [tester respondEmbedderCallsWith:false];
  [tester respondChannelCallsWith:false];
  [tester respondTextInputWith:false];
  [tester.manager handleEvent:keyDownEvent(kVK_ANSI_A)];
 
  NSDictionary* pressingRecords = [tester.manager getPressedState];
  EXPECT_EQ([pressingRecords count], 1u);
  EXPECT_EQ(pressingRecords[@(kPhysicalKeyA)], @(kLogicalKeyA));
 
  return true;
}

keyboardChannelGetPressedState

- (bool) keyboardChannelGetPressedState

Definition at line 466 of file FlutterKeyboardManagerTest.mm.

                                       {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
 
  [tester respondEmbedderCallsWith:false];
  [tester respondChannelCallsWith:false];
  [tester respondTextInputWith:false];
  [tester.manager handleEvent:keyDownEvent(kVK_ANSI_A)];
 
  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;
}

racingConditionBetweenKeyAndText

- (bool) racingConditionBetweenKeyAndText

Definition at line 466 of file FlutterKeyboardManagerTest.mm.

                                         {
  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, @"Æ°", @"Æ°")];
  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)];
  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")];
  [tester.manager handleEvent:keyUpEvent(kVK_ANSI_O)];
  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)];
  [tester.manager handleEvent:keyUpEvent(kVK_Delete)];
  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;
}

shouldNotHoldStrongReferenceToViewDelegate

- (bool) shouldNotHoldStrongReferenceToViewDelegate

Definition at line 466 of file FlutterKeyboardManagerTest.mm.

                                                   {
  __strong FlutterKeyboardManager* strongKeyboardManager;
  __weak id weakViewDelegate;
 
  @autoreleasepool {
    id binaryMessengerMock = OCMStrictProtocolMock(@protocol(FlutterBinaryMessenger));
    OCMStub([binaryMessengerMock setMessageHandlerOnChannel:[OCMArg any]
                                       binaryMessageHandler:[OCMArg any]]);
 
    id viewDelegateMock = OCMStrictProtocolMock(@protocol(FlutterKeyboardViewDelegate));
    OCMStub([viewDelegateMock getBinaryMessenger]).andReturn(binaryMessengerMock);
    OCMStub([viewDelegateMock subscribeToKeyboardLayoutChange:[OCMArg any]]);
 
    LayoutClue layoutClue;
    OCMStub([viewDelegateMock lookUpLayoutForKeyCode:0 shift:NO])
        .ignoringNonObjectArgs()
        .andReturn(layoutClue);
    FlutterKeyboardManager* keyboardManager =
        [[FlutterKeyboardManager alloc] initWithViewDelegate:viewDelegateMock];
    strongKeyboardManager = keyboardManager;
    weakViewDelegate = viewDelegateMock;
  }
 
  return weakViewDelegate == nil;
}

singlePrimaryResponder

- (bool) singlePrimaryResponder

Definition at line 466 of file FlutterKeyboardManagerTest.mm.

                               {
  KeyboardTester* tester = [[KeyboardTester alloc] init];
  NSMutableArray<FlutterAsyncKeyCallback>* embedderCallbacks =
      [NSMutableArray<FlutterAsyncKeyCallback> array];
  [tester recordEmbedderCallsTo:embedderCallbacks];
 
  // Case: The responder reports FALSE
  [tester.manager handleEvent:keyDownEvent(0x50)];
  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)];
  EXPECT_EQ([embedderCallbacks count], 1u);
  embedderCallbacks[0](TRUE);
  // [owner.nextResponder keyUp:] should not be called, otherwise an error will be thrown.
 
  return true;
}

textInputPlugin

- (bool) textInputPlugin

Definition at line 466 of file FlutterKeyboardManagerTest.mm.

                        {
  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)];
 
  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)];
  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)];
 
  // Case: Primary responder responds FALSE. The secondary responder returns
  // TRUE.
  [tester recordEmbedderCallsTo:callbacks];
  [tester respondTextInputWith:TRUE];
  [tester.manager handleEvent:keyUpEvent(0x50)];
  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)];
  EXPECT_EQ([callbacks count], 1u);
  callbacks[0](FALSE);
  OCMVerify([tester.nextResponder keyDown:checkKeyDownEvent(0x50)]);
  [callbacks removeAllObjects];
 
  return true;
}

---

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

• shell/platform/darwin/macos/framework/Source/FlutterKeyboardManagerTest.mm