567 {
570
571
572
573
574 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
576 kWmResultZero),
578 kWmResultZero)});
579
580 EXPECT_EQ(
tester.key_calls.size(), 1);
582 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
584 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
585
586
587 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
589 kWmResultZero)});
590
591 EXPECT_EQ(
tester.key_calls.size(), 1);
593 kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
595 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
596}
597
598TEST_F(KeyboardTest, LowerCaseAUnhandled) {
601
602
603
604
605 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
607 kWmResultZero),
609 kWmResultZero)});
610
611 EXPECT_EQ(
tester.key_calls.size(), 2);
613 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
616 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
617
618
619 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
621 kWmResultZero)});
622
623 EXPECT_EQ(
tester.key_calls.size(), 1);
625 kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
627 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
628}
629
630TEST_F(KeyboardTest, ArrowLeftHandled) {
633
634
635
636
637 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
639 kWmResultZero)});
640
641 EXPECT_EQ(
tester.key_calls.size(), 1);
643 kPhysicalArrowLeft, kLogicalArrowLeft, "",
644 kNotSynthesized);
646 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
647
648
649 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
651 kWmResultZero)});
652
653 EXPECT_EQ(
tester.key_calls.size(), 1);
655 kPhysicalArrowLeft, kLogicalArrowLeft, "",
656 kNotSynthesized);
658 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
659}
660
661TEST_F(KeyboardTest, ArrowLeftUnhandled) {
664
665
666
667
668 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
670 kWmResultZero)});
671
672 EXPECT_EQ(
tester.key_calls.size(), 1);
674 kPhysicalArrowLeft, kLogicalArrowLeft, "",
675 kNotSynthesized);
677 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
678
679
680 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
682 kWmResultZero)});
683
684 EXPECT_EQ(
tester.key_calls.size(), 1);
686 kPhysicalArrowLeft, kLogicalArrowLeft, "",
687 kNotSynthesized);
689 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
690}
691
692TEST_F(KeyboardTest, ShiftLeftUnhandled) {
695
696
697
698
699 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
700 KeyStateChange{VK_LSHIFT, true, false},
702 kWmResultZero)});
703
704 EXPECT_EQ(
tester.key_calls.size(), 1);
706 kPhysicalShiftLeft, kLogicalShiftLeft, "",
707 kNotSynthesized);
709 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
710
711
712 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
714 kWmResultZero)});
715
716 EXPECT_EQ(
tester.key_calls.size(), 1);
718 kPhysicalShiftLeft, kLogicalShiftLeft, "",
719 kNotSynthesized);
721 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
722
723
724 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
725 KeyStateChange{VK_LSHIFT, false, true},
727 kWmResultZero)});
728
729 EXPECT_EQ(
tester.key_calls.size(), 1);
731 kPhysicalShiftLeft, kLogicalShiftLeft, "",
732 kNotSynthesized);
734 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
735}
736
737TEST_F(KeyboardTest, ShiftRightUnhandled) {
740
741
742
743
744 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
745 KeyStateChange{VK_RSHIFT, true, false},
747 kWmResultZero)});
748
749 EXPECT_EQ(
tester.key_calls.size(), 1);
751 kPhysicalShiftRight, kLogicalShiftRight, "",
752 kNotSynthesized);
754 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
755
756
757 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
758 KeyStateChange{VK_RSHIFT, false, true},
760 kWmResultZero)});
761
762 EXPECT_EQ(
tester.key_calls.size(), 1);
764 kPhysicalShiftRight, kLogicalShiftRight, "",
765 kNotSynthesized);
767 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
768}
769
770TEST_F(KeyboardTest, CtrlLeftUnhandled) {
773
774
775
776
777 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
778 KeyStateChange{VK_LCONTROL, true, false},
780 kWmResultZero)});
781
782 EXPECT_EQ(
tester.key_calls.size(), 1);
784 kPhysicalControlLeft, kLogicalControlLeft, "",
785 kNotSynthesized);
787 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
788
789
790 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
791 KeyStateChange{VK_LCONTROL, false, true},
793 kWmResultZero)});
794
795 EXPECT_EQ(
tester.key_calls.size(), 1);
797 kPhysicalControlLeft, kLogicalControlLeft, "",
798 kNotSynthesized);
800 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
801}
802
803TEST_F(KeyboardTest, CtrlRightUnhandled) {
806
807
808
809
810 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
811 KeyStateChange{VK_RCONTROL, true, false},
813 kWmResultZero)});
814
815 EXPECT_EQ(
tester.key_calls.size(), 1);
817 kPhysicalControlRight, kLogicalControlRight, "",
818 kNotSynthesized);
820 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
821
822
823 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
824 KeyStateChange{VK_RCONTROL, false, true},
826 kWmResultZero)});
827
828 EXPECT_EQ(
tester.key_calls.size(), 1);
830 kPhysicalControlRight, kLogicalControlRight, "",
831 kNotSynthesized);
833 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
834}
835
836TEST_F(KeyboardTest, AltLeftUnhandled) {
839
840
841
842
843 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
844 KeyStateChange{VK_LMENU, true, false},
846 kWmResultDefault)});
847
848 EXPECT_EQ(
tester.key_calls.size(), 1);
850 kPhysicalAltLeft, kLogicalAltLeft, "", kNotSynthesized);
852
853 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
854
855
856 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
857 KeyStateChange{VK_LMENU, false, true},
859 kWmResultDefault)});
860
861 EXPECT_EQ(
tester.key_calls.size(), 1);
863 kPhysicalAltLeft, kLogicalAltLeft, "", kNotSynthesized);
865
866 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
867}
868
869TEST_F(KeyboardTest, AltRightUnhandled) {
872
873
874
875
876 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
877 KeyStateChange{VK_RMENU, true, false},
879 kWmResultDefault)});
880
881 EXPECT_EQ(
tester.key_calls.size(), 1);
883 kPhysicalAltRight, kLogicalAltRight, "",
884 kNotSynthesized);
886
887 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
888
889
890 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
891 KeyStateChange{VK_RMENU, false, true},
893 kWmResultDefault)});
894
895 EXPECT_EQ(
tester.key_calls.size(), 1);
897 kPhysicalAltRight, kLogicalAltRight, "",
898 kNotSynthesized);
900
901 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
902}
903
904TEST_F(KeyboardTest, MetaLeftUnhandled) {
907
908
909
910
911 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
912 KeyStateChange{VK_LWIN, true, false},
914 kWmResultZero)});
915
916 EXPECT_EQ(
tester.key_calls.size(), 1);
918 kPhysicalMetaLeft, kLogicalMetaLeft, "",
919 kNotSynthesized);
921 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
922
923
924 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
925 KeyStateChange{VK_LWIN, false, true},
927
928 EXPECT_EQ(
tester.key_calls.size(), 1);
930 kPhysicalMetaLeft, kLogicalMetaLeft, "",
931 kNotSynthesized);
933 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
934}
935
936TEST_F(KeyboardTest, MetaRightUnhandled) {
939
940
941
942
943 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
944 KeyStateChange{VK_RWIN, true, false},
946 kWmResultZero)});
947
948 EXPECT_EQ(
tester.key_calls.size(), 1);
950 kPhysicalMetaRight, kLogicalMetaRight, "",
951 kNotSynthesized);
953 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
954
955
956 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
957 KeyStateChange{VK_RWIN, false, true},
959 kWmResultZero)});
960
961 EXPECT_EQ(
tester.key_calls.size(), 1);
963 kPhysicalMetaRight, kLogicalMetaRight, "",
964 kNotSynthesized);
966 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
967}
968
969
970TEST_F(KeyboardTest, RepeatA) {
973
974
975 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
977 kWmResultZero),
979 kWmResultZero)});
980
981
982 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
984 kWmResultZero),
986 kWmResultZero)});
987
988 EXPECT_EQ(
tester.key_calls.size(), 2);
990 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
992 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
993 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
994}
995
996
997
998
999TEST_F(KeyboardTest, RestartClearsKeyboardState) {
1002
1003
1004 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1006 kWmResultZero),
1008 kWmResultZero)});
1009
1010
1012
1013
1014
1015 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1017 kWmResultZero),
1019 kWmResultZero)});
1020
1021 EXPECT_EQ(
tester.key_calls.size(), 2);
1023 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
1025 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
1026 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
1027}
1028
1029
1030
1031TEST_F(KeyboardTest, ShiftLeftKeyA) {
1033 tester.Responding(
false);
1034
1035
1036
1037
1038 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1039 KeyStateChange{VK_LSHIFT, true, true},
1041 kWmResultZero)});
1042
1043 EXPECT_EQ(
tester.key_calls.size(), 1);
1045 kPhysicalShiftLeft, kLogicalShiftLeft, "",
1046 kNotSynthesized);
1047 tester.clear_key_calls();
1048 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1049
1050
1051 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1053 kWmResultZero),
1055 kWmResultZero)});
1056
1057 EXPECT_EQ(
tester.key_calls.size(), 2);
1059 kPhysicalKeyA, kLogicalKeyA, "A", kNotSynthesized);
1061 tester.clear_key_calls();
1062 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1063
1064
1065 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1066 KeyStateChange{VK_LSHIFT, false, true},
1068 kWmResultZero)});
1069
1070 EXPECT_EQ(
tester.key_calls.size(), 1);
1072 kPhysicalShiftLeft, kLogicalShiftLeft, "",
1073 kNotSynthesized);
1074 tester.clear_key_calls();
1075 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1076
1077
1078 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1080 kWmResultZero)});
1081
1082 EXPECT_EQ(
tester.key_calls.size(), 1);
1084 kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
1085 tester.clear_key_calls();
1086 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1087}
1088
1089
1090
1091TEST_F(KeyboardTest, CtrlLeftKeyA) {
1093 tester.Responding(
false);
1094
1095
1096
1097
1098 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1099 KeyStateChange{VK_LCONTROL, true, true},
1101 kWmResultZero)});
1102
1103 EXPECT_EQ(
tester.key_calls.size(), 1);
1105 kPhysicalControlLeft, kLogicalControlLeft, "",
1106 kNotSynthesized);
1107 tester.clear_key_calls();
1108 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1109
1110
1111 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1113 kWmResultZero),
1115 kWmResultZero)});
1116
1117 EXPECT_EQ(
tester.key_calls.size(), 1);
1119 kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
1120 tester.clear_key_calls();
1121 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1122
1123
1124 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1126 kWmResultZero)});
1127
1128 EXPECT_EQ(
tester.key_calls.size(), 1);
1130 kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
1131 tester.clear_key_calls();
1132 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1133
1134
1135 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1136 KeyStateChange{VK_LCONTROL, false, true},
1138 kWmResultZero)});
1139
1140 EXPECT_EQ(
tester.key_calls.size(), 1);
1142 kPhysicalControlLeft, kLogicalControlLeft, "",
1143 kNotSynthesized);
1144 tester.clear_key_calls();
1145 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1146}
1147
1148
1149TEST_F(KeyboardTest, CtrlLeftDigit1) {
1151 tester.Responding(
false);
1152
1153
1154
1155
1156 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1157 KeyStateChange{VK_LCONTROL, true, true},
1159 kWmResultZero)});
1160
1161 EXPECT_EQ(
tester.key_calls.size(), 1);
1163 kPhysicalControlLeft, kLogicalControlLeft, "",
1164 kNotSynthesized);
1165 tester.clear_key_calls();
1166 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1167
1168
1169 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1171 .Build(kWmResultZero)});
1172
1173 EXPECT_EQ(
tester.key_calls.size(), 1);
1175 kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1176 tester.clear_key_calls();
1177 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1178
1179
1180 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1182 kWmResultZero)});
1183
1184 EXPECT_EQ(
tester.key_calls.size(), 1);
1186 kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1187 tester.clear_key_calls();
1188 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1189
1190
1191 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1192 KeyStateChange{VK_LCONTROL, false, true},
1194 kWmResultZero)});
1195
1196 EXPECT_EQ(
tester.key_calls.size(), 1);
1198 kPhysicalControlLeft, kLogicalControlLeft, "",
1199 kNotSynthesized);
1200 tester.clear_key_calls();
1201 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1202}
1203
1204
1205
1206TEST_F(KeyboardTest, Digit1OnFrenchLayout) {
1208 tester.Responding(
false);
1209
1210 tester.SetLayout(LayoutFrench);
1211
1212
1213 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1215 .Build(kWmResultZero),
1217 kWmResultZero)});
1218
1219 EXPECT_EQ(
tester.key_calls.size(), 2);
1221 kPhysicalDigit1, kLogicalDigit1, "&", kNotSynthesized);
1223 tester.clear_key_calls();
1224 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1225
1226
1227 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1229 kWmResultZero)});
1230
1231 EXPECT_EQ(
tester.key_calls.size(), 1);
1233 kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1234 tester.clear_key_calls();
1235 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1236}
1237
1238
1239TEST_F(KeyboardTest, AltGrModifiedKey) {
1241 tester.Responding(
false);
1242
1243
1244
1245
1246 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1247 KeyStateChange{VK_LCONTROL, true, true},
1249 kWmResultZero),
1250 KeyStateChange{VK_RMENU, true, true},
1252 kWmResultZero)});
1253
1254 EXPECT_EQ(
tester.key_calls.size(), 2);
1256 kPhysicalControlLeft, kLogicalControlLeft, "",
1257 kNotSynthesized);
1259 kPhysicalAltRight, kLogicalAltRight, "",
1260 kNotSynthesized);
1261 tester.clear_key_calls();
1262 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1263
1264
1265 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1267 kWmResultZero),
1269 kWmResultZero)});
1270
1271 EXPECT_EQ(
tester.key_calls.size(), 2);
1273 kPhysicalKeyQ, kLogicalKeyQ, "@", kNotSynthesized);
1275 tester.clear_key_calls();
1276 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1277
1278
1279 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1281 kWmResultZero)});
1282
1283 EXPECT_EQ(
tester.key_calls.size(), 1);
1285 kPhysicalKeyQ, kLogicalKeyQ, "", kNotSynthesized);
1286 tester.clear_key_calls();
1287 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1288
1289
1290
1291
1292 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1293 KeyStateChange{VK_LCONTROL, false, true},
1294 ExpectForgedMessage{
1296 kWmResultZero)},
1297 KeyStateChange{VK_RMENU, false, true},
1299 kWmResultDefault)});
1300
1301 EXPECT_EQ(
tester.key_calls.size(), 2);
1303 kPhysicalControlLeft, kLogicalControlLeft, "",
1304 kNotSynthesized);
1306 kPhysicalAltRight, kLogicalAltRight, "",
1307 kNotSynthesized);
1308 tester.clear_key_calls();
1309
1310 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1311}
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326TEST_F(KeyboardTest, AltGrTwice) {
1328 tester.Responding(
false);
1329
1330
1331
1332
1333
1334 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1335 KeyStateChange{VK_LCONTROL, true, true},
1337 kWmResultZero),
1338 KeyStateChange{VK_RMENU, true, true},
1340 kWmResultZero)});
1341
1342 EXPECT_EQ(
tester.key_calls.size(), 2);
1344 kPhysicalControlLeft, kLogicalControlLeft, "",
1345 kNotSynthesized);
1347 kPhysicalAltRight, kLogicalAltRight, "",
1348 kNotSynthesized);
1349 tester.clear_key_calls();
1350 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1351
1352
1353
1354
1355 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1356 KeyStateChange{VK_LCONTROL, false, true},
1357 ExpectForgedMessage{
1359 kWmResultZero)},
1360 KeyStateChange{VK_RMENU, false, true},
1362 kWmResultDefault)});
1363 EXPECT_EQ(
tester.key_calls.size(), 2);
1365 kPhysicalControlLeft, kLogicalControlLeft, "",
1366 kNotSynthesized);
1368 kPhysicalAltRight, kLogicalAltRight, "",
1369 kNotSynthesized);
1370 tester.clear_key_calls();
1371
1372 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1373
1374
1375
1376 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1377 KeyStateChange{VK_LCONTROL, true, false},
1379 kWmResultZero),
1380 KeyStateChange{VK_RMENU, true, true},
1382 kWmResultZero)});
1383
1384 EXPECT_EQ(
tester.key_calls.size(), 2);
1386 kPhysicalControlLeft, kLogicalControlLeft, "",
1387 kNotSynthesized);
1389 kPhysicalAltRight, kLogicalAltRight, "",
1390 kNotSynthesized);
1391 tester.clear_key_calls();
1392 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1393
1394
1395
1396
1397 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1398 KeyStateChange{VK_LCONTROL, false, false},
1399 ExpectForgedMessage{
1401 kWmResultZero)},
1402 KeyStateChange{VK_RMENU, false, false},
1404 kWmResultDefault)});
1405 EXPECT_EQ(
tester.key_calls.size(), 2);
1407 kPhysicalControlLeft, kLogicalControlLeft, "",
1408 kNotSynthesized);
1410 kPhysicalAltRight, kLogicalAltRight, "",
1411 kNotSynthesized);
1412 tester.clear_key_calls();
1413
1414 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1415
1416
1417 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1419 kWmResultZero)});
1420 EXPECT_EQ(
tester.key_calls.size(), 1);
1422 kNotSynthesized);
1423 tester.clear_key_calls();
1424 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
1425}
1426
1427
1428
1429TEST_F(KeyboardTest, DeadKeyThatCombines) {
1431 tester.Responding(
false);
1432
1433 tester.SetLayout(LayoutFrench);
1434
1435
1436 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1438 kWmResultZero),
1440 kWmResultZero)});
1441
1442 EXPECT_EQ(
tester.key_calls.size(), 1);
1444 kPhysicalBracketLeft, kLogicalBracketRight, "^",
1445 kNotSynthesized);
1446 tester.clear_key_calls();
1447 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1448
1449
1450 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1452 kWmResultZero)});
1453
1454 EXPECT_EQ(
tester.key_calls.size(), 1);
1456 kPhysicalBracketLeft, kLogicalBracketRight, "",
1457 kNotSynthesized);
1458 tester.clear_key_calls();
1459 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1460
1461
1462 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1464 kWmResultZero),
1466 kWmResultZero)});
1467
1468 EXPECT_EQ(
tester.key_calls.size(), 2);
1470 kPhysicalKeyE, kLogicalKeyE, "ê", kNotSynthesized);
1472 tester.clear_key_calls();
1473 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1474
1475
1476 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1478 kWmResultZero)});
1479
1480 EXPECT_EQ(
tester.key_calls.size(), 1);
1482 kPhysicalKeyE, kLogicalKeyE, "", kNotSynthesized);
1483 tester.clear_key_calls();
1484 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1485}
1486
1487
1488
1489
1490
1491
1492TEST_F(KeyboardTest, DeadKeyWithoutDeadMaskThatCombines) {
1494 tester.Responding(
false);
1495
1496
1497 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1498 KeyStateChange{VK_LSHIFT, true, true},
1500 kWmResultZero)});
1501
1502 EXPECT_EQ(
tester.key_calls.size(), 1);
1504 kPhysicalShiftLeft, kLogicalShiftLeft, "",
1505 kNotSynthesized);
1506 tester.clear_key_calls();
1507 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1508
1509
1510 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1512 kWmResultZero),
1514 kWmResultZero)});
1515
1516 EXPECT_EQ(
tester.key_calls.size(), 1);
1518 kPhysicalDigit6, kLogicalDigit6, "6", kNotSynthesized);
1519 tester.clear_key_calls();
1520 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1521
1522
1523 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1525
1526 EXPECT_EQ(
tester.key_calls.size(), 1);
1528 kPhysicalDigit6, kLogicalDigit6, "", kNotSynthesized);
1529 tester.clear_key_calls();
1530 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1531
1532
1533 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1534 KeyStateChange{VK_LSHIFT, false, true},
1536 kWmResultZero)});
1537
1538 EXPECT_EQ(
tester.key_calls.size(), 1);
1540 kPhysicalShiftLeft, kLogicalShiftLeft, "",
1541 kNotSynthesized);
1542 tester.clear_key_calls();
1543 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1544
1545
1546 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1548 kWmResultZero),
1550 kWmResultZero)});
1551
1552 EXPECT_EQ(
tester.key_calls.size(), 2);
1554 kPhysicalKeyE, kLogicalKeyE, "ê", kNotSynthesized);
1556 tester.clear_key_calls();
1557 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1558
1559
1560 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1562 kWmResultZero)});
1563
1564 EXPECT_EQ(
tester.key_calls.size(), 1);
1566 kPhysicalKeyE, kLogicalKeyE, "", kNotSynthesized);
1567 tester.clear_key_calls();
1568 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1569}
1570
1571
1572
1573TEST_F(KeyboardTest, DeadKeyThatDoesNotCombine) {
1575 tester.Responding(
false);
1576
1577 tester.SetLayout(LayoutFrench);
1578
1579
1580 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1582 kWmResultZero),
1584 kWmResultZero)});
1585
1586 EXPECT_EQ(
tester.key_calls.size(), 1);
1588 kPhysicalBracketLeft, kLogicalBracketRight, "^",
1589 kNotSynthesized);
1590 tester.clear_key_calls();
1591 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1592
1593
1594 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1596 kWmResultZero)});
1597
1598 EXPECT_EQ(
tester.key_calls.size(), 1);
1600 kPhysicalBracketLeft, kLogicalBracketRight, "",
1601 kNotSynthesized);
1602 tester.clear_key_calls();
1603 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1604
1605
1606 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1608 .Build(kWmResultZero),
1610 kWmResultZero),
1612 kWmResultZero)});
1613
1614 EXPECT_EQ(
tester.key_calls.size(), 3);
1616 kPhysicalDigit1, kLogicalDigit1, "^", kNotSynthesized);
1619 tester.clear_key_calls();
1620
1621
1622
1623
1624
1625 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1626
1627
1628 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1630 kWmResultZero)});
1631
1632 EXPECT_EQ(
tester.key_calls.size(), 1);
1634 kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
1635 tester.clear_key_calls();
1636 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1637}
1638
1639
1640
1641
1642TEST_F(KeyboardTest, DeadKeyTwiceThenLetter) {
1644 tester.Responding(
false);
1645
1646
1647
1648
1649 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1651 kWmResultZero),
1653 kWmResultZero)});
1654
1655 EXPECT_EQ(
tester.key_calls.size(), 1);
1657 kPhysicalBackquote, kLogicalBackquote, "`",
1658 kNotSynthesized);
1659 tester.clear_key_calls();
1660 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1661
1662
1663 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1665 kWmResultZero)});
1666
1667 EXPECT_EQ(
tester.key_calls.size(), 1);
1669 kPhysicalBackquote, kLogicalBackquote, "",
1670 kNotSynthesized);
1671 tester.clear_key_calls();
1672 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1673
1674
1675
1676 std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
1678 [&recorded_callbacks](
1680 MockKeyResponseController::ResponseCallback
callback) {
1681 recorded_callbacks.push_back(
callback);
1682 });
1683
1684 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1686 kWmResultZero),
1689 .Build(kWmResultZero),
1691 kWmResultZero)});
1692
1693 EXPECT_EQ(recorded_callbacks.size(), 1);
1694 EXPECT_EQ(
tester.key_calls.size(), 1);
1696 kPhysicalBackquote, kLogicalBackquote, "`",
1697 kNotSynthesized);
1698 tester.clear_key_calls();
1699
1700 recorded_callbacks.front()(false);
1701 EXPECT_EQ(
tester.key_calls.size(), 2);
1704 tester.clear_key_calls();
1705
1706
1707
1708 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
1709
1710 tester.Responding(
false);
1711
1712
1713 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1715 kWmResultZero)});
1716
1717 EXPECT_EQ(
tester.key_calls.size(), 1);
1719 kPhysicalBackquote, kLogicalBackquote, "",
1720 kNotSynthesized);
1721 tester.clear_key_calls();
1722 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1723}
1724
1725
1726TEST_F(KeyboardTest, MultibyteCharacter) {
1728 tester.Responding(
false);
1729
1730
1731
1732
1733
1734 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1736 kWmResultZero),
1738 kWmResultZero),
1740 kWmResultZero)});
1741
1742 const char* st =
tester.key_calls[0].key_event.character;
1743
1744 EXPECT_EQ(
tester.key_calls.size(), 2);
1746 kPhysicalKeyW, kLogicalKeyW, "𐍅", kNotSynthesized);
1748 tester.clear_key_calls();
1749 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 3);
1750
1751
1752 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1754 kWmResultZero)});
1755
1756 EXPECT_EQ(
tester.key_calls.size(), 1);
1758 kPhysicalKeyW, kLogicalKeyW, "", kNotSynthesized);
1759 tester.clear_key_calls();
1760 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1761}
1762
1763TEST_F(KeyboardTest, SynthesizeModifiers) {
1765 tester.Responding(
false);
1766
1767
1768 Win32Message event1 =
1770 kWmResultZero);
1771 Win32Message event2 =
1773 kWmResultZero);
1774
1775
1776 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1777 KeyStateChange{VK_LSHIFT, true, true}, event1});
1778 EXPECT_EQ(
tester.key_calls.size(), 2);
1780 kPhysicalShiftLeft, kLogicalShiftLeft, "", kSynthesized);
1781 tester.clear_key_calls();
1782 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1783
1784 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1785 KeyStateChange{VK_LSHIFT, false, true}, event2});
1786 EXPECT_EQ(
tester.key_calls.size(), 2);
1788 kPhysicalShiftLeft, kLogicalShiftLeft, "", kSynthesized);
1789 tester.clear_key_calls();
1790 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1791
1792
1793 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1794 KeyStateChange{VK_RSHIFT, true, true}, event1});
1795 EXPECT_EQ(
tester.key_calls.size(), 2);
1797 kPhysicalShiftRight, kLogicalShiftRight, "",
1798 kSynthesized);
1799 tester.clear_key_calls();
1800 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1801
1802 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1803 KeyStateChange{VK_RSHIFT, false, true}, event2});
1804 EXPECT_EQ(
tester.key_calls.size(), 2);
1806 kPhysicalShiftRight, kLogicalShiftRight, "",
1807 kSynthesized);
1808 tester.clear_key_calls();
1809 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1810
1811
1812 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1813 KeyStateChange{VK_LCONTROL, true, true}, event1});
1814 EXPECT_EQ(
tester.key_calls.size(), 2);
1816 kPhysicalControlLeft, kLogicalControlLeft, "",
1817 kSynthesized);
1818 tester.clear_key_calls();
1819 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1820
1821 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1822 KeyStateChange{VK_LCONTROL, false, true}, event2});
1823 EXPECT_EQ(
tester.key_calls.size(), 2);
1825 kPhysicalControlLeft, kLogicalControlLeft, "",
1826 kSynthesized);
1827 tester.clear_key_calls();
1828 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1829
1830
1831 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1832 KeyStateChange{VK_RCONTROL, true, true}, event1});
1833 EXPECT_EQ(
tester.key_calls.size(), 2);
1835 kPhysicalControlRight, kLogicalControlRight, "",
1836 kSynthesized);
1837 tester.clear_key_calls();
1838 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1839
1840 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1841 KeyStateChange{VK_RCONTROL, false, true}, event2});
1842 EXPECT_EQ(
tester.key_calls.size(), 2);
1844 kPhysicalControlRight, kLogicalControlRight, "",
1845 kSynthesized);
1846 tester.clear_key_calls();
1847 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1848
1849
1850 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1851 KeyStateChange{VK_LMENU, true, true}, event1});
1852 EXPECT_EQ(
tester.key_calls.size(), 2);
1854 kPhysicalAltLeft, kLogicalAltLeft, "", kSynthesized);
1855 tester.clear_key_calls();
1856 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1857
1858 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1859 KeyStateChange{VK_LMENU, false, true}, event2});
1860 EXPECT_EQ(
tester.key_calls.size(), 2);
1862 kPhysicalAltLeft, kLogicalAltLeft, "", kSynthesized);
1863 tester.clear_key_calls();
1864 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1865
1866
1867 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1868 KeyStateChange{VK_RMENU, true, true}, event1});
1869 EXPECT_EQ(
tester.key_calls.size(), 2);
1871 kPhysicalAltRight, kLogicalAltRight, "", kSynthesized);
1872 tester.clear_key_calls();
1873 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1874
1875 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1876 KeyStateChange{VK_RMENU, false, true}, event2});
1877 EXPECT_EQ(
tester.key_calls.size(), 2);
1879 kPhysicalAltRight, kLogicalAltRight, "", kSynthesized);
1880 tester.clear_key_calls();
1881 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1882
1883
1884 tester.InjectKeyboardChanges(
1885 std::vector<KeyboardChange>{KeyStateChange{VK_LWIN, true, true}, event1});
1886 EXPECT_EQ(
tester.key_calls.size(), 2);
1888 kPhysicalMetaLeft, kLogicalMetaLeft, "", kSynthesized);
1889 tester.clear_key_calls();
1890 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1891
1892 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1893 KeyStateChange{VK_LWIN, false, true}, event2});
1894 EXPECT_EQ(
tester.key_calls.size(), 2);
1896 kPhysicalMetaLeft, kLogicalMetaLeft, "", kSynthesized);
1897 tester.clear_key_calls();
1898 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1899
1900
1901 tester.InjectKeyboardChanges(
1902 std::vector<KeyboardChange>{KeyStateChange{VK_RWIN, true, true}, event1});
1903 EXPECT_EQ(
tester.key_calls.size(), 2);
1905 kPhysicalMetaRight, kLogicalMetaRight, "", kSynthesized);
1906 tester.clear_key_calls();
1907 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1908
1909 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1910 KeyStateChange{VK_RWIN, false, true}, event2});
1911 EXPECT_EQ(
tester.key_calls.size(), 2);
1913 kPhysicalMetaRight, kLogicalMetaRight, "", kSynthesized);
1914 tester.clear_key_calls();
1915 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1916
1917
1918
1919 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1920 KeyStateChange{VK_CAPITAL, false, true}, event1});
1921 EXPECT_EQ(
tester.key_calls.size(), 3);
1923 kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
1925 kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
1926 tester.clear_key_calls();
1927 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1928
1929 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1930 KeyStateChange{VK_CAPITAL, false, false}, event2});
1931 EXPECT_EQ(
tester.key_calls.size(), 3);
1933 kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
1935 kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
1936 tester.clear_key_calls();
1937 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1938
1939
1940 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1941 KeyStateChange{VK_SCROLL, true, true}, event1});
1942 EXPECT_EQ(
tester.key_calls.size(), 2);
1944 kPhysicalScrollLock, kLogicalScrollLock, "",
1945 kSynthesized);
1946 tester.clear_key_calls();
1947 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1948
1949 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1950 KeyStateChange{VK_SCROLL, true, false}, event2});
1951 EXPECT_EQ(
tester.key_calls.size(), 3);
1953 kPhysicalScrollLock, kLogicalScrollLock, "",
1954 kSynthesized);
1956 kPhysicalScrollLock, kLogicalScrollLock, "",
1957 kSynthesized);
1958 tester.clear_key_calls();
1959 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1960
1961
1962 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1963 KeyStateChange{VK_NUMLOCK, true, false}, event1});
1964
1965
1966
1967
1968 EXPECT_EQ(
tester.key_calls.size(), 2);
1970 kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
1971 tester.clear_key_calls();
1972 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1973
1974 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
1975 KeyStateChange{VK_NUMLOCK, false, true}, event2});
1976 EXPECT_EQ(
tester.key_calls.size(), 4);
1978 kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
1980 kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
1982 kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
1983 tester.clear_key_calls();
1984 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
1985}
1986
1987
1988
1989
1990
1991TEST_F(KeyboardTest, ImeExtendedEventsAreIgnored) {
1993 tester.Responding(
false);
1994
1995
1996
1997
1998
1999
2000
2001 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2002 KeyStateChange{VK_RCONTROL, true, false},
2004 kWmResultZero)});
2005
2006 EXPECT_EQ(
tester.key_calls.size(), 1);
2008 kNotSynthesized);
2009 tester.clear_key_calls();
2010 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
2011}
2012
2013
2014
2015
2016
2017
2018
2019TEST_F(KeyboardTest, UpOnlyImeEventsAreCorrectlyHandled) {
2022
2023
2024
2025
2026 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2027 KeyStateChange{VK_LSHIFT, true, false},
2029 kWmResultZero),
2031 kWmResultZero),
2032 KeyStateChange{VK_LSHIFT, false, true},
2034 kWmResultZero),
2036 kWmResultZero)});
2037
2038 EXPECT_EQ(
tester.key_calls.size(), 4);
2040 kPhysicalShiftLeft, kLogicalShiftLeft, "",
2041 kNotSynthesized);
2043 kNotSynthesized);
2045 kPhysicalShiftLeft, kLogicalShiftLeft, "",
2046 kNotSynthesized);
2048 kNotSynthesized);
2049 tester.clear_key_calls();
2050}
2051
2052
2053
2054
2055
2056
2057
2058TEST_F(KeyboardTest, SlowFrameworkResponse) {
2060
2061 std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2062
2063
2065 [&recorded_callbacks](
2067 MockKeyResponseController::ResponseCallback
callback) {
2068 recorded_callbacks.push_back(
callback);
2069 });
2070
2071
2072 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2074 kWmResultZero),
2076 kWmResultZero)});
2077
2078
2079 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2081 kWmResultZero),
2083 kWmResultZero)});
2084
2085 EXPECT_EQ(
tester.key_calls.size(), 1);
2087 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2088 EXPECT_EQ(recorded_callbacks.size(), 1);
2089 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
2090
2091
2092 recorded_callbacks.front()(false);
2093
2094 EXPECT_EQ(
tester.key_calls.size(), 3);
2095 EXPECT_EQ(recorded_callbacks.size(), 2);
2098 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2099 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
2100
2101
2102 recorded_callbacks.back()(false);
2103
2104 EXPECT_EQ(
tester.key_calls.size(), 4);
2106 tester.clear_key_calls();
2107 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
2108}
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121TEST_F(KeyboardTest, SlowFrameworkResponseForIdenticalEvents) {
2123 std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2124
2125
2127 [&recorded_callbacks](
2129 MockKeyResponseController::ResponseCallback
callback) {
2130 recorded_callbacks.push_back(
callback);
2131 });
2132
2133
2134 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2136 kWmResultZero),
2138 kWmResultZero)});
2139
2140 EXPECT_EQ(
tester.key_calls.size(), 1);
2142 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2143 tester.clear_key_calls();
2144 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
2145
2146
2147 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2149 kWmResultZero)});
2150
2151 EXPECT_EQ(
tester.key_calls.size(), 0);
2152 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
2153
2154
2155 EXPECT_EQ(recorded_callbacks.size(), 1);
2156 recorded_callbacks.front()(false);
2157
2158 EXPECT_EQ(
tester.key_calls.size(), 2);
2161 kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2162 tester.clear_key_calls();
2163 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
2164
2165
2166 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2168 kWmResultZero),
2170 kWmResultZero)});
2171
2172
2173
2174 EXPECT_EQ(recorded_callbacks.size(), 2);
2175 EXPECT_EQ(
tester.key_calls.size(), 0);
2176 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
2177
2178
2179
2180 recorded_callbacks.back()(false);
2181 EXPECT_EQ(
tester.key_calls.size(), 1);
2183 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2184 tester.clear_key_calls();
2185 EXPECT_EQ(recorded_callbacks.size(), 3);
2186 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
2187
2188
2189 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2191 kWmResultZero)});
2192
2193 EXPECT_EQ(
tester.key_calls.size(), 0);
2194 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
2195}
2196
2197TEST_F(KeyboardTest, TextInputSubmit) {
2199 tester.Responding(
false);
2200
2201
2202
2203 tester.InjectPlatformMessage(
2204 "flutter/textinput", "TextInput.setClient",
2205 R"|([108, {"inputAction": "TextInputAction.none"}])|");
2206
2207
2208 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2210 kWmResultZero),
2212 kWmResultZero)});
2213
2214 EXPECT_EQ(
tester.key_calls.size(), 2);
2216 kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
2219 "{"
2220 R"|("method":"TextInputClient.performAction",)|"
2221 R"|("args":[108,"TextInputAction.none"])|"
2222 "}");
2223 tester.clear_key_calls();
2224 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
2225
2226
2227 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2229 kWmResultZero)});
2230
2231 EXPECT_EQ(
tester.key_calls.size(), 1);
2233 kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
2234 tester.clear_key_calls();
2235 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
2236
2237
2238
2239
2240
2241
2242 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2244 kWmResultZero),
2246 kWmResultZero)});
2247
2248 EXPECT_EQ(
tester.key_calls.size(), 2);
2250 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2252 tester.clear_key_calls();
2253
2254
2255 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2257 kWmResultZero)});
2258
2259 EXPECT_EQ(
tester.key_calls.size(), 1);
2261 kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2262 tester.clear_key_calls();
2263}
2264
2265TEST_F(KeyboardTest, VietnameseTelexAddDiacriticWithFastResponse) {
2266
2267
2268
2269
2270
2271
2272
2273
2274
2276 tester.Responding(
false);
2277
2278
2279
2280
2281 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2283 kWmResultZero),
2285 kWmResultZero)});
2286
2287 EXPECT_EQ(
tester.key_calls.size(), 2);
2289 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2291 tester.clear_key_calls();
2292 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
2293
2294
2295 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2297 kWmResultZero)});
2298
2299 EXPECT_EQ(
tester.key_calls.size(), 1);
2301 kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2302 tester.clear_key_calls();
2303 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
2304
2305
2306
2307
2308 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2310 kWmResultZero),
2312 kWmResultZero),
2313 WmKeyUpInfo{VK_BACK, kScanCodeBackspace,
kNotExtended}.Build(
2314 kWmResultZero),
2317 WmKeyUpInfo{VK_PACKET, 0,
kNotExtended}.Build(kWmResultDefault)});
2318
2319 EXPECT_EQ(
tester.key_calls.size(), 3);
2321 kPhysicalBackspace, kLogicalBackspace, "",
2322 kNotSynthesized);
2324 kPhysicalBackspace, kLogicalBackspace, "",
2325 kNotSynthesized);
2327 tester.clear_key_calls();
2328
2329
2330
2331
2332
2333 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 3);
2334
2335
2336 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2338 true}
2339 .Build(kWmResultZero)});
2340
2341 EXPECT_EQ(
tester.key_calls.size(), 1);
2343 kNotSynthesized);
2344 tester.clear_key_calls();
2345 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
2346}
2347
2349 bool backspace_response) {
2350
2351
2352
2353
2354
2355
2356
2357
2358
2360 tester.Responding(
false);
2361
2362
2363
2364
2365 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2367 kWmResultZero),
2369 kWmResultZero)});
2370
2371 EXPECT_EQ(
tester.key_calls.size(), 2);
2373 kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
2375 tester.clear_key_calls();
2376 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 2);
2377
2378
2379 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2381 kWmResultZero)});
2382
2383 EXPECT_EQ(
tester.key_calls.size(), 1);
2385 kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
2386 tester.clear_key_calls();
2387 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
2388
2389 std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
2391 [&recorded_callbacks](
2393 MockKeyResponseController::ResponseCallback
callback) {
2394 recorded_callbacks.push_back(
callback);
2395 });
2396
2397
2398
2399
2400 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2402 kWmResultZero),
2404 kWmResultZero),
2405 WmKeyUpInfo{VK_BACK, kScanCodeBackspace,
kNotExtended}.Build(
2406 kWmResultZero),
2409 WmKeyUpInfo{VK_PACKET, 0,
kNotExtended}.Build(kWmResultDefault)});
2410
2411
2412
2413
2414
2415
2416 EXPECT_EQ(
tester.key_calls.size(), 1);
2418 kPhysicalBackspace, kLogicalBackspace, "",
2419 kNotSynthesized);
2420 tester.clear_key_calls();
2421 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
2422
2423 EXPECT_EQ(recorded_callbacks.size(), 1);
2424 recorded_callbacks[0](backspace_response);
2425
2426 EXPECT_EQ(
tester.key_calls.size(), 1);
2428 kPhysicalBackspace, kLogicalBackspace, "",
2429 kNotSynthesized);
2430 tester.clear_key_calls();
2431 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(),
2432 backspace_response ? 0 : 2);
2433
2434 recorded_callbacks[1](false);
2435 EXPECT_EQ(
tester.key_calls.size(), 1);
2437 tester.clear_key_calls();
2438 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 1);
2439
2440 tester.Responding(
false);
2441
2442
2443 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2445 true}
2446 .Build(kWmResultZero)});
2447
2448 EXPECT_EQ(
tester.key_calls.size(), 1);
2450 kNotSynthesized);
2451 tester.clear_key_calls();
2452 EXPECT_EQ(
tester.RedispatchedMessageCountAndClear(), 0);
2453}
2454
2455TEST_F(KeyboardTest, VietnameseTelexAddDiacriticWithSlowFalseResponse) {
2457}
2458
2459TEST_F(KeyboardTest, VietnameseTelexAddDiacriticWithSlowTrueResponse) {
2461}
2462
2463
2464
2465TEST_F(KeyboardTest, DoubleCapsLock) {
2467 tester.Responding(
false);
2468
2469 tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
2472
2473 tester.clear_key_calls();
2474}
2475
2476}
2477}
@ kFlutterKeyEventTypeDown
@ kFlutterKeyEventTypeRepeat
TEST_F(FlGnomeSettingsTest, ClockFormat)
FlKeyEvent uint64_t FlKeyResponderAsyncCallback callback
#define EXPECT_CALL_IS_TEXT(_key_call, u16_string)
#define EXPECT_CALL_IS_TEXT_METHOD_CALL(_key_call, json_string)
#define EXPECT_CALL_IS_EVENT(_key_call, _type, _physical, _logical, _character, _synthesized)
SK_API GrDirectContext * GetContext(const SkImage *src)
constexpr uint64_t kScanCodeKeyA
struct flutter::testing::WmKeyDownInfo WmKeyDownInfo
struct flutter::testing::WmSysKeyUpInfo WmSysKeyUpInfo
struct flutter::testing::WmKeyUpInfo WmKeyUpInfo
constexpr uint64_t kVirtualKeyA
struct flutter::testing::WmSysKeyDownInfo WmSysKeyDownInfo
void VietnameseTelexAddDiacriticWithSlowResponse(WindowsTestContext &context, bool backspace_response)
constexpr int kScanCodeShiftRight
constexpr int kScanCodeShiftLeft