5 #include "flutter/fml/logging.h"
7 #include "flutter/shell/platform/embedder/embedder.h"
8 #include "flutter/shell/platform/embedder/test_utils/key_codes.g.h"
15 #include "flutter/shell/platform/windows/testing/engine_modifier.h"
16 #include "flutter/shell/platform/windows/testing/flutter_windows_engine_builder.h"
17 #include "flutter/shell/platform/windows/testing/mock_window_binding_handler.h"
18 #include "flutter/shell/platform/windows/testing/test_keyboard.h"
19 #include "flutter/shell/platform/windows/testing/windows_test.h"
21 #include "gmock/gmock.h"
22 #include "gtest/gtest.h"
23 #include "rapidjson/stringbuffer.h"
24 #include "rapidjson/writer.h"
31 using testing::Invoke;
32 using testing::Return;
33 using namespace ::flutter::testing::keycodes;
40 constexpr SHORT kStateMaskToggled = 0x01;
41 constexpr SHORT kStateMaskPressed = 0x80;
43 constexpr uint64_t kScanCodeBackquote = 0x29;
45 constexpr uint64_t kScanCodeKeyB = 0x30;
46 constexpr uint64_t kScanCodeKeyE = 0x12;
47 constexpr uint64_t kScanCodeKeyF = 0x21;
48 constexpr uint64_t kScanCodeKeyO = 0x18;
49 constexpr uint64_t kScanCodeKeyQ = 0x10;
50 constexpr uint64_t kScanCodeKeyW = 0x11;
51 constexpr uint64_t kScanCodeDigit1 = 0x02;
52 constexpr uint64_t kScanCodeDigit2 = 0x03;
53 constexpr uint64_t kScanCodeDigit6 = 0x07;
56 constexpr uint64_t kScanCodeControl = 0x1d;
57 constexpr uint64_t kScanCodeMetaLeft = 0x5b;
58 constexpr uint64_t kScanCodeMetaRight = 0x5c;
59 constexpr uint64_t kScanCodeAlt = 0x38;
62 constexpr uint64_t kScanCodeBracketLeft = 0x1a;
63 constexpr uint64_t kScanCodeArrowLeft = 0x4b;
64 constexpr uint64_t kScanCodeEnter = 0x1c;
65 constexpr uint64_t kScanCodeBackspace = 0x0e;
67 constexpr uint64_t kVirtualDigit1 = 0x31;
69 constexpr uint64_t kVirtualKeyB = 0x42;
70 constexpr uint64_t kVirtualKeyE = 0x45;
71 constexpr uint64_t kVirtualKeyF = 0x46;
72 constexpr uint64_t kVirtualKeyO = 0x4f;
73 constexpr uint64_t kVirtualKeyQ = 0x51;
74 constexpr uint64_t kVirtualKeyW = 0x57;
76 constexpr
bool kSynthesized =
true;
77 constexpr
bool kNotSynthesized =
false;
79 typedef UINT (*MapVirtualKeyLayout)(UINT uCode, UINT uMapType);
80 typedef std::function<UINT(UINT)> MapVirtualKeyToChar;
82 UINT LayoutDefault(UINT uCode, UINT uMapType) {
83 return MapVirtualKey(uCode, uMapType);
86 UINT LayoutFrench(UINT uCode, UINT uMapType) {
88 case MAPVK_VK_TO_CHAR:
93 return MapVirtualKey(uCode, MAPVK_VK_TO_CHAR);
96 return MapVirtualKey(uCode, uMapType);
100 class TestKeyboardManager :
public KeyboardManager {
102 explicit TestKeyboardManager(WindowDelegate* delegate)
103 : KeyboardManager(delegate) {}
105 bool DuringRedispatch() {
return during_redispatch_; }
108 void RedispatchEvent(std::unique_ptr<PendingEvent> event)
override {
109 FML_DCHECK(!during_redispatch_)
110 <<
"RedispatchEvent called while already redispatching an event";
111 during_redispatch_ =
true;
113 during_redispatch_ =
false;
117 bool during_redispatch_ =
false;
119 FML_DISALLOW_COPY_AND_ASSIGN(TestKeyboardManager);
124 struct KeyStateChange {
136 struct ExpectForgedMessage {
142 struct KeyboardChange {
145 KeyboardChange(Win32Message
message) :
type(kMessage) {
149 KeyboardChange(KeyStateChange change) :
type(kKeyStateChange) {
150 content.key_state_change = change;
153 KeyboardChange(ExpectForgedMessage forged_message)
154 :
type(kExpectForgedMessage) {
155 content.expected_forged_message = forged_message.message;
161 kExpectForgedMessage,
174 state_[virtual_key] = (
pressed ? kStateMaskPressed : 0) |
178 SHORT Get(uint32_t virtual_key) {
return state_[virtual_key]; }
181 std::map<uint32_t, SHORT> state_;
184 class MockKeyboardManagerDelegate :
public KeyboardManager::WindowDelegate,
185 protected MockMessageQueue {
187 MockKeyboardManagerDelegate(WindowBindingHandlerDelegate* view,
188 MapVirtualKeyToChar map_vk_to_char)
189 : view_(view), map_vk_to_char_(std::move(map_vk_to_char)) {
190 keyboard_manager_ = std::make_unique<TestKeyboardManager>(
this);
192 virtual ~MockKeyboardManagerDelegate() {}
201 KeyEventCallback
callback)
override {
207 void OnText(
const std::u16string&
text)
override { view_->OnText(
text); }
209 SHORT GetKeyState(
int virtual_key) {
return key_state_.Get(virtual_key); }
211 void InjectKeyboardChanges(std::vector<KeyboardChange> changes) {
213 for (
const KeyboardChange& change : changes) {
214 switch (change.type) {
215 case KeyboardChange::kMessage:
216 PushBack(&change.content.message);
222 for (
const KeyboardChange& change : changes) {
223 switch (change.type) {
224 case KeyboardChange::kMessage:
227 case KeyboardChange::kExpectForgedMessage:
228 forged_message_expectations_.push_back(ForgedMessageExpectation{
229 .message = change.content.expected_forged_message,
232 case KeyboardChange::kKeyStateChange: {
233 const KeyStateChange& state_change = change.content.key_state_change;
234 if (forged_message_expectations_.empty()) {
235 key_state_.Set(state_change.key, state_change.pressed,
236 state_change.toggled_on);
238 forged_message_expectations_.back()
239 .state_changes_afterwards.push_back(state_change);
244 FML_LOG(FATAL) <<
"Unhandled KeyboardChange type " << change.type;
249 std::list<Win32Message>& RedispatchedMessages() {
250 return redispatched_messages_;
254 BOOL Win32PeekMessage(LPMSG lpMsg,
257 UINT wRemoveMsg)
override {
258 return MockMessageQueue::Win32PeekMessage(lpMsg, wMsgFilterMin,
259 wMsgFilterMax, wRemoveMsg);
262 uint32_t Win32MapVkToChar(uint32_t virtual_key)
override {
263 return map_vk_to_char_(virtual_key);
268 LRESULT Win32SendMessage(UINT
const message,
270 LPARAM
const lparam)
override {
271 return keyboard_manager_->HandleMessage(
message, wparam, lparam)
278 UINT Win32DispatchMessage(UINT Msg, WPARAM wParam, LPARAM lParam)
override {
279 bool handled = keyboard_manager_->HandleMessage(Msg, wParam, lParam);
280 if (keyboard_manager_->DuringRedispatch()) {
281 redispatched_messages_.push_back(Win32Message{
286 EXPECT_FALSE(handled);
288 EXPECT_FALSE(forged_message_expectations_.empty());
289 ForgedMessageExpectation expectation =
290 forged_message_expectations_.front();
291 forged_message_expectations_.pop_front();
292 EXPECT_EQ(expectation.message.message, Msg);
293 EXPECT_EQ(expectation.message.wParam, wParam);
294 EXPECT_EQ(expectation.message.lParam, lParam);
295 if (expectation.message.expected_result != kWmResultDontCheck) {
296 EXPECT_EQ(expectation.message.expected_result,
297 handled ? kWmResultZero : kWmResultDefault);
299 for (
const KeyStateChange& change :
300 expectation.state_changes_afterwards) {
301 key_state_.Set(change.key, change.pressed, change.toggled_on);
308 struct ForgedMessageExpectation {
313 WindowBindingHandlerDelegate* view_;
314 std::unique_ptr<TestKeyboardManager> keyboard_manager_;
315 std::list<ForgedMessageExpectation> forged_message_expectations_;
316 MapVirtualKeyToChar map_vk_to_char_;
317 TestKeystate key_state_;
318 std::list<Win32Message> redispatched_messages_;
320 FML_DISALLOW_COPY_AND_ASSIGN(MockKeyboardManagerDelegate);
327 kKeyCallTextMethodCall,
337 class TestFlutterWindowsView :
public FlutterWindowsView {
339 TestFlutterWindowsView(std::function<
void(KeyCall)> on_key_call,
340 std::unique_ptr<WindowBindingHandler> window)
341 : on_key_call_(on_key_call), FlutterWindowsView(std::move(window)) {}
343 void OnText(
const std::u16string&
text)
override {
344 on_key_call_(KeyCall{
345 .type = KeyCall::kKeyCallOnText,
351 std::function<void(KeyCall)> on_key_call_;
353 FML_DISALLOW_COPY_AND_ASSIGN(TestFlutterWindowsView);
356 class KeyboardTester {
358 using ResponseHandler =
359 std::function<void(MockKeyResponseController::ResponseCallback)>;
361 explicit KeyboardTester(WindowsTestContext& context)
362 : callback_handler_(RespondValue(false)),
363 map_virtual_key_layout_(LayoutDefault) {
364 engine_ = GetTestEngine(context);
365 view_ = std::make_unique<TestFlutterWindowsView>(
366 [
this](KeyCall key_call) {
key_calls.push_back(key_call); },
369 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>());
370 view_->SetEngine(engine_.get());
371 window_ = std::make_unique<MockKeyboardManagerDelegate>(
372 view_.get(), [
this](UINT virtual_key) -> SHORT {
373 return map_virtual_key_layout_(virtual_key, MAPVK_VK_TO_CHAR);
377 TestFlutterWindowsView& GetView() {
return *view_; }
378 MockKeyboardManagerDelegate& GetWindow() {
return *window_; }
381 void ResetKeyboard() { EngineModifier{engine_.get()}.Restart(); }
384 void Responding(
bool response) { callback_handler_ = RespondValue(response); }
393 MockKeyResponseController::EmbedderCallbackHandler handler) {
394 callback_handler_ = std::move(handler);
397 void SetLayout(MapVirtualKeyLayout layout) {
398 map_virtual_key_layout_ = layout ==
nullptr ? LayoutDefault : layout;
401 void InjectKeyboardChanges(std::vector<KeyboardChange> changes) {
402 FML_DCHECK(window_ !=
nullptr);
403 window_->InjectKeyboardChanges(std::move(changes));
407 void InjectPlatformMessage(
const char* channel,
410 rapidjson::Document args_doc;
411 args_doc.Parse(args);
412 FML_DCHECK(!args_doc.HasParseError());
414 rapidjson::Document message_doc(rapidjson::kObjectType);
415 auto& allocator = message_doc.GetAllocator();
416 message_doc.AddMember(
"method", rapidjson::Value(method, allocator),
418 message_doc.AddMember(
"args", args_doc, allocator);
420 rapidjson::StringBuffer buffer;
421 rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
422 message_doc.Accept(writer);
424 std::unique_ptr<std::vector<uint8_t>> data =
426 FlutterPlatformMessageResponseHandle response_handle;
427 const FlutterPlatformMessage
message = {
428 sizeof(FlutterPlatformMessage),
434 view_->GetEngine()->HandlePlatformMessage(&
message);
439 size_t RedispatchedMessageCountAndClear() {
440 auto& messages = window_->RedispatchedMessages();
441 size_t count = messages.size();
446 void clear_key_calls() {
448 if (key_call.type == KeyCall::kKeyCallOnKey &&
449 key_call.key_event.character !=
nullptr) {
450 delete[] key_call.key_event.character;
459 std::unique_ptr<FlutterWindowsEngine> engine_;
460 std::unique_ptr<TestFlutterWindowsView> view_;
461 std::unique_ptr<MockKeyboardManagerDelegate> window_;
462 MockKeyResponseController::EmbedderCallbackHandler callback_handler_;
463 MapVirtualKeyLayout map_virtual_key_layout_;
468 std::unique_ptr<FlutterWindowsEngine> GetTestEngine(
469 WindowsTestContext& context) {
470 FlutterWindowsEngineBuilder builder{context};
472 builder.SetCreateKeyboardHandlerCallbacks(
473 [
this](
int virtual_key) -> SHORT {
476 return window_ ? window_->GetKeyState(virtual_key) : 0;
478 [
this](UINT virtual_key,
bool extended) -> SHORT {
479 return map_virtual_key_layout_(
480 virtual_key,
extended ? MAPVK_VK_TO_VSC_EX : MAPVK_VK_TO_VSC);
483 auto engine = builder.Build();
485 EngineModifier modifier(engine.get());
487 auto key_response_controller =
488 std::make_shared<MockKeyResponseController>();
489 key_response_controller->SetEmbedderResponse(
491 const FlutterKeyEvent* event,
492 MockKeyResponseController::ResponseCallback
callback) {
493 FlutterKeyEvent clone_event = *event;
494 clone_event.character =
event->character ==
nullptr
496 : clone_string(event->character);
498 .type = KeyCall::kKeyCallOnKey,
499 .key_event = clone_event,
503 key_response_controller->SetTextInputResponse(
505 key_calls](std::unique_ptr<rapidjson::Document> document) {
506 rapidjson::StringBuffer buffer;
507 rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
508 document->Accept(writer);
510 .type = KeyCall::kKeyCallTextMethodCall,
511 .text_method_call = buffer.GetString(),
514 MockEmbedderApiForKeyboard(modifier, key_response_controller);
521 static MockKeyResponseController::EmbedderCallbackHandler RespondValue(
523 return [value](
const FlutterKeyEvent* event,
524 MockKeyResponseController::ResponseCallback
callback) {
530 FML_DISALLOW_COPY_AND_ASSIGN(KeyboardTester);
533 class KeyboardTest :
public WindowsTest {
535 KeyboardTest() =
default;
536 virtual ~KeyboardTest() =
default;
539 FML_DISALLOW_COPY_AND_ASSIGN(KeyboardTest);
547 #define EXPECT_CALL_IS_EVENT(_key_call, ...) \
548 EXPECT_EQ(_key_call.type, KeyCall::kKeyCallOnKey); \
549 EXPECT_EVENT_EQUALS(_key_call.key_event, __VA_ARGS__);
551 #define EXPECT_CALL_IS_TEXT(_key_call, u16_string) \
552 EXPECT_EQ(_key_call.type, KeyCall::kKeyCallOnText); \
553 EXPECT_EQ(_key_call.text, u16_string);
555 #define EXPECT_CALL_IS_TEXT_METHOD_CALL(_key_call, json_string) \
556 EXPECT_EQ(_key_call.type, KeyCall::kKeyCallTextMethodCall); \
557 EXPECT_STREQ(_key_call.text_method_call.c_str(), json_string);
559 TEST_F(KeyboardTest, LowerCaseAHandled) {
560 KeyboardTester tester{GetContext()};
561 tester.Responding(
true);
566 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
572 EXPECT_EQ(tester.key_calls.size(), 1);
574 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
575 tester.clear_key_calls();
576 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
579 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
583 EXPECT_EQ(tester.key_calls.size(), 1);
585 kPhysicalKeyA, kLogicalKeyA,
"", kNotSynthesized);
586 tester.clear_key_calls();
587 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
590 TEST_F(KeyboardTest, LowerCaseAUnhandled) {
591 KeyboardTester tester{GetContext()};
592 tester.Responding(
false);
597 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
603 EXPECT_EQ(tester.key_calls.size(), 2);
605 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
607 tester.clear_key_calls();
608 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
611 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
615 EXPECT_EQ(tester.key_calls.size(), 1);
617 kPhysicalKeyA, kLogicalKeyA,
"", kNotSynthesized);
618 tester.clear_key_calls();
619 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
623 KeyboardTester tester{GetContext()};
624 tester.Responding(
true);
629 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
630 WmKeyDownInfo{VK_LEFT, kScanCodeArrowLeft, kExtended, kWasUp}.Build(
633 EXPECT_EQ(tester.key_calls.size(), 1);
635 kPhysicalArrowLeft, kLogicalArrowLeft,
"",
637 tester.clear_key_calls();
638 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
641 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
642 WmKeyUpInfo{VK_LEFT, kScanCodeArrowLeft, kExtended}.Build(
645 EXPECT_EQ(tester.key_calls.size(), 1);
647 kPhysicalArrowLeft, kLogicalArrowLeft,
"",
649 tester.clear_key_calls();
650 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
653 TEST_F(KeyboardTest, ArrowLeftUnhandled) {
654 KeyboardTester tester{GetContext()};
655 tester.Responding(
false);
660 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
661 WmKeyDownInfo{VK_LEFT, kScanCodeArrowLeft, kExtended, kWasUp}.Build(
664 EXPECT_EQ(tester.key_calls.size(), 1);
666 kPhysicalArrowLeft, kLogicalArrowLeft,
"",
668 tester.clear_key_calls();
669 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
672 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
673 WmKeyUpInfo{VK_LEFT, kScanCodeArrowLeft, kExtended}.Build(
676 EXPECT_EQ(tester.key_calls.size(), 1);
678 kPhysicalArrowLeft, kLogicalArrowLeft,
"",
680 tester.clear_key_calls();
681 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
684 TEST_F(KeyboardTest, ShiftLeftUnhandled) {
685 KeyboardTester tester{GetContext()};
686 tester.Responding(
false);
691 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
692 KeyStateChange{VK_LSHIFT,
true,
false},
696 EXPECT_EQ(tester.key_calls.size(), 1);
698 kPhysicalShiftLeft, kLogicalShiftLeft,
"",
700 tester.clear_key_calls();
701 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
704 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
708 EXPECT_EQ(tester.key_calls.size(), 1);
710 kPhysicalShiftLeft, kLogicalShiftLeft,
"",
712 tester.clear_key_calls();
713 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
716 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
717 KeyStateChange{VK_LSHIFT,
false,
true},
721 EXPECT_EQ(tester.key_calls.size(), 1);
723 kPhysicalShiftLeft, kLogicalShiftLeft,
"",
725 tester.clear_key_calls();
726 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
729 TEST_F(KeyboardTest, ShiftRightUnhandled) {
730 KeyboardTester tester{GetContext()};
731 tester.Responding(
false);
736 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
737 KeyStateChange{VK_RSHIFT,
true,
false},
741 EXPECT_EQ(tester.key_calls.size(), 1);
743 kPhysicalShiftRight, kLogicalShiftRight,
"",
745 tester.clear_key_calls();
746 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
749 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
750 KeyStateChange{VK_RSHIFT,
false,
true},
754 EXPECT_EQ(tester.key_calls.size(), 1);
756 kPhysicalShiftRight, kLogicalShiftRight,
"",
758 tester.clear_key_calls();
759 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
762 TEST_F(KeyboardTest, CtrlLeftUnhandled) {
763 KeyboardTester tester{GetContext()};
764 tester.Responding(
false);
769 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
770 KeyStateChange{VK_LCONTROL,
true,
false},
771 WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
774 EXPECT_EQ(tester.key_calls.size(), 1);
776 kPhysicalControlLeft, kLogicalControlLeft,
"",
778 tester.clear_key_calls();
779 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
782 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
783 KeyStateChange{VK_LCONTROL,
false,
true},
784 WmKeyUpInfo{VK_SHIFT, kScanCodeControl, kNotExtended}.Build(
787 EXPECT_EQ(tester.key_calls.size(), 1);
789 kPhysicalControlLeft, kLogicalControlLeft,
"",
791 tester.clear_key_calls();
792 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
795 TEST_F(KeyboardTest, CtrlRightUnhandled) {
796 KeyboardTester tester{GetContext()};
797 tester.Responding(
false);
802 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
803 KeyStateChange{VK_RCONTROL,
true,
false},
804 WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kExtended, kWasUp}.Build(
807 EXPECT_EQ(tester.key_calls.size(), 1);
809 kPhysicalControlRight, kLogicalControlRight,
"",
811 tester.clear_key_calls();
812 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
815 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
816 KeyStateChange{VK_RCONTROL,
false,
true},
817 WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kExtended}.Build(
820 EXPECT_EQ(tester.key_calls.size(), 1);
822 kPhysicalControlRight, kLogicalControlRight,
"",
824 tester.clear_key_calls();
825 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
829 KeyboardTester tester{GetContext()};
830 tester.Responding(
false);
835 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
836 KeyStateChange{VK_LMENU,
true,
false},
837 WmSysKeyDownInfo{VK_MENU, kScanCodeAlt, kNotExtended, kWasUp}.Build(
840 EXPECT_EQ(tester.key_calls.size(), 1);
842 kPhysicalAltLeft, kLogicalAltLeft,
"", kNotSynthesized);
843 tester.clear_key_calls();
845 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
848 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
849 KeyStateChange{VK_LMENU,
false,
true},
850 WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kNotExtended}.Build(
853 EXPECT_EQ(tester.key_calls.size(), 1);
855 kPhysicalAltLeft, kLogicalAltLeft,
"", kNotSynthesized);
856 tester.clear_key_calls();
858 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
861 TEST_F(KeyboardTest, AltRightUnhandled) {
862 KeyboardTester tester{GetContext()};
863 tester.Responding(
false);
868 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
869 KeyStateChange{VK_RMENU,
true,
false},
870 WmSysKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
873 EXPECT_EQ(tester.key_calls.size(), 1);
875 kPhysicalAltRight, kLogicalAltRight,
"",
877 tester.clear_key_calls();
879 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
882 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
883 KeyStateChange{VK_RMENU,
false,
true},
884 WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
887 EXPECT_EQ(tester.key_calls.size(), 1);
889 kPhysicalAltRight, kLogicalAltRight,
"",
891 tester.clear_key_calls();
893 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
896 TEST_F(KeyboardTest, MetaLeftUnhandled) {
897 KeyboardTester tester{GetContext()};
898 tester.Responding(
false);
903 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
904 KeyStateChange{VK_LWIN,
true,
false},
905 WmKeyDownInfo{VK_LWIN, kScanCodeMetaLeft, kExtended, kWasUp}.Build(
908 EXPECT_EQ(tester.key_calls.size(), 1);
910 kPhysicalMetaLeft, kLogicalMetaLeft,
"",
912 tester.clear_key_calls();
913 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
916 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
917 KeyStateChange{VK_LWIN,
false,
true},
918 WmKeyUpInfo{VK_LWIN, kScanCodeMetaLeft, kExtended}.Build(kWmResultZero)});
920 EXPECT_EQ(tester.key_calls.size(), 1);
922 kPhysicalMetaLeft, kLogicalMetaLeft,
"",
924 tester.clear_key_calls();
925 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
928 TEST_F(KeyboardTest, MetaRightUnhandled) {
929 KeyboardTester tester{GetContext()};
930 tester.Responding(
false);
935 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
936 KeyStateChange{VK_RWIN,
true,
false},
937 WmKeyDownInfo{VK_RWIN, kScanCodeMetaRight, kExtended, kWasUp}.Build(
940 EXPECT_EQ(tester.key_calls.size(), 1);
942 kPhysicalMetaRight, kLogicalMetaRight,
"",
944 tester.clear_key_calls();
945 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
948 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
949 KeyStateChange{VK_RWIN,
false,
true},
950 WmKeyUpInfo{VK_RWIN, kScanCodeMetaRight, kExtended}.Build(
953 EXPECT_EQ(tester.key_calls.size(), 1);
955 kPhysicalMetaRight, kLogicalMetaRight,
"",
957 tester.clear_key_calls();
958 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
963 KeyboardTester tester{GetContext()};
964 tester.Responding(
true);
967 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
974 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
977 WmCharInfo{
'a',
kScanCodeKeyA, kNotExtended, kWasDown}.Build(
980 EXPECT_EQ(tester.key_calls.size(), 2);
982 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
984 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
985 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
991 TEST_F(KeyboardTest, RestartClearsKeyboardState) {
992 KeyboardTester tester{GetContext()};
993 tester.Responding(
true);
996 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1003 tester.ResetKeyboard();
1007 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1010 WmCharInfo{
'a',
kScanCodeKeyA, kNotExtended, kWasDown}.Build(
1013 EXPECT_EQ(tester.key_calls.size(), 2);
1015 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
1017 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
1018 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
1024 KeyboardTester tester{GetContext()};
1025 tester.Responding(
false);
1030 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1031 KeyStateChange{VK_LSHIFT,
true,
true},
1035 EXPECT_EQ(tester.key_calls.size(), 1);
1037 kPhysicalShiftLeft, kLogicalShiftLeft,
"",
1039 tester.clear_key_calls();
1040 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1043 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1049 EXPECT_EQ(tester.key_calls.size(), 2);
1051 kPhysicalKeyA, kLogicalKeyA,
"A", kNotSynthesized);
1053 tester.clear_key_calls();
1054 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1057 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1058 KeyStateChange{VK_LSHIFT,
false,
true},
1062 EXPECT_EQ(tester.key_calls.size(), 1);
1064 kPhysicalShiftLeft, kLogicalShiftLeft,
"",
1066 tester.clear_key_calls();
1067 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1070 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1074 EXPECT_EQ(tester.key_calls.size(), 1);
1076 kPhysicalKeyA, kLogicalKeyA,
"", kNotSynthesized);
1077 tester.clear_key_calls();
1078 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1084 KeyboardTester tester{GetContext()};
1085 tester.Responding(
false);
1090 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1091 KeyStateChange{VK_LCONTROL,
true,
true},
1092 WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1095 EXPECT_EQ(tester.key_calls.size(), 1);
1097 kPhysicalControlLeft, kLogicalControlLeft,
"",
1099 tester.clear_key_calls();
1100 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1103 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1106 WmCharInfo{0x01,
kScanCodeKeyA, kNotExtended, kWasUp}.Build(
1109 EXPECT_EQ(tester.key_calls.size(), 1);
1111 kPhysicalKeyA, kLogicalKeyA,
"", kNotSynthesized);
1112 tester.clear_key_calls();
1113 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1116 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1120 EXPECT_EQ(tester.key_calls.size(), 1);
1122 kPhysicalKeyA, kLogicalKeyA,
"", kNotSynthesized);
1123 tester.clear_key_calls();
1124 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1127 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1128 KeyStateChange{VK_LCONTROL,
false,
true},
1129 WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1132 EXPECT_EQ(tester.key_calls.size(), 1);
1134 kPhysicalControlLeft, kLogicalControlLeft,
"",
1136 tester.clear_key_calls();
1137 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1142 KeyboardTester tester{GetContext()};
1143 tester.Responding(
false);
1148 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1149 KeyStateChange{VK_LCONTROL,
true,
true},
1150 WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1153 EXPECT_EQ(tester.key_calls.size(), 1);
1155 kPhysicalControlLeft, kLogicalControlLeft,
"",
1157 tester.clear_key_calls();
1158 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1161 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1162 WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
1163 .Build(kWmResultZero)});
1165 EXPECT_EQ(tester.key_calls.size(), 1);
1167 kPhysicalDigit1, kLogicalDigit1,
"", kNotSynthesized);
1168 tester.clear_key_calls();
1169 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1172 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1173 WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
1176 EXPECT_EQ(tester.key_calls.size(), 1);
1178 kPhysicalDigit1, kLogicalDigit1,
"", kNotSynthesized);
1179 tester.clear_key_calls();
1180 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1183 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1184 KeyStateChange{VK_LCONTROL,
false,
true},
1185 WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1188 EXPECT_EQ(tester.key_calls.size(), 1);
1190 kPhysicalControlLeft, kLogicalControlLeft,
"",
1192 tester.clear_key_calls();
1193 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1199 KeyboardTester tester{GetContext()};
1200 tester.Responding(
false);
1202 tester.SetLayout(LayoutFrench);
1205 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1206 WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
1207 .Build(kWmResultZero),
1208 WmCharInfo{
'&', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
1211 EXPECT_EQ(tester.key_calls.size(), 2);
1213 kPhysicalDigit1, kLogicalDigit1,
"&", kNotSynthesized);
1215 tester.clear_key_calls();
1216 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1219 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1220 WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
1223 EXPECT_EQ(tester.key_calls.size(), 1);
1225 kPhysicalDigit1, kLogicalDigit1,
"", kNotSynthesized);
1226 tester.clear_key_calls();
1227 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1232 KeyboardTester tester{GetContext()};
1233 tester.Responding(
false);
1238 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1239 KeyStateChange{VK_LCONTROL,
true,
true},
1240 WmKeyDownInfo{VK_LCONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1242 KeyStateChange{VK_RMENU,
true,
true},
1243 WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
1246 EXPECT_EQ(tester.key_calls.size(), 2);
1248 kPhysicalControlLeft, kLogicalControlLeft,
"",
1251 kPhysicalAltRight, kLogicalAltRight,
"",
1253 tester.clear_key_calls();
1254 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1257 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1258 WmKeyDownInfo{kVirtualKeyQ, kScanCodeKeyQ, kNotExtended, kWasUp}.Build(
1260 WmCharInfo{
'@', kScanCodeKeyQ, kNotExtended, kWasUp}.Build(
1263 EXPECT_EQ(tester.key_calls.size(), 2);
1265 kPhysicalKeyQ, kLogicalKeyQ,
"@", kNotSynthesized);
1267 tester.clear_key_calls();
1268 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1271 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1272 WmKeyUpInfo{kVirtualKeyQ, kScanCodeKeyQ, kNotExtended}.Build(
1275 EXPECT_EQ(tester.key_calls.size(), 1);
1277 kPhysicalKeyQ, kLogicalKeyQ,
"", kNotSynthesized);
1278 tester.clear_key_calls();
1279 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1284 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1285 KeyStateChange{VK_LCONTROL,
false,
true},
1286 ExpectForgedMessage{
1287 WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1289 KeyStateChange{VK_RMENU,
false,
true},
1290 WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
1291 kWmResultDefault)});
1293 EXPECT_EQ(tester.key_calls.size(), 2);
1295 kPhysicalControlLeft, kLogicalControlLeft,
"",
1298 kPhysicalAltRight, kLogicalAltRight,
"",
1300 tester.clear_key_calls();
1302 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1319 KeyboardTester tester{GetContext()};
1320 tester.Responding(
false);
1326 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1327 KeyStateChange{VK_LCONTROL,
true,
true},
1328 WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1330 KeyStateChange{VK_RMENU,
true,
true},
1331 WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
1334 EXPECT_EQ(tester.key_calls.size(), 2);
1336 kPhysicalControlLeft, kLogicalControlLeft,
"",
1339 kPhysicalAltRight, kLogicalAltRight,
"",
1341 tester.clear_key_calls();
1342 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1347 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1348 KeyStateChange{VK_LCONTROL,
false,
true},
1349 ExpectForgedMessage{
1350 WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1352 KeyStateChange{VK_RMENU,
false,
true},
1353 WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
1354 kWmResultDefault)});
1355 EXPECT_EQ(tester.key_calls.size(), 2);
1357 kPhysicalControlLeft, kLogicalControlLeft,
"",
1360 kPhysicalAltRight, kLogicalAltRight,
"",
1362 tester.clear_key_calls();
1364 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1368 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1369 KeyStateChange{VK_LCONTROL,
true,
false},
1370 WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
1372 KeyStateChange{VK_RMENU,
true,
true},
1373 WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
1376 EXPECT_EQ(tester.key_calls.size(), 2);
1378 kPhysicalControlLeft, kLogicalControlLeft,
"",
1381 kPhysicalAltRight, kLogicalAltRight,
"",
1383 tester.clear_key_calls();
1384 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1389 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1390 KeyStateChange{VK_LCONTROL,
false,
false},
1391 ExpectForgedMessage{
1392 WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1394 KeyStateChange{VK_RMENU,
false,
false},
1395 WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
1396 kWmResultDefault)});
1397 EXPECT_EQ(tester.key_calls.size(), 2);
1399 kPhysicalControlLeft, kLogicalControlLeft,
"",
1402 kPhysicalAltRight, kLogicalAltRight,
"",
1404 tester.clear_key_calls();
1406 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1409 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1410 WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
1412 EXPECT_EQ(tester.key_calls.size(), 1);
1415 tester.clear_key_calls();
1416 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
1422 KeyboardTester tester{GetContext()};
1423 tester.Responding(
false);
1425 tester.SetLayout(LayoutFrench);
1428 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1429 WmKeyDownInfo{0xDD, kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1431 WmDeadCharInfo{
'^', kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1434 EXPECT_EQ(tester.key_calls.size(), 1);
1436 kPhysicalBracketLeft, kLogicalBracketRight,
"^",
1438 tester.clear_key_calls();
1439 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1442 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1443 WmKeyUpInfo{0xDD, kScanCodeBracketLeft, kNotExtended}.Build(
1446 EXPECT_EQ(tester.key_calls.size(), 1);
1448 kPhysicalBracketLeft, kLogicalBracketRight,
"",
1450 tester.clear_key_calls();
1451 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1454 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1455 WmKeyDownInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1457 WmCharInfo{0xEA, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1460 EXPECT_EQ(tester.key_calls.size(), 2);
1462 kPhysicalKeyE, kLogicalKeyE,
"ê", kNotSynthesized);
1464 tester.clear_key_calls();
1465 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1468 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1469 WmKeyUpInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended}.Build(
1472 EXPECT_EQ(tester.key_calls.size(), 1);
1474 kPhysicalKeyE, kLogicalKeyE,
"", kNotSynthesized);
1475 tester.clear_key_calls();
1476 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1484 TEST_F(KeyboardTest, DeadKeyWithoutDeadMaskThatCombines) {
1485 KeyboardTester tester{GetContext()};
1486 tester.Responding(
false);
1489 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1490 KeyStateChange{VK_LSHIFT,
true,
true},
1494 EXPECT_EQ(tester.key_calls.size(), 1);
1496 kPhysicalShiftLeft, kLogicalShiftLeft,
"",
1498 tester.clear_key_calls();
1499 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1502 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1503 WmKeyDownInfo{
'6', kScanCodeDigit6, kNotExtended, kWasUp}.Build(
1505 WmDeadCharInfo{
'^', kScanCodeDigit6, kNotExtended, kWasUp}.Build(
1508 EXPECT_EQ(tester.key_calls.size(), 1);
1510 kPhysicalDigit6, kLogicalDigit6,
"6", kNotSynthesized);
1511 tester.clear_key_calls();
1512 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1515 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1516 WmKeyUpInfo{
'6', kScanCodeDigit6, kNotExtended}.Build(kWmResultZero)});
1518 EXPECT_EQ(tester.key_calls.size(), 1);
1520 kPhysicalDigit6, kLogicalDigit6,
"", kNotSynthesized);
1521 tester.clear_key_calls();
1522 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1525 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1526 KeyStateChange{VK_LSHIFT,
false,
true},
1530 EXPECT_EQ(tester.key_calls.size(), 1);
1532 kPhysicalShiftLeft, kLogicalShiftLeft,
"",
1534 tester.clear_key_calls();
1535 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1538 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1539 WmKeyDownInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1541 WmCharInfo{0xEA, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
1544 EXPECT_EQ(tester.key_calls.size(), 2);
1546 kPhysicalKeyE, kLogicalKeyE,
"ê", kNotSynthesized);
1548 tester.clear_key_calls();
1549 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1552 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1553 WmKeyUpInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended}.Build(
1556 EXPECT_EQ(tester.key_calls.size(), 1);
1558 kPhysicalKeyE, kLogicalKeyE,
"", kNotSynthesized);
1559 tester.clear_key_calls();
1560 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1565 TEST_F(KeyboardTest, DeadKeyThatDoesNotCombine) {
1566 KeyboardTester tester{GetContext()};
1567 tester.Responding(
false);
1569 tester.SetLayout(LayoutFrench);
1572 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1573 WmKeyDownInfo{0xDD, kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1575 WmDeadCharInfo{
'^', kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
1578 EXPECT_EQ(tester.key_calls.size(), 1);
1580 kPhysicalBracketLeft, kLogicalBracketRight,
"^",
1582 tester.clear_key_calls();
1583 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1586 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1587 WmKeyUpInfo{0xDD, kScanCodeBracketLeft, kNotExtended}.Build(
1590 EXPECT_EQ(tester.key_calls.size(), 1);
1592 kPhysicalBracketLeft, kLogicalBracketRight,
"",
1594 tester.clear_key_calls();
1595 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1598 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1599 WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
1600 .Build(kWmResultZero),
1601 WmCharInfo{
'^', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
1603 WmCharInfo{
'&', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
1606 EXPECT_EQ(tester.key_calls.size(), 3);
1608 kPhysicalDigit1, kLogicalDigit1,
"^", kNotSynthesized);
1611 tester.clear_key_calls();
1617 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1620 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1621 WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
1624 EXPECT_EQ(tester.key_calls.size(), 1);
1626 kPhysicalDigit1, kLogicalDigit1,
"", kNotSynthesized);
1627 tester.clear_key_calls();
1628 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1634 TEST_F(KeyboardTest, DeadKeyTwiceThenLetter) {
1635 KeyboardTester tester{GetContext()};
1636 tester.Responding(
false);
1641 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1642 WmKeyDownInfo{0xC0, kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1644 WmDeadCharInfo{
'`', kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1647 EXPECT_EQ(tester.key_calls.size(), 1);
1649 kPhysicalBackquote, kLogicalBackquote,
"`",
1651 tester.clear_key_calls();
1652 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1655 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1656 WmKeyUpInfo{0xC0, kScanCodeBackquote, kNotExtended}.Build(
1659 EXPECT_EQ(tester.key_calls.size(), 1);
1661 kPhysicalBackquote, kLogicalBackquote,
"",
1663 tester.clear_key_calls();
1664 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1668 std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
1669 tester.LateResponding(
1670 [&recorded_callbacks](
1671 const FlutterKeyEvent* event,
1672 MockKeyResponseController::ResponseCallback
callback) {
1673 recorded_callbacks.push_back(
callback);
1676 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1677 WmKeyDownInfo{0xC0, kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1679 WmCharInfo{
'`', kScanCodeBackquote, kNotExtended, kWasUp, kBeingReleased,
1680 kNoContext, 1,
true}
1681 .Build(kWmResultZero),
1682 WmCharInfo{
'`', kScanCodeBackquote, kNotExtended, kWasUp}.Build(
1685 EXPECT_EQ(recorded_callbacks.size(), 1);
1686 EXPECT_EQ(tester.key_calls.size(), 1);
1688 kPhysicalBackquote, kLogicalBackquote,
"`",
1690 tester.clear_key_calls();
1692 recorded_callbacks.front()(
false);
1693 EXPECT_EQ(tester.key_calls.size(), 2);
1696 tester.clear_key_calls();
1700 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
1702 tester.Responding(
false);
1705 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1706 WmKeyUpInfo{0xC0, kScanCodeBackquote, kNotExtended}.Build(
1709 EXPECT_EQ(tester.key_calls.size(), 1);
1711 kPhysicalBackquote, kLogicalBackquote,
"",
1713 tester.clear_key_calls();
1714 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1719 KeyboardTester tester{GetContext()};
1720 tester.Responding(
false);
1726 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1727 WmKeyDownInfo{kVirtualKeyW, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
1729 WmCharInfo{0xd800, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
1731 WmCharInfo{0xdf45, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
1734 const char* st = tester.key_calls[0].key_event.character;
1736 EXPECT_EQ(tester.key_calls.size(), 2);
1738 kPhysicalKeyW, kLogicalKeyW,
"𐍅", kNotSynthesized);
1740 tester.clear_key_calls();
1741 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 3);
1744 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1745 WmKeyUpInfo{kVirtualKeyW, kScanCodeKeyW, kNotExtended}.Build(
1748 EXPECT_EQ(tester.key_calls.size(), 1);
1750 kPhysicalKeyW, kLogicalKeyW,
"", kNotSynthesized);
1751 tester.clear_key_calls();
1752 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1756 KeyboardTester tester{GetContext()};
1757 tester.Responding(
false);
1760 Win32Message event1 =
1761 WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
1763 Win32Message event2 =
1764 WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
1768 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1769 KeyStateChange{VK_LSHIFT,
true,
true}, event1});
1770 EXPECT_EQ(tester.key_calls.size(), 2);
1772 kPhysicalShiftLeft, kLogicalShiftLeft,
"", kSynthesized);
1773 tester.clear_key_calls();
1774 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1776 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1777 KeyStateChange{VK_LSHIFT,
false,
true}, event2});
1778 EXPECT_EQ(tester.key_calls.size(), 2);
1780 kPhysicalShiftLeft, kLogicalShiftLeft,
"", kSynthesized);
1781 tester.clear_key_calls();
1782 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1785 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1786 KeyStateChange{VK_RSHIFT,
true,
true}, event1});
1787 EXPECT_EQ(tester.key_calls.size(), 2);
1789 kPhysicalShiftRight, kLogicalShiftRight,
"",
1791 tester.clear_key_calls();
1792 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1794 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1795 KeyStateChange{VK_RSHIFT,
false,
true}, event2});
1796 EXPECT_EQ(tester.key_calls.size(), 2);
1798 kPhysicalShiftRight, kLogicalShiftRight,
"",
1800 tester.clear_key_calls();
1801 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1804 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1805 KeyStateChange{VK_LCONTROL,
true,
true}, event1});
1806 EXPECT_EQ(tester.key_calls.size(), 2);
1808 kPhysicalControlLeft, kLogicalControlLeft,
"",
1810 tester.clear_key_calls();
1811 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1813 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1814 KeyStateChange{VK_LCONTROL,
false,
true}, event2});
1815 EXPECT_EQ(tester.key_calls.size(), 2);
1817 kPhysicalControlLeft, kLogicalControlLeft,
"",
1819 tester.clear_key_calls();
1820 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1823 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1824 KeyStateChange{VK_RCONTROL,
true,
true}, event1});
1825 EXPECT_EQ(tester.key_calls.size(), 2);
1827 kPhysicalControlRight, kLogicalControlRight,
"",
1829 tester.clear_key_calls();
1830 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1832 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1833 KeyStateChange{VK_RCONTROL,
false,
true}, event2});
1834 EXPECT_EQ(tester.key_calls.size(), 2);
1836 kPhysicalControlRight, kLogicalControlRight,
"",
1838 tester.clear_key_calls();
1839 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1842 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1843 KeyStateChange{VK_LMENU,
true,
true}, event1});
1844 EXPECT_EQ(tester.key_calls.size(), 2);
1846 kPhysicalAltLeft, kLogicalAltLeft,
"", kSynthesized);
1847 tester.clear_key_calls();
1848 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1850 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1851 KeyStateChange{VK_LMENU,
false,
true}, event2});
1852 EXPECT_EQ(tester.key_calls.size(), 2);
1854 kPhysicalAltLeft, kLogicalAltLeft,
"", kSynthesized);
1855 tester.clear_key_calls();
1856 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1859 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1860 KeyStateChange{VK_RMENU,
true,
true}, event1});
1861 EXPECT_EQ(tester.key_calls.size(), 2);
1863 kPhysicalAltRight, kLogicalAltRight,
"", kSynthesized);
1864 tester.clear_key_calls();
1865 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1867 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1868 KeyStateChange{VK_RMENU,
false,
true}, event2});
1869 EXPECT_EQ(tester.key_calls.size(), 2);
1871 kPhysicalAltRight, kLogicalAltRight,
"", kSynthesized);
1872 tester.clear_key_calls();
1873 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1876 tester.InjectKeyboardChanges(
1877 std::vector<KeyboardChange>{KeyStateChange{VK_LWIN,
true,
true}, event1});
1878 EXPECT_EQ(tester.key_calls.size(), 2);
1880 kPhysicalMetaLeft, kLogicalMetaLeft,
"", kSynthesized);
1881 tester.clear_key_calls();
1882 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1884 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1885 KeyStateChange{VK_LWIN,
false,
true}, event2});
1886 EXPECT_EQ(tester.key_calls.size(), 2);
1888 kPhysicalMetaLeft, kLogicalMetaLeft,
"", kSynthesized);
1889 tester.clear_key_calls();
1890 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1893 tester.InjectKeyboardChanges(
1894 std::vector<KeyboardChange>{KeyStateChange{VK_RWIN,
true,
true}, event1});
1895 EXPECT_EQ(tester.key_calls.size(), 2);
1897 kPhysicalMetaRight, kLogicalMetaRight,
"", kSynthesized);
1898 tester.clear_key_calls();
1899 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1901 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1902 KeyStateChange{VK_RWIN,
false,
true}, event2});
1903 EXPECT_EQ(tester.key_calls.size(), 2);
1905 kPhysicalMetaRight, kLogicalMetaRight,
"", kSynthesized);
1906 tester.clear_key_calls();
1907 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1911 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1912 KeyStateChange{VK_CAPITAL,
false,
true}, event1});
1913 EXPECT_EQ(tester.key_calls.size(), 3);
1915 kPhysicalCapsLock, kLogicalCapsLock,
"", kSynthesized);
1917 kPhysicalCapsLock, kLogicalCapsLock,
"", kSynthesized);
1918 tester.clear_key_calls();
1919 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1921 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1922 KeyStateChange{VK_CAPITAL,
false,
false}, event2});
1923 EXPECT_EQ(tester.key_calls.size(), 3);
1925 kPhysicalCapsLock, kLogicalCapsLock,
"", kSynthesized);
1927 kPhysicalCapsLock, kLogicalCapsLock,
"", kSynthesized);
1928 tester.clear_key_calls();
1929 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1932 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1933 KeyStateChange{VK_SCROLL,
true,
true}, event1});
1934 EXPECT_EQ(tester.key_calls.size(), 2);
1936 kPhysicalScrollLock, kLogicalScrollLock,
"",
1938 tester.clear_key_calls();
1939 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1941 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1942 KeyStateChange{VK_SCROLL,
true,
false}, event2});
1943 EXPECT_EQ(tester.key_calls.size(), 3);
1945 kPhysicalScrollLock, kLogicalScrollLock,
"",
1948 kPhysicalScrollLock, kLogicalScrollLock,
"",
1950 tester.clear_key_calls();
1951 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1954 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1955 KeyStateChange{VK_NUMLOCK,
true,
false}, event1});
1960 EXPECT_EQ(tester.key_calls.size(), 2);
1962 kPhysicalNumLock, kLogicalNumLock,
"", kSynthesized);
1963 tester.clear_key_calls();
1964 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1966 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1967 KeyStateChange{VK_NUMLOCK,
false,
true}, event2});
1968 EXPECT_EQ(tester.key_calls.size(), 4);
1970 kPhysicalNumLock, kLogicalNumLock,
"", kSynthesized);
1972 kPhysicalNumLock, kLogicalNumLock,
"", kSynthesized);
1974 kPhysicalNumLock, kLogicalNumLock,
"", kSynthesized);
1975 tester.clear_key_calls();
1976 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
1983 TEST_F(KeyboardTest, ImeExtendedEventsAreIgnored) {
1984 KeyboardTester tester{GetContext()};
1985 tester.Responding(
false);
1993 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1994 KeyStateChange{VK_RCONTROL,
true,
false},
1995 WmKeyDownInfo{VK_PROCESSKEY, kScanCodeControl, kExtended, kWasUp}.Build(
1998 EXPECT_EQ(tester.key_calls.size(), 1);
2001 tester.clear_key_calls();
2002 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2011 TEST_F(KeyboardTest, UpOnlyImeEventsAreCorrectlyHandled) {
2012 KeyboardTester tester{GetContext()};
2013 tester.Responding(
true);
2018 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2019 KeyStateChange{VK_LSHIFT,
true,
false},
2022 WmKeyDownInfo{VK_PROCESSKEY, kScanCodeDigit2, kNotExtended, kWasUp}.Build(
2024 KeyStateChange{VK_LSHIFT,
false,
true},
2027 WmKeyUpInfo{
'2', kScanCodeDigit2, kNotExtended, kWasUp}.Build(
2030 EXPECT_EQ(tester.key_calls.size(), 4);
2032 kPhysicalShiftLeft, kLogicalShiftLeft,
"",
2037 kPhysicalShiftLeft, kLogicalShiftLeft,
"",
2041 tester.clear_key_calls();
2050 TEST_F(KeyboardTest, SlowFrameworkResponse) {
2051 KeyboardTester tester{GetContext()};
2053 std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2056 tester.LateResponding(
2057 [&recorded_callbacks](
2058 const FlutterKeyEvent* event,
2059 MockKeyResponseController::ResponseCallback
callback) {
2060 recorded_callbacks.push_back(
callback);
2064 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2071 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2074 WmCharInfo{
'a',
kScanCodeKeyA, kNotExtended, kWasDown}.Build(
2077 EXPECT_EQ(tester.key_calls.size(), 1);
2079 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
2080 EXPECT_EQ(recorded_callbacks.size(), 1);
2081 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2084 recorded_callbacks.front()(
false);
2086 EXPECT_EQ(tester.key_calls.size(), 3);
2087 EXPECT_EQ(recorded_callbacks.size(), 2);
2090 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
2091 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2094 recorded_callbacks.back()(
false);
2096 EXPECT_EQ(tester.key_calls.size(), 4);
2098 tester.clear_key_calls();
2099 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2113 TEST_F(KeyboardTest, SlowFrameworkResponseForIdenticalEvents) {
2114 KeyboardTester tester{GetContext()};
2115 std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2118 tester.LateResponding(
2119 [&recorded_callbacks](
2120 const FlutterKeyEvent* event,
2121 MockKeyResponseController::ResponseCallback
callback) {
2122 recorded_callbacks.push_back(
callback);
2126 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2132 EXPECT_EQ(tester.key_calls.size(), 1);
2134 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
2135 tester.clear_key_calls();
2136 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2139 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2143 EXPECT_EQ(tester.key_calls.size(), 0);
2144 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2147 EXPECT_EQ(recorded_callbacks.size(), 1);
2148 recorded_callbacks.front()(
false);
2150 EXPECT_EQ(tester.key_calls.size(), 2);
2153 kPhysicalKeyA, kLogicalKeyA,
"", kNotSynthesized);
2154 tester.clear_key_calls();
2155 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2158 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2166 EXPECT_EQ(recorded_callbacks.size(), 2);
2167 EXPECT_EQ(tester.key_calls.size(), 0);
2168 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2172 recorded_callbacks.back()(
false);
2173 EXPECT_EQ(tester.key_calls.size(), 1);
2175 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
2176 tester.clear_key_calls();
2177 EXPECT_EQ(recorded_callbacks.size(), 3);
2178 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2181 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2185 EXPECT_EQ(tester.key_calls.size(), 0);
2186 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2190 KeyboardTester tester{GetContext()};
2191 tester.Responding(
false);
2195 tester.InjectPlatformMessage(
2196 "flutter/textinput",
"TextInput.setClient",
2197 R
"|([108, {"inputAction": "TextInputAction.none"}])|");
2200 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2201 WmKeyDownInfo{VK_RETURN, kScanCodeEnter, kNotExtended, kWasUp}.Build(
2203 WmCharInfo{
'\n', kScanCodeEnter, kNotExtended, kWasUp}.Build(
2206 EXPECT_EQ(tester.key_calls.size(), 2);
2208 kPhysicalEnter, kLogicalEnter,
"", kNotSynthesized);
2210 tester.key_calls[1],
2212 R
"|("method":"TextInputClient.performAction",)|"
2213 R"|("args":[108,"TextInputAction.none"])|"
2215 tester.clear_key_calls();
2216 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2219 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2220 WmKeyUpInfo{VK_RETURN, kScanCodeEnter, kNotExtended}.Build(
2223 EXPECT_EQ(tester.key_calls.size(), 1);
2225 kPhysicalEnter, kLogicalEnter,
"", kNotSynthesized);
2226 tester.clear_key_calls();
2227 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2234 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2240 EXPECT_EQ(tester.key_calls.size(), 2);
2242 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
2244 tester.clear_key_calls();
2247 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2251 EXPECT_EQ(tester.key_calls.size(), 1);
2253 kPhysicalKeyA, kLogicalKeyA,
"", kNotSynthesized);
2254 tester.clear_key_calls();
2257 TEST_F(KeyboardTest, VietnameseTelexAddDiacriticWithFastResponse) {
2267 KeyboardTester tester{GetContext()};
2268 tester.Responding(
false);
2273 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2279 EXPECT_EQ(tester.key_calls.size(), 2);
2281 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
2283 tester.clear_key_calls();
2284 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2287 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2291 EXPECT_EQ(tester.key_calls.size(), 1);
2293 kPhysicalKeyA, kLogicalKeyA,
"", kNotSynthesized);
2294 tester.clear_key_calls();
2295 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2300 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2301 WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2303 WmCharInfo{0x8, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2305 WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
2307 WmKeyDownInfo{VK_PACKET, 0, kNotExtended, kWasUp}.Build(kWmResultDefault),
2308 WmCharInfo{0xe0 , 0, kNotExtended, kWasUp}.Build(kWmResultZero),
2309 WmKeyUpInfo{VK_PACKET, 0, kNotExtended}.Build(kWmResultDefault)});
2311 EXPECT_EQ(tester.key_calls.size(), 3);
2313 kPhysicalBackspace, kLogicalBackspace,
"",
2316 kPhysicalBackspace, kLogicalBackspace,
"",
2319 tester.clear_key_calls();
2325 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 3);
2328 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2329 WmKeyUpInfo{kVirtualKeyF, kScanCodeKeyF, kNotExtended,
2331 .Build(kWmResultZero)});
2333 EXPECT_EQ(tester.key_calls.size(), 1);
2336 tester.clear_key_calls();
2337 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2341 bool backspace_response) {
2351 KeyboardTester tester{context};
2352 tester.Responding(
false);
2357 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2363 EXPECT_EQ(tester.key_calls.size(), 2);
2365 kPhysicalKeyA, kLogicalKeyA,
"a", kNotSynthesized);
2367 tester.clear_key_calls();
2368 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
2371 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2375 EXPECT_EQ(tester.key_calls.size(), 1);
2377 kPhysicalKeyA, kLogicalKeyA,
"", kNotSynthesized);
2378 tester.clear_key_calls();
2379 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2381 std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2382 tester.LateResponding(
2383 [&recorded_callbacks](
2384 const FlutterKeyEvent* event,
2385 MockKeyResponseController::ResponseCallback
callback) {
2386 recorded_callbacks.push_back(
callback);
2392 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2393 WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2395 WmCharInfo{0x8, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
2397 WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
2399 WmKeyDownInfo{VK_PACKET, 0, kNotExtended, kWasUp}.Build(kWmResultDefault),
2400 WmCharInfo{0xe0 , 0, kNotExtended, kWasUp}.Build(kWmResultZero),
2401 WmKeyUpInfo{VK_PACKET, 0, kNotExtended}.Build(kWmResultDefault)});
2408 EXPECT_EQ(tester.key_calls.size(), 1);
2410 kPhysicalBackspace, kLogicalBackspace,
"",
2412 tester.clear_key_calls();
2413 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2415 EXPECT_EQ(recorded_callbacks.size(), 1);
2416 recorded_callbacks[0](backspace_response);
2418 EXPECT_EQ(tester.key_calls.size(), 1);
2420 kPhysicalBackspace, kLogicalBackspace,
"",
2422 tester.clear_key_calls();
2423 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(),
2424 backspace_response ? 0 : 2);
2426 recorded_callbacks[1](
false);
2427 EXPECT_EQ(tester.key_calls.size(), 1);
2429 tester.clear_key_calls();
2430 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
2432 tester.Responding(
false);
2435 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2436 WmKeyUpInfo{kVirtualKeyF, kScanCodeKeyF, kNotExtended,
2438 .Build(kWmResultZero)});
2440 EXPECT_EQ(tester.key_calls.size(), 1);
2443 tester.clear_key_calls();
2444 EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
2447 TEST_F(KeyboardTest, VietnameseTelexAddDiacriticWithSlowFalseResponse) {
2451 TEST_F(KeyboardTest, VietnameseTelexAddDiacriticWithSlowTrueResponse) {
2458 KeyboardTester tester{GetContext()};
2459 tester.Responding(
false);
2461 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2462 WmKeyDownInfo{VK_CAPITAL, 0, kNotExtended}.Build(),
2463 WmKeyUpInfo{VK_CAPITAL, 0, kNotExtended}.Build()});
2465 tester.clear_key_calls();