test_one_shot_keys.cpp (19681B)
1 /* Copyright 2021 Stefan Kerkmann 2 * 3 * This program is free software: you can redistribute it and/or modify 4 * it under the terms of the GNU General Public License as published by 5 * the Free Software Foundation, either version 2 of the License, or 6 * (at your option) any later version. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program. If not, see <http://www.gnu.org/licenses/>. 15 */ 16 17 #include "action_util.h" 18 #include "keyboard_report_util.hpp" 19 #include "test_common.hpp" 20 21 using testing::_; 22 using testing::InSequence; 23 24 class OneShot : public TestFixture {}; 25 class OneShotParametrizedTestFixture : public ::testing::WithParamInterface<std::pair<KeymapKey, KeymapKey>>, public OneShot {}; 26 27 TEST_F(OneShot, OSMWithoutAdditionalKeypressDoesNothing) { 28 TestDriver driver; 29 auto osm_key = KeymapKey(0, 0, 0, OSM(MOD_LSFT), KC_LSFT); 30 31 set_keymap({osm_key}); 32 33 /* Press and release OSM key*/ 34 EXPECT_NO_REPORT(driver); 35 tap_key(osm_key); 36 VERIFY_AND_CLEAR(driver); 37 38 /* OSM are added when an actual report is send */ 39 EXPECT_REPORT(driver, (osm_key.report_code)); 40 send_keyboard_report(); 41 VERIFY_AND_CLEAR(driver); 42 43 /* Make unit-test pass */ 44 clear_oneshot_mods(); 45 } 46 47 #if defined(ONESHOT_TIMEOUT) 48 49 TEST_P(OneShotParametrizedTestFixture, OSMExpiredDoesNothing) { 50 TestDriver driver; 51 KeymapKey osm_key = GetParam().first; 52 KeymapKey regular_key = GetParam().second; 53 54 set_keymap({osm_key, regular_key}); 55 56 /* Press and release OSM */ 57 EXPECT_NO_REPORT(driver); 58 osm_key.press(); 59 run_one_scan_loop(); 60 osm_key.release(); 61 idle_for(ONESHOT_TIMEOUT); 62 VERIFY_AND_CLEAR(driver); 63 64 /* Press regular key */ 65 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); 66 regular_key.press(); 67 run_one_scan_loop(); 68 VERIFY_AND_CLEAR(driver); 69 70 /* Release regular key */ 71 EXPECT_EMPTY_REPORT(driver); 72 regular_key.release(); 73 run_one_scan_loop(); 74 VERIFY_AND_CLEAR(driver); 75 } 76 77 #endif 78 79 TEST_P(OneShotParametrizedTestFixture, OSMWithAdditionalKeypress) { 80 TestDriver driver; 81 KeymapKey osm_key = GetParam().first; 82 KeymapKey regular_key = GetParam().second; 83 84 set_keymap({osm_key, regular_key}); 85 86 /* Press and release OSM */ 87 EXPECT_NO_REPORT(driver); 88 tap_key(osm_key); 89 VERIFY_AND_CLEAR(driver); 90 91 /* Press regular key */ 92 EXPECT_REPORT(driver, (osm_key.report_code, regular_key.report_code)).Times(1); 93 regular_key.press(); 94 run_one_scan_loop(); 95 VERIFY_AND_CLEAR(driver); 96 97 /* Release regular key */ 98 EXPECT_EMPTY_REPORT(driver); 99 regular_key.release(); 100 run_one_scan_loop(); 101 VERIFY_AND_CLEAR(driver); 102 } 103 104 TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypress) { 105 TestDriver driver; 106 testing::InSequence s; 107 108 KeymapKey osm_key = GetParam().first; 109 KeymapKey regular_key = GetParam().second; 110 111 set_keymap({osm_key, regular_key}); 112 113 /* Press OSM */ 114 EXPECT_NO_REPORT(driver); 115 osm_key.press(); 116 run_one_scan_loop(); 117 VERIFY_AND_CLEAR(driver); 118 119 /* Press regular key */ 120 EXPECT_NO_REPORT(driver); 121 regular_key.press(); 122 run_one_scan_loop(); 123 VERIFY_AND_CLEAR(driver); 124 125 /* Release regular key */ 126 EXPECT_NO_REPORT(driver); 127 regular_key.release(); 128 run_one_scan_loop(); 129 VERIFY_AND_CLEAR(driver); 130 131 /* Release OSM */ 132 EXPECT_REPORT(driver, (regular_key.report_code, osm_key.report_code)).Times(1); 133 EXPECT_EMPTY_REPORT(driver); 134 osm_key.release(); 135 run_one_scan_loop(); 136 VERIFY_AND_CLEAR(driver); 137 } 138 139 // clang-format off 140 141 INSTANTIATE_TEST_CASE_P( 142 OneShotModifierTests, 143 OneShotParametrizedTestFixture, 144 ::testing::Values( 145 /* first is osm key, second is regular key. */ 146 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_LSFT), KC_LSFT}, KeymapKey{0, 1, 1, KC_A}), 147 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_LCTL), KC_LCTL}, KeymapKey{0, 1, 1, KC_A}), 148 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_LALT), KC_LALT}, KeymapKey{0, 1, 1, KC_A}), 149 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_LGUI), KC_LGUI}, KeymapKey{0, 1, 1, KC_A}), 150 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_RCTL), KC_RCTL}, KeymapKey{0, 1, 1, KC_A}), 151 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_RSFT), KC_RSFT}, KeymapKey{0, 1, 1, KC_A}), 152 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_RALT), KC_RALT}, KeymapKey{0, 1, 1, KC_A}), 153 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_RGUI), KC_RGUI}, KeymapKey{0, 1, 1, KC_A}) 154 )); 155 // clang-format on 156 157 TEST_F(OneShot, OSMChainingTwoOSMs) { 158 TestDriver driver; 159 InSequence s; 160 KeymapKey osm_key1 = KeymapKey{0, 0, 0, OSM(MOD_LSFT), KC_LSFT}; 161 KeymapKey osm_key2 = KeymapKey{0, 0, 1, OSM(MOD_LCTL), KC_LCTL}; 162 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A}; 163 164 set_keymap({osm_key1, osm_key2, regular_key}); 165 166 /* Press and release OSM1 */ 167 EXPECT_NO_REPORT(driver); 168 tap_key(osm_key1); 169 VERIFY_AND_CLEAR(driver); 170 171 /* Press and release OSM2 */ 172 EXPECT_NO_REPORT(driver); 173 tap_key(osm_key2); 174 VERIFY_AND_CLEAR(driver); 175 176 /* Press regular key */ 177 EXPECT_REPORT(driver, (osm_key1.report_code, osm_key2.report_code, regular_key.report_code)).Times(1); 178 regular_key.press(); 179 run_one_scan_loop(); 180 VERIFY_AND_CLEAR(driver); 181 182 /* Release regular key */ 183 EXPECT_EMPTY_REPORT(driver); 184 regular_key.release(); 185 run_one_scan_loop(); 186 VERIFY_AND_CLEAR(driver); 187 } 188 189 TEST_F(OneShot, OSMDoubleTapNotLockingOSMs) { 190 TestDriver driver; 191 InSequence s; 192 KeymapKey osm_key1 = KeymapKey{0, 0, 0, OSM(MOD_LSFT), KC_LSFT}; 193 KeymapKey osm_key2 = KeymapKey{0, 0, 1, OSM(MOD_LCTL), KC_LCTL}; 194 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A}; 195 196 set_keymap({osm_key1, osm_key2, regular_key}); 197 198 /* Press and release OSM1 */ 199 EXPECT_NO_REPORT(driver); 200 tap_key(osm_key1); 201 VERIFY_AND_CLEAR(driver); 202 203 /* Press and release OSM2 twice */ 204 EXPECT_NO_REPORT(driver); 205 tap_key(osm_key2); 206 tap_key(osm_key2); 207 VERIFY_AND_CLEAR(driver); 208 209 /* Press regular key */ 210 EXPECT_REPORT(driver, (osm_key1.report_code, osm_key2.report_code, regular_key.report_code)).Times(1); 211 regular_key.press(); 212 run_one_scan_loop(); 213 VERIFY_AND_CLEAR(driver); 214 215 /* Release regular key */ 216 EXPECT_EMPTY_REPORT(driver); 217 regular_key.release(); 218 run_one_scan_loop(); 219 VERIFY_AND_CLEAR(driver); 220 221 /* Press regular key */ 222 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); 223 regular_key.press(); 224 run_one_scan_loop(); 225 VERIFY_AND_CLEAR(driver); 226 227 /* Release regular key */ 228 EXPECT_EMPTY_REPORT(driver); 229 regular_key.release(); 230 run_one_scan_loop(); 231 VERIFY_AND_CLEAR(driver); 232 } 233 234 TEST_F(OneShot, OSMHoldNotLockingOSMs) { 235 TestDriver driver; 236 InSequence s; 237 KeymapKey osm_key1 = KeymapKey{0, 0, 0, OSM(MOD_LSFT), KC_LSFT}; 238 KeymapKey osm_key2 = KeymapKey{0, 0, 1, OSM(MOD_LCTL), KC_LCTL}; 239 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A}; 240 241 set_keymap({osm_key1, osm_key2, regular_key}); 242 243 /* Press and release OSM1 */ 244 EXPECT_NO_REPORT(driver); 245 tap_key(osm_key1); 246 VERIFY_AND_CLEAR(driver); 247 248 /* Press and hold OSM2 */ 249 EXPECT_REPORT(driver, (osm_key1.report_code, osm_key2.report_code)).Times(1); 250 osm_key2.press(); 251 run_one_scan_loop(); 252 idle_for(TAPPING_TERM); 253 VERIFY_AND_CLEAR(driver); 254 255 /* Press and release regular key */ 256 EXPECT_REPORT(driver, (osm_key1.report_code, osm_key2.report_code, regular_key.report_code)).Times(1); 257 EXPECT_REPORT(driver, (osm_key2.report_code)).Times(1); 258 tap_key(regular_key); 259 VERIFY_AND_CLEAR(driver); 260 261 /* Release OSM2 */ 262 EXPECT_EMPTY_REPORT(driver); 263 osm_key2.release(); 264 run_one_scan_loop(); 265 VERIFY_AND_CLEAR(driver); 266 267 /* Press regular key */ 268 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); 269 regular_key.press(); 270 run_one_scan_loop(); 271 VERIFY_AND_CLEAR(driver); 272 273 /* Release regular key */ 274 EXPECT_EMPTY_REPORT(driver); 275 regular_key.release(); 276 run_one_scan_loop(); 277 VERIFY_AND_CLEAR(driver); 278 } 279 280 TEST_F(OneShot, OSLWithAdditionalKeypress) { 281 TestDriver driver; 282 InSequence s; 283 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)}; 284 KeymapKey regular_key = KeymapKey{1, 1, 0, KC_A}; 285 286 set_keymap({osl_key, regular_key}); 287 288 /* Press OSL key */ 289 EXPECT_NO_REPORT(driver); 290 osl_key.press(); 291 run_one_scan_loop(); 292 VERIFY_AND_CLEAR(driver); 293 294 /* Release OSL key */ 295 EXPECT_NO_REPORT(driver); 296 osl_key.release(); 297 run_one_scan_loop(); 298 VERIFY_AND_CLEAR(driver); 299 300 /* Press regular key */ 301 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); 302 EXPECT_EMPTY_REPORT(driver); 303 regular_key.press(); 304 run_one_scan_loop(); 305 VERIFY_AND_CLEAR(driver); 306 307 /* Release regular key */ 308 EXPECT_NO_REPORT(driver); 309 regular_key.release(); 310 run_one_scan_loop(); 311 VERIFY_AND_CLEAR(driver); 312 } 313 314 TEST_F(OneShot, OSLWithOsmAndAdditionalKeypress) { 315 TestDriver driver; 316 InSequence s; 317 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)}; 318 KeymapKey osm_key = KeymapKey{1, 1, 0, OSM(MOD_LSFT), KC_LSFT}; 319 KeymapKey regular_key = KeymapKey{1, 1, 1, KC_A}; 320 321 set_keymap({osl_key, osm_key, regular_key}); 322 323 /* Press OSL key */ 324 EXPECT_NO_REPORT(driver); 325 osl_key.press(); 326 run_one_scan_loop(); 327 VERIFY_AND_CLEAR(driver); 328 329 /* Release OSL key */ 330 EXPECT_NO_REPORT(driver); 331 osl_key.release(); 332 run_one_scan_loop(); 333 EXPECT_TRUE(layer_state_is(1)); 334 VERIFY_AND_CLEAR(driver); 335 336 /* Press and release OSM */ 337 EXPECT_NO_REPORT(driver); 338 tap_key(osm_key); 339 EXPECT_TRUE(layer_state_is(1)); 340 VERIFY_AND_CLEAR(driver); 341 342 /* Press regular key */ 343 EXPECT_REPORT(driver, (osm_key.report_code, regular_key.report_code)).Times(1); 344 EXPECT_EMPTY_REPORT(driver); 345 regular_key.press(); 346 run_one_scan_loop(); 347 EXPECT_FALSE(layer_state_is(1)); 348 VERIFY_AND_CLEAR(driver); 349 350 /* Release regular key */ 351 EXPECT_NO_REPORT(driver); 352 regular_key.release(); 353 run_one_scan_loop(); 354 VERIFY_AND_CLEAR(driver); 355 } 356 357 TEST_F(OneShot, OSLWithMoAndAdditionalKeypress) { 358 TestDriver driver; 359 InSequence s; 360 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)}; 361 KeymapKey mo_key = KeymapKey{1, 1, 0, MO(2)}; 362 KeymapKey regular_key = KeymapKey{2, 1, 1, KC_A}; 363 364 set_keymap({osl_key, mo_key, regular_key}); 365 366 /* Press OSL key */ 367 EXPECT_NO_REPORT(driver); 368 osl_key.press(); 369 run_one_scan_loop(); 370 VERIFY_AND_CLEAR(driver); 371 372 /* Release OSL key */ 373 EXPECT_NO_REPORT(driver); 374 osl_key.release(); 375 run_one_scan_loop(); 376 EXPECT_TRUE(layer_state_is(1)); 377 VERIFY_AND_CLEAR(driver); 378 379 /* Press MO */ 380 EXPECT_NO_REPORT(driver); 381 mo_key.press(); 382 run_one_scan_loop(); 383 EXPECT_TRUE(layer_state_is(2)); 384 VERIFY_AND_CLEAR(driver); 385 386 /* Press regular key */ 387 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); 388 regular_key.press(); 389 run_one_scan_loop(); 390 EXPECT_TRUE(layer_state_is(2)); 391 VERIFY_AND_CLEAR(driver); 392 393 /* Release regular key */ 394 EXPECT_EMPTY_REPORT(driver); 395 regular_key.release(); 396 run_one_scan_loop(); 397 VERIFY_AND_CLEAR(driver); 398 399 /* Release MO */ 400 EXPECT_NO_REPORT(driver); 401 mo_key.release(); 402 run_one_scan_loop(); 403 EXPECT_TRUE(layer_state_is(0)); 404 VERIFY_AND_CLEAR(driver); 405 } 406 407 class OneShotLayerParametrizedTestFixture : public ::testing::WithParamInterface<uint16_t>, public OneShot {}; 408 409 TEST_P(OneShotLayerParametrizedTestFixture, OSLWithActionAndAdditionalKeypress) { 410 TestDriver driver; 411 InSequence s; 412 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)}; 413 KeymapKey action_key = KeymapKey{1, 1, 0, GetParam()}; 414 KeymapKey regular_key = KeymapKey{2, 1, 1, KC_A}; 415 416 set_keymap({osl_key, action_key, regular_key}); 417 418 /* Tap OSL key */ 419 EXPECT_NO_REPORT(driver); 420 tap_key(osl_key); 421 run_one_scan_loop(); 422 VERIFY_AND_CLEAR(driver); 423 424 /* Tag Action key */ 425 EXPECT_NO_REPORT(driver); 426 tap_key(action_key); 427 run_one_scan_loop(); 428 EXPECT_TRUE(layer_state_is(2)); 429 VERIFY_AND_CLEAR(driver); 430 431 /* Press regular key */ 432 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); 433 regular_key.press(); 434 run_one_scan_loop(); 435 EXPECT_TRUE(layer_state_is(2)); 436 VERIFY_AND_CLEAR(driver); 437 438 /* Release regular key */ 439 EXPECT_EMPTY_REPORT(driver); 440 regular_key.release(); 441 run_one_scan_loop(); 442 VERIFY_AND_CLEAR(driver); 443 } 444 445 INSTANTIATE_TEST_CASE_P(OneShotLayerTests, OneShotLayerParametrizedTestFixture, ::testing::Values(TG(2), TO(2))); 446 447 TEST_F(OneShot, OSLWithDFAndAdditionalKeypress) { 448 TestDriver driver; 449 InSequence s; 450 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)}; 451 KeymapKey df_key = KeymapKey{1, 1, 0, DF(2)}; 452 KeymapKey regular_key = KeymapKey{2, 1, 1, KC_A}; 453 454 set_keymap({osl_key, df_key, regular_key}); 455 456 layer_state_t default_layer_state_bak = default_layer_state; 457 458 /* Tap OSL key */ 459 EXPECT_NO_REPORT(driver); 460 tap_key(osl_key); 461 run_one_scan_loop(); 462 EXPECT_TRUE(layer_state_is(1)); 463 VERIFY_AND_CLEAR(driver); 464 465 /* Press DF key */ 466 EXPECT_NO_REPORT(driver); 467 df_key.press(); 468 run_one_scan_loop(); 469 EXPECT_EQ(default_layer_state, 0b001); 470 471 VERIFY_AND_CLEAR(driver); 472 473 /* Release DF key */ 474 EXPECT_NO_REPORT(driver); 475 df_key.release(); 476 run_one_scan_loop(); 477 EXPECT_EQ(default_layer_state, 0b100); 478 VERIFY_AND_CLEAR(driver); 479 480 /* Press regular key */ 481 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); 482 regular_key.press(); 483 run_one_scan_loop(); 484 VERIFY_AND_CLEAR(driver); 485 486 /* Release regular key */ 487 EXPECT_EMPTY_REPORT(driver); 488 regular_key.release(); 489 run_one_scan_loop(); 490 VERIFY_AND_CLEAR(driver); 491 492 default_layer_state = default_layer_state_bak; 493 } 494 495 TEST_F(OneShot, OSLChainingTwoOSLsAndAdditionalKeypress) { 496 TestDriver driver; 497 InSequence s; 498 KeymapKey osl1_key = KeymapKey{0, 0, 0, OSL(1)}; 499 KeymapKey osl2_key = KeymapKey{1, 1, 0, OSL(2)}; 500 KeymapKey regular_key = KeymapKey{2, 1, 1, KC_A}; 501 502 set_keymap({osl1_key, osl2_key, regular_key}); 503 504 /* Press and release first OSL key */ 505 EXPECT_NO_REPORT(driver); 506 osl1_key.press(); 507 run_one_scan_loop(); 508 osl1_key.release(); 509 run_one_scan_loop(); 510 EXPECT_TRUE(layer_state_is(1)); 511 VERIFY_AND_CLEAR(driver); 512 513 /* Press and release second OSL */ 514 EXPECT_NO_REPORT(driver); 515 osl2_key.press(); 516 run_one_scan_loop(); 517 osl2_key.release(); 518 run_one_scan_loop(); 519 EXPECT_TRUE(layer_state_is(2)); 520 VERIFY_AND_CLEAR(driver); 521 522 /* Press regular key */ 523 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); 524 EXPECT_EMPTY_REPORT(driver); 525 regular_key.press(); 526 run_one_scan_loop(); 527 VERIFY_AND_CLEAR(driver); 528 529 /* Release regular key */ 530 EXPECT_NO_REPORT(driver); 531 regular_key.release(); 532 run_one_scan_loop(); 533 EXPECT_TRUE(layer_state_is(0)); 534 VERIFY_AND_CLEAR(driver); 535 } 536 537 TEST_F(OneShot, OSLWithShortLT) { 538 TestDriver driver; 539 InSequence s; 540 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)}; 541 KeymapKey lt_key = KeymapKey(1, 1, 0, LT(2, KC_A)); 542 543 set_keymap({osl_key, lt_key}); 544 545 /* Tap OSL key */ 546 EXPECT_NO_REPORT(driver); 547 tap_key(osl_key); 548 run_one_scan_loop(); 549 EXPECT_TRUE(layer_state_is(1)); 550 VERIFY_AND_CLEAR(driver); 551 552 /* Tap LT key. */ 553 EXPECT_REPORT(driver, (lt_key.report_code)).Times(1); 554 EXPECT_EMPTY_REPORT(driver); 555 tap_key(lt_key); 556 run_one_scan_loop(); 557 EXPECT_TRUE(layer_state_is(0)); 558 VERIFY_AND_CLEAR(driver); 559 } 560 561 TEST_F(OneShot, OSLWithLongLTAndRegularKey) { 562 TestDriver driver; 563 InSequence s; 564 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)}; 565 KeymapKey lt_key = KeymapKey(1, 1, 0, LT(2, KC_A)); 566 KeymapKey regular_key = KeymapKey(2, 1, 1, KC_B); 567 568 set_keymap({osl_key, lt_key, regular_key}); 569 570 /* Tap OSL key */ 571 EXPECT_NO_REPORT(driver); 572 tap_key(osl_key); 573 run_one_scan_loop(); 574 EXPECT_TRUE(layer_state_is(1)); 575 VERIFY_AND_CLEAR(driver); 576 577 /* Press LT key. */ 578 EXPECT_NO_REPORT(driver); 579 lt_key.press(); 580 run_one_scan_loop(); 581 VERIFY_AND_CLEAR(driver); 582 583 /* Idle for tapping term of mod tap hold key. */ 584 EXPECT_NO_REPORT(driver); 585 idle_for(TAPPING_TERM + 1); 586 VERIFY_AND_CLEAR(driver); 587 EXPECT_TRUE(layer_state_is(2)); 588 589 /* Press regular key. */ 590 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); 591 regular_key.press(); 592 run_one_scan_loop(); 593 VERIFY_AND_CLEAR(driver); 594 595 /* Release regular key. */ 596 EXPECT_EMPTY_REPORT(driver); 597 regular_key.release(); 598 run_one_scan_loop(); 599 VERIFY_AND_CLEAR(driver); 600 } 601 602 TEST_F(OneShot, OSLWithShortModTapKeyAndRegularKey) { 603 TestDriver driver; 604 InSequence s; 605 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)}; 606 KeymapKey mod_tap_hold_key = KeymapKey(1, 1, 0, SFT_T(KC_P)); 607 KeymapKey regular_key = KeymapKey(0, 2, 0, KC_A); 608 609 set_keymap({osl_key, mod_tap_hold_key, regular_key}); 610 611 /* Tap OSL key */ 612 EXPECT_NO_REPORT(driver); 613 tap_key(osl_key); 614 run_one_scan_loop(); 615 EXPECT_TRUE(layer_state_is(1)); 616 VERIFY_AND_CLEAR(driver); 617 618 /* Press mod-tap-hold key. */ 619 EXPECT_NO_REPORT(driver); 620 mod_tap_hold_key.press(); 621 run_one_scan_loop(); 622 VERIFY_AND_CLEAR(driver); 623 624 /* Release mod-tap-hold key. */ 625 EXPECT_REPORT(driver, (KC_P)); 626 EXPECT_EMPTY_REPORT(driver); 627 mod_tap_hold_key.release(); 628 run_one_scan_loop(); 629 VERIFY_AND_CLEAR(driver); 630 631 /* Press regular key. */ 632 EXPECT_REPORT(driver, (regular_key.report_code)); 633 regular_key.press(); 634 run_one_scan_loop(); 635 VERIFY_AND_CLEAR(driver); 636 637 /* Release regular key. */ 638 EXPECT_EMPTY_REPORT(driver); 639 regular_key.release(); 640 run_one_scan_loop(); 641 VERIFY_AND_CLEAR(driver); 642 } 643 644 TEST_F(OneShot, OSLWithLongModTapKeyAndRegularKey) { 645 TestDriver driver; 646 InSequence s; 647 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)}; 648 KeymapKey mod_tap_hold_key = KeymapKey(1, 1, 0, SFT_T(KC_P)); 649 KeymapKey regular_key = KeymapKey(1, 2, 0, KC_A); 650 651 set_keymap({osl_key, mod_tap_hold_key, regular_key}); 652 653 /* Tap OSL key */ 654 EXPECT_NO_REPORT(driver); 655 tap_key(osl_key); 656 run_one_scan_loop(); 657 EXPECT_TRUE(layer_state_is(1)); 658 VERIFY_AND_CLEAR(driver); 659 660 /* Press mod-tap-hold key. */ 661 EXPECT_NO_REPORT(driver); 662 mod_tap_hold_key.press(); 663 run_one_scan_loop(); 664 VERIFY_AND_CLEAR(driver); 665 666 /* Idle for tapping term of mod tap hold key. */ 667 EXPECT_REPORT(driver, (KC_LSFT)); 668 idle_for(TAPPING_TERM + 1); 669 VERIFY_AND_CLEAR(driver); 670 671 /* Release mod-tap-hold key. */ 672 EXPECT_EMPTY_REPORT(driver); 673 mod_tap_hold_key.release(); 674 run_one_scan_loop(); 675 VERIFY_AND_CLEAR(driver); 676 677 /* Press regular key. */ 678 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); 679 EXPECT_EMPTY_REPORT(driver); 680 regular_key.press(); 681 run_one_scan_loop(); 682 VERIFY_AND_CLEAR(driver); 683 684 /* Release regular key. */ 685 EXPECT_NO_REPORT(driver); 686 regular_key.release(); 687 run_one_scan_loop(); 688 VERIFY_AND_CLEAR(driver); 689 }