test_tap_hold.cpp (24228B)
1 // Copyright 2025 Google LLC 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // https://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #include "keyboard_report_util.hpp" 16 #include "keycode.h" 17 #include "test_common.hpp" 18 #include "action_tapping.h" 19 #include "test_fixture.hpp" 20 #include "test_keymap_key.hpp" 21 22 using testing::_; 23 using testing::AnyNumber; 24 using testing::InSequence; 25 26 class FlowTapTest : public TestFixture {}; 27 28 // Test an input of quick distinct taps. All should be settled as tapped. 29 TEST_F(FlowTapTest, distinct_taps) { 30 TestDriver driver; 31 InSequence s; 32 auto regular_key = KeymapKey(0, 0, 0, KC_A); 33 auto mod_tap_key1 = KeymapKey(0, 1, 0, SFT_T(KC_B)); 34 auto mod_tap_key2 = KeymapKey(0, 2, 0, CTL_T(KC_C)); 35 auto mod_tap_key3 = KeymapKey(0, 3, 0, ALT_T(KC_D)); 36 37 set_keymap({regular_key, mod_tap_key1, mod_tap_key2, mod_tap_key3}); 38 39 // Tap regular key. 40 EXPECT_REPORT(driver, (KC_A)); 41 EXPECT_EMPTY_REPORT(driver); 42 tap_key(regular_key, FLOW_TAP_TERM + 1); 43 VERIFY_AND_CLEAR(driver); 44 45 // Tap mod-tap 1. 46 EXPECT_REPORT(driver, (KC_B)); 47 mod_tap_key1.press(); 48 run_one_scan_loop(); 49 VERIFY_AND_CLEAR(driver); 50 51 EXPECT_EMPTY_REPORT(driver); 52 idle_for(FLOW_TAP_TERM + 1); 53 mod_tap_key1.release(); 54 run_one_scan_loop(); 55 VERIFY_AND_CLEAR(driver); 56 57 // Tap mod-tap 2. 58 EXPECT_REPORT(driver, (KC_C)); 59 mod_tap_key2.press(); 60 run_one_scan_loop(); 61 VERIFY_AND_CLEAR(driver); 62 63 EXPECT_EMPTY_REPORT(driver); 64 idle_for(FLOW_TAP_TERM + 1); 65 mod_tap_key2.release(); 66 run_one_scan_loop(); 67 VERIFY_AND_CLEAR(driver); 68 69 // Tap mod-tap 3. 70 EXPECT_REPORT(driver, (KC_D)); 71 mod_tap_key3.press(); 72 run_one_scan_loop(); 73 VERIFY_AND_CLEAR(driver); 74 75 EXPECT_EMPTY_REPORT(driver); 76 idle_for(FLOW_TAP_TERM + 1); 77 mod_tap_key3.release(); 78 idle_for(FLOW_TAP_TERM + 1); // Pause between taps. 79 VERIFY_AND_CLEAR(driver); 80 81 // Tap mod-tap 1. 82 EXPECT_NO_REPORT(driver); 83 mod_tap_key1.press(); 84 run_one_scan_loop(); 85 VERIFY_AND_CLEAR(driver); 86 87 EXPECT_REPORT(driver, (KC_B)); 88 EXPECT_EMPTY_REPORT(driver); 89 idle_for(FLOW_TAP_TERM + 1); 90 mod_tap_key1.release(); 91 run_one_scan_loop(); 92 VERIFY_AND_CLEAR(driver); 93 94 // Tap mod-tap 2. 95 EXPECT_REPORT(driver, (KC_C)); 96 mod_tap_key2.press(); 97 run_one_scan_loop(); 98 VERIFY_AND_CLEAR(driver); 99 100 EXPECT_EMPTY_REPORT(driver); 101 idle_for(TAPPING_TERM + 1); 102 mod_tap_key2.release(); 103 idle_for(FLOW_TAP_TERM + 1); 104 VERIFY_AND_CLEAR(driver); 105 } 106 107 // By default, Flow Tap is disabled when mods other than Shift and AltGr are on. 108 TEST_F(FlowTapTest, hotkey_taps) { 109 TestDriver driver; 110 InSequence s; 111 auto ctrl_key = KeymapKey(0, 0, 0, KC_LCTL); 112 auto shft_key = KeymapKey(0, 1, 0, KC_LSFT); 113 auto alt_key = KeymapKey(0, 2, 0, KC_LALT); 114 auto gui_key = KeymapKey(0, 3, 0, KC_LGUI); 115 auto regular_key = KeymapKey(0, 4, 0, KC_A); 116 auto mod_tap_key = KeymapKey(0, 5, 0, RCTL_T(KC_B)); 117 118 set_keymap({ctrl_key, shft_key, alt_key, gui_key, regular_key, mod_tap_key}); 119 120 for (KeymapKey* mod_key : {&ctrl_key, &alt_key, &gui_key}) { 121 // Hold mod key. 122 EXPECT_REPORT(driver, (mod_key->code)); 123 mod_key->press(); 124 run_one_scan_loop(); 125 126 // Tap regular key. 127 EXPECT_REPORT(driver, (mod_key->code, KC_A)); 128 regular_key.press(); 129 run_one_scan_loop(); 130 VERIFY_AND_CLEAR(driver); 131 132 EXPECT_REPORT(driver, (mod_key->code)); 133 regular_key.release(); 134 run_one_scan_loop(); 135 VERIFY_AND_CLEAR(driver); 136 137 // Press mod-tap, where Flow Tap is disabled due to the held mod. 138 EXPECT_REPORT(driver, (mod_key->code, KC_RCTL)); 139 mod_tap_key.press(); 140 idle_for(TAPPING_TERM + 1); 141 VERIFY_AND_CLEAR(driver); 142 143 // Release mod-tap. 144 EXPECT_REPORT(driver, (mod_key->code)); 145 mod_tap_key.release(); 146 run_one_scan_loop(); 147 148 // Release mod key. 149 EXPECT_EMPTY_REPORT(driver); 150 mod_key->release(); 151 run_one_scan_loop(); 152 VERIFY_AND_CLEAR(driver); 153 } 154 155 // Hold Shift key. 156 EXPECT_REPORT(driver, (KC_LSFT)); 157 shft_key.press(); 158 run_one_scan_loop(); 159 160 // Tap regular key. 161 EXPECT_REPORT(driver, (KC_LSFT, KC_A)); 162 regular_key.press(); 163 run_one_scan_loop(); 164 VERIFY_AND_CLEAR(driver); 165 166 EXPECT_REPORT(driver, (KC_LSFT)); 167 regular_key.release(); 168 run_one_scan_loop(); 169 VERIFY_AND_CLEAR(driver); 170 171 // Press mod-tap, where Flow Tap applies to settle as tapped. 172 EXPECT_REPORT(driver, (KC_LSFT, KC_B)); 173 mod_tap_key.press(); 174 idle_for(TAPPING_TERM + 1); 175 VERIFY_AND_CLEAR(driver); 176 177 // Release mod-tap. 178 EXPECT_REPORT(driver, (KC_LSFT)); 179 mod_tap_key.release(); 180 run_one_scan_loop(); 181 182 // Release Shift key. 183 EXPECT_EMPTY_REPORT(driver); 184 shft_key.release(); 185 run_one_scan_loop(); 186 VERIFY_AND_CLEAR(driver); 187 } 188 189 // Test input with two mod-taps in a rolled press quickly after a regular key. 190 TEST_F(FlowTapTest, rolled_press) { 191 TestDriver driver; 192 InSequence s; 193 auto regular_key = KeymapKey(0, 0, 0, KC_A); 194 auto mod_tap_key1 = KeymapKey(0, 1, 0, SFT_T(KC_B)); 195 auto mod_tap_key2 = KeymapKey(0, 2, 0, CTL_T(KC_C)); 196 197 set_keymap({regular_key, mod_tap_key1, mod_tap_key2}); 198 199 // Tap regular key. 200 EXPECT_REPORT(driver, (KC_A)); 201 EXPECT_EMPTY_REPORT(driver); 202 tap_key(regular_key); 203 VERIFY_AND_CLEAR(driver); 204 205 // Press mod-tap key 1 quickly after regular key. The mod-tap should settle 206 // immediately as tapped, sending `KC_B`. 207 EXPECT_REPORT(driver, (KC_B)); 208 mod_tap_key1.press(); 209 run_one_scan_loop(); 210 VERIFY_AND_CLEAR(driver); 211 212 // Press mod-tap key 2 quickly. 213 EXPECT_REPORT(driver, (KC_B, KC_C)); 214 mod_tap_key2.press(); 215 run_one_scan_loop(); 216 VERIFY_AND_CLEAR(driver); 217 218 // Hold for longer than the tapping term. 219 EXPECT_NO_REPORT(driver); 220 idle_for(TAPPING_TERM + 1); 221 VERIFY_AND_CLEAR(driver); 222 223 // Release mod-tap keys. 224 EXPECT_REPORT(driver, (KC_C)); 225 EXPECT_EMPTY_REPORT(driver); 226 mod_tap_key1.release(); 227 run_one_scan_loop(); 228 mod_tap_key2.release(); 229 run_one_scan_loop(); 230 VERIFY_AND_CLEAR(driver); 231 } 232 233 TEST_F(FlowTapTest, long_flow_tap_settled_as_held) { 234 TestDriver driver; 235 InSequence s; 236 auto regular_key = KeymapKey(0, 0, 0, KC_A); 237 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_B)); 238 239 set_keymap({regular_key, mod_tap_key}); 240 241 // Tap regular key. 242 EXPECT_REPORT(driver, (KC_A)); 243 EXPECT_EMPTY_REPORT(driver); 244 tap_key(regular_key); 245 VERIFY_AND_CLEAR(driver); 246 247 EXPECT_NO_REPORT(driver); 248 idle_for(FLOW_TAP_TERM + 1); 249 VERIFY_AND_CLEAR(driver); 250 251 // Press mod-tap key. 252 EXPECT_NO_REPORT(driver); 253 mod_tap_key.press(); 254 run_one_scan_loop(); 255 VERIFY_AND_CLEAR(driver); 256 257 // Hold for the tapping term. 258 EXPECT_REPORT(driver, (KC_LSFT)); 259 idle_for(TAPPING_TERM); 260 VERIFY_AND_CLEAR(driver); 261 262 // Release mod-tap key. 263 EXPECT_EMPTY_REPORT(driver); 264 mod_tap_key.release(); 265 run_one_scan_loop(); 266 VERIFY_AND_CLEAR(driver); 267 } 268 269 TEST_F(FlowTapTest, holding_multiple_mod_taps) { 270 TestDriver driver; 271 InSequence s; 272 auto regular_key = KeymapKey(0, 0, 0, KC_A); 273 auto mod_tap_key1 = KeymapKey(0, 1, 0, SFT_T(KC_B)); 274 auto mod_tap_key2 = KeymapKey(0, 2, 0, CTL_T(KC_C)); 275 276 set_keymap({regular_key, mod_tap_key1, mod_tap_key2}); 277 278 // Tap regular key. 279 EXPECT_REPORT(driver, (KC_A)); 280 EXPECT_EMPTY_REPORT(driver); 281 tap_key(regular_key); 282 VERIFY_AND_CLEAR(driver); 283 284 EXPECT_NO_REPORT(driver); 285 idle_for(FLOW_TAP_TERM + 1); 286 VERIFY_AND_CLEAR(driver); 287 288 // Press mod-tap keys. 289 EXPECT_NO_REPORT(driver); 290 mod_tap_key1.press(); 291 run_one_scan_loop(); 292 mod_tap_key2.press(); 293 idle_for(TAPPING_TERM - 5); // Hold almost until tapping term. 294 VERIFY_AND_CLEAR(driver); 295 296 // Press regular key. 297 EXPECT_REPORT(driver, (KC_LSFT)); 298 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL)); 299 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL, KC_A)); 300 regular_key.press(); 301 idle_for(10); 302 VERIFY_AND_CLEAR(driver); 303 304 // Release keys. 305 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL)); 306 EXPECT_REPORT(driver, (KC_LCTL)); 307 EXPECT_EMPTY_REPORT(driver); 308 regular_key.release(); 309 run_one_scan_loop(); 310 mod_tap_key1.release(); 311 run_one_scan_loop(); 312 mod_tap_key2.release(); 313 run_one_scan_loop(); 314 VERIFY_AND_CLEAR(driver); 315 } 316 317 TEST_F(FlowTapTest, holding_mod_tap_with_regular_mod) { 318 TestDriver driver; 319 InSequence s; 320 auto regular_key = KeymapKey(0, 0, 0, KC_A); 321 auto mod_key = KeymapKey(0, 1, 0, KC_LSFT); 322 auto mod_tap_key = KeymapKey(0, 2, 0, CTL_T(KC_C)); 323 324 set_keymap({regular_key, mod_key, mod_tap_key}); 325 326 // Tap regular key. 327 EXPECT_REPORT(driver, (KC_A)); 328 EXPECT_EMPTY_REPORT(driver); 329 tap_key(regular_key); 330 VERIFY_AND_CLEAR(driver); 331 332 EXPECT_NO_REPORT(driver); 333 idle_for(FLOW_TAP_TERM + 1); 334 VERIFY_AND_CLEAR(driver); 335 336 // Press mod and mod-tap keys. 337 EXPECT_REPORT(driver, (KC_LSFT)); 338 mod_key.press(); 339 run_one_scan_loop(); 340 mod_tap_key.press(); 341 idle_for(TAPPING_TERM - 5); // Hold almost until tapping term. 342 VERIFY_AND_CLEAR(driver); 343 344 // Press regular key. 345 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL)); 346 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL, KC_A)); 347 regular_key.press(); 348 idle_for(10); 349 VERIFY_AND_CLEAR(driver); 350 351 // Release keys. 352 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL)); 353 EXPECT_REPORT(driver, (KC_LCTL)); 354 EXPECT_EMPTY_REPORT(driver); 355 regular_key.release(); 356 run_one_scan_loop(); 357 mod_key.release(); 358 run_one_scan_loop(); 359 mod_tap_key.release(); 360 run_one_scan_loop(); 361 VERIFY_AND_CLEAR(driver); 362 } 363 364 TEST_F(FlowTapTest, layer_tap_key) { 365 TestDriver driver; 366 InSequence s; 367 auto regular_key = KeymapKey(0, 0, 0, KC_A); 368 auto layer_tap_key = KeymapKey(0, 1, 0, LT(1, KC_B)); 369 auto regular_key2 = KeymapKey(1, 0, 0, KC_C); 370 371 set_keymap({regular_key, layer_tap_key, regular_key2}); 372 373 // Tap regular key. 374 EXPECT_REPORT(driver, (KC_A)); 375 EXPECT_EMPTY_REPORT(driver); 376 tap_key(regular_key); 377 VERIFY_AND_CLEAR(driver); 378 379 // Press layer-tap key, quickly after the regular key. 380 EXPECT_REPORT(driver, (KC_B)); 381 layer_tap_key.press(); 382 run_one_scan_loop(); 383 VERIFY_AND_CLEAR(driver); 384 385 EXPECT_NO_REPORT(driver); 386 idle_for(TAPPING_TERM + 1); 387 VERIFY_AND_CLEAR(driver); 388 389 // Release layer-tap key. 390 EXPECT_EMPTY_REPORT(driver); 391 layer_tap_key.release(); 392 run_one_scan_loop(); 393 394 // Tap regular key. 395 EXPECT_REPORT(driver, (KC_A)); 396 EXPECT_EMPTY_REPORT(driver); 397 tap_key(regular_key); 398 VERIFY_AND_CLEAR(driver); 399 400 EXPECT_NO_REPORT(driver); 401 idle_for(FLOW_TAP_TERM + 1); 402 VERIFY_AND_CLEAR(driver); 403 404 // Press layer-tap key, slowly after the regular key. 405 EXPECT_NO_REPORT(driver); 406 layer_tap_key.press(); 407 run_one_scan_loop(); 408 VERIFY_AND_CLEAR(driver); 409 410 EXPECT_NO_REPORT(driver); 411 idle_for(TAPPING_TERM + 1); 412 EXPECT_EQ(layer_state, 1 << 1); 413 VERIFY_AND_CLEAR(driver); 414 415 // Tap regular key2. 416 EXPECT_REPORT(driver, (KC_C)); 417 EXPECT_EMPTY_REPORT(driver); 418 tap_key(regular_key); 419 VERIFY_AND_CLEAR(driver); 420 421 // Release layer-tap key. 422 EXPECT_NO_REPORT(driver); 423 layer_tap_key.release(); 424 run_one_scan_loop(); 425 VERIFY_AND_CLEAR(driver); 426 } 427 428 TEST_F(FlowTapTest, layer_tap_ignored_with_disabled_key) { 429 TestDriver driver; 430 InSequence s; 431 auto no_key = KeymapKey(0, 0, 0, KC_NO); 432 auto regular_key = KeymapKey(1, 0, 0, KC_ESC); 433 auto layer_tap_key = KeymapKey(0, 1, 0, LT(1, KC_A)); 434 auto mod_tap_key = KeymapKey(0, 2, 0, CTL_T(KC_B)); 435 436 set_keymap({no_key, regular_key, layer_tap_key, mod_tap_key}); 437 438 EXPECT_REPORT(driver, (KC_ESC)); 439 EXPECT_EMPTY_REPORT(driver); 440 layer_tap_key.press(); 441 idle_for(TAPPING_TERM + 1); 442 tap_key(regular_key); 443 layer_tap_key.release(); 444 run_one_scan_loop(); 445 VERIFY_AND_CLEAR(driver); 446 447 EXPECT_REPORT(driver, (KC_LCTL)); 448 mod_tap_key.press(); 449 idle_for(TAPPING_TERM + 1); 450 VERIFY_AND_CLEAR(driver); 451 452 EXPECT_EMPTY_REPORT(driver); 453 mod_tap_key.release(); 454 run_one_scan_loop(); 455 VERIFY_AND_CLEAR(driver); 456 } 457 458 TEST_F(FlowTapTest, layer_tap_ignored_with_disabled_key_complex) { 459 TestDriver driver; 460 InSequence s; 461 auto regular_key1 = KeymapKey(0, 0, 0, KC_Q); 462 auto layer_tap_key = KeymapKey(0, 1, 0, LT(1, KC_SPC)); 463 auto mod_tap_key1 = KeymapKey(0, 2, 0, CTL_T(KC_T)); 464 // Place RALT_T(KC_I), where Flow Tap is enabled, in the same position on 465 // layer 0 as KC_RGHT, where Flow Tap is disabled. This tests that Flow Tap 466 // tracks the keycode from the correct layer. 467 auto mod_tap_key2 = KeymapKey(0, 3, 0, RALT_T(KC_I)); 468 auto regular_key2 = KeymapKey(1, 3, 0, KC_RGHT); 469 470 set_keymap({regular_key1, layer_tap_key, mod_tap_key1, mod_tap_key2, regular_key2}); 471 472 // Tap regular key 1. 473 EXPECT_REPORT(driver, (KC_Q)); 474 EXPECT_EMPTY_REPORT(driver); 475 tap_key(regular_key1); 476 idle_for(FLOW_TAP_TERM + 1); 477 VERIFY_AND_CLEAR(driver); 478 479 // Hold layer-tap key. 480 EXPECT_NO_REPORT(driver); 481 layer_tap_key.press(); 482 run_one_scan_loop(); 483 // idle_for(TAPPING_TERM + 1); 484 VERIFY_AND_CLEAR(driver); 485 486 // Tap regular key 2. 487 EXPECT_REPORT(driver, (KC_RGHT)); 488 EXPECT_EMPTY_REPORT(driver); 489 tap_key(regular_key2); 490 VERIFY_AND_CLEAR(driver); 491 492 // Release layer-tap key. 493 EXPECT_NO_REPORT(driver); 494 layer_tap_key.release(); 495 run_one_scan_loop(); 496 VERIFY_AND_CLEAR(driver); 497 498 // Quickly hold mod-tap key 1. 499 EXPECT_NO_REPORT(driver); 500 mod_tap_key1.press(); 501 run_one_scan_loop(); 502 VERIFY_AND_CLEAR(driver); 503 504 EXPECT_REPORT(driver, (KC_LCTL)); 505 EXPECT_REPORT(driver, (KC_LCTL, KC_Q)); 506 EXPECT_REPORT(driver, (KC_LCTL)); 507 tap_key(regular_key1); 508 VERIFY_AND_CLEAR(driver); 509 510 EXPECT_EMPTY_REPORT(driver); 511 mod_tap_key1.release(); 512 run_one_scan_loop(); 513 VERIFY_AND_CLEAR(driver); 514 } 515 516 TEST_F(FlowTapTest, layer_tap_ignored_with_enabled_key) { 517 TestDriver driver; 518 InSequence s; 519 auto no_key = KeymapKey(0, 0, 0, KC_NO); 520 auto regular_key = KeymapKey(1, 0, 0, KC_C); 521 auto layer_tap_key = KeymapKey(0, 1, 0, LT(1, KC_A)); 522 auto mod_tap_key = KeymapKey(0, 2, 0, CTL_T(KC_B)); 523 524 set_keymap({no_key, regular_key, layer_tap_key, mod_tap_key}); 525 526 EXPECT_REPORT(driver, (KC_C)); 527 EXPECT_EMPTY_REPORT(driver); 528 layer_tap_key.press(); 529 idle_for(TAPPING_TERM + 1); 530 tap_key(regular_key); 531 layer_tap_key.release(); 532 run_one_scan_loop(); 533 VERIFY_AND_CLEAR(driver); 534 535 EXPECT_REPORT(driver, (KC_B)); 536 mod_tap_key.press(); 537 run_one_scan_loop(); 538 VERIFY_AND_CLEAR(driver); 539 540 EXPECT_EMPTY_REPORT(driver); 541 idle_for(TAPPING_TERM + 1); 542 mod_tap_key.release(); 543 run_one_scan_loop(); 544 VERIFY_AND_CLEAR(driver); 545 } 546 547 TEST_F(FlowTapTest, combo_key) { 548 TestDriver driver; 549 InSequence s; 550 auto regular_key = KeymapKey(0, 0, 0, KC_A); 551 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_X)); 552 auto layer_tap_key = KeymapKey(0, 2, 0, LT(1, KC_Y)); 553 554 set_keymap({regular_key, mod_tap_key, layer_tap_key}); 555 556 // Tap regular key. 557 EXPECT_REPORT(driver, (KC_A)); 558 EXPECT_EMPTY_REPORT(driver); 559 tap_key(regular_key); 560 VERIFY_AND_CLEAR(driver); 561 562 // Press combo keys quickly after regular key. 563 EXPECT_REPORT(driver, (KC_Z)); 564 EXPECT_EMPTY_REPORT(driver); 565 tap_combo({mod_tap_key, layer_tap_key}); 566 VERIFY_AND_CLEAR(driver); 567 568 // Press mod-tap key quickly. 569 EXPECT_REPORT(driver, (KC_X)); 570 mod_tap_key.press(); 571 idle_for(TAPPING_TERM + 1); 572 VERIFY_AND_CLEAR(driver); 573 574 // Release mod-tap key. 575 EXPECT_EMPTY_REPORT(driver); 576 mod_tap_key.release(); 577 run_one_scan_loop(); 578 VERIFY_AND_CLEAR(driver); 579 } 580 581 TEST_F(FlowTapTest, oneshot_mod_key) { 582 TestDriver driver; 583 InSequence s; 584 auto regular_key = KeymapKey(0, 0, 0, KC_A); 585 auto osm_key = KeymapKey(0, 1, 0, OSM(MOD_LSFT)); 586 587 set_keymap({regular_key, osm_key}); 588 589 // Tap regular key. 590 EXPECT_REPORT(driver, (KC_A)); 591 EXPECT_EMPTY_REPORT(driver); 592 tap_key(regular_key); 593 VERIFY_AND_CLEAR(driver); 594 595 // Tap OSM, tap regular key. 596 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT))).Times(AnyNumber()); 597 EXPECT_REPORT(driver, (KC_LSFT, KC_A)); 598 EXPECT_EMPTY_REPORT(driver); 599 tap_key(osm_key); 600 tap_key(regular_key); 601 VERIFY_AND_CLEAR(driver); 602 603 // Nested press of OSM and regular keys. 604 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT))).Times(AnyNumber()); 605 EXPECT_REPORT(driver, (KC_LSFT, KC_A)); 606 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT))).Times(AnyNumber()); 607 EXPECT_EMPTY_REPORT(driver); 608 osm_key.press(); 609 run_one_scan_loop(); 610 tap_key(regular_key); 611 osm_key.release(); 612 run_one_scan_loop(); 613 VERIFY_AND_CLEAR(driver); 614 } 615 616 TEST_F(FlowTapTest, quick_tap) { 617 TestDriver driver; 618 InSequence s; 619 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_A)); 620 621 set_keymap({mod_tap_key}); 622 623 EXPECT_REPORT(driver, (KC_A)); 624 EXPECT_EMPTY_REPORT(driver); 625 tap_key(mod_tap_key); 626 VERIFY_AND_CLEAR(driver); 627 628 EXPECT_REPORT(driver, (KC_A)); 629 mod_tap_key.press(); 630 run_one_scan_loop(); 631 VERIFY_AND_CLEAR(driver); 632 633 EXPECT_NO_REPORT(driver); 634 idle_for(TAPPING_TERM + 1); 635 VERIFY_AND_CLEAR(driver); 636 637 // Release mod-tap key. 638 EXPECT_EMPTY_REPORT(driver); 639 mod_tap_key.release(); 640 run_one_scan_loop(); 641 VERIFY_AND_CLEAR(driver); 642 } 643 644 TEST_F(FlowTapTest, rolling_mt_mt) { 645 TestDriver driver; 646 InSequence s; 647 auto mod_tap_key1 = KeymapKey(0, 1, 0, SFT_T(KC_A)); 648 auto mod_tap_key2 = KeymapKey(0, 2, 0, CTL_T(KC_B)); 649 650 set_keymap({mod_tap_key1, mod_tap_key2}); 651 652 EXPECT_NO_REPORT(driver); 653 idle_for(FLOW_TAP_TERM + 1); 654 mod_tap_key1.press(); 655 run_one_scan_loop(); 656 mod_tap_key2.press(); 657 run_one_scan_loop(); 658 VERIFY_AND_CLEAR(driver); 659 660 EXPECT_REPORT(driver, (KC_A)); 661 EXPECT_REPORT(driver, (KC_A, KC_B)); 662 EXPECT_REPORT(driver, (KC_B)); 663 mod_tap_key1.release(); 664 run_one_scan_loop(); 665 VERIFY_AND_CLEAR(driver); 666 667 // Hold for longer than the tapping term. 668 EXPECT_NO_REPORT(driver); 669 idle_for(TAPPING_TERM + 1); 670 VERIFY_AND_CLEAR(driver); 671 672 // Release mod-tap keys. 673 EXPECT_EMPTY_REPORT(driver); 674 mod_tap_key2.release(); 675 run_one_scan_loop(); 676 VERIFY_AND_CLEAR(driver); 677 } 678 679 TEST_F(FlowTapTest, rolling_lt_mt_regular) { 680 TestDriver driver; 681 InSequence s; 682 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 683 auto mod_tap_key = KeymapKey(0, 1, 0, CTL_T(KC_B)); 684 auto regular_key = KeymapKey(0, 2, 0, KC_C); 685 686 set_keymap({layer_tap_key, mod_tap_key, regular_key}); 687 688 EXPECT_NO_REPORT(driver); 689 idle_for(FLOW_TAP_TERM + 1); 690 layer_tap_key.press(); 691 run_one_scan_loop(); 692 mod_tap_key.press(); 693 run_one_scan_loop(); 694 regular_key.press(); 695 run_one_scan_loop(); 696 VERIFY_AND_CLEAR(driver); 697 698 EXPECT_REPORT(driver, (KC_A)); 699 EXPECT_REPORT(driver, (KC_A, KC_B)); 700 EXPECT_REPORT(driver, (KC_A, KC_B, KC_C)); 701 EXPECT_REPORT(driver, (KC_B, KC_C)); 702 layer_tap_key.release(); 703 run_one_scan_loop(); 704 VERIFY_AND_CLEAR(driver); 705 706 // Hold for longer than the tapping term. 707 EXPECT_NO_REPORT(driver); 708 idle_for(TAPPING_TERM + 1); 709 VERIFY_AND_CLEAR(driver); 710 711 // Release mod-tap keys. 712 EXPECT_REPORT(driver, (KC_C)); 713 EXPECT_EMPTY_REPORT(driver); 714 mod_tap_key.release(); 715 run_one_scan_loop(); 716 regular_key.release(); 717 run_one_scan_loop(); 718 VERIFY_AND_CLEAR(driver); 719 } 720 721 TEST_F(FlowTapTest, rolling_lt_regular_mt) { 722 TestDriver driver; 723 InSequence s; 724 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 725 auto regular_key = KeymapKey(0, 1, 0, KC_B); 726 auto mod_tap_key = KeymapKey(0, 2, 0, CTL_T(KC_C)); 727 728 set_keymap({layer_tap_key, regular_key, mod_tap_key}); 729 730 EXPECT_NO_REPORT(driver); 731 idle_for(FLOW_TAP_TERM + 1); 732 layer_tap_key.press(); 733 run_one_scan_loop(); 734 regular_key.press(); 735 run_one_scan_loop(); 736 mod_tap_key.press(); 737 run_one_scan_loop(); 738 VERIFY_AND_CLEAR(driver); 739 740 EXPECT_REPORT(driver, (KC_A)); 741 EXPECT_REPORT(driver, (KC_A, KC_B)); 742 EXPECT_REPORT(driver, (KC_A, KC_B, KC_C)); 743 EXPECT_REPORT(driver, (KC_B, KC_C)); 744 layer_tap_key.release(); 745 run_one_scan_loop(); 746 VERIFY_AND_CLEAR(driver); 747 748 // Hold for longer than the tapping term. 749 EXPECT_NO_REPORT(driver); 750 idle_for(TAPPING_TERM + 1); 751 VERIFY_AND_CLEAR(driver); 752 753 // Release mod-tap keys. 754 EXPECT_REPORT(driver, (KC_C)); 755 EXPECT_EMPTY_REPORT(driver); 756 regular_key.release(); 757 run_one_scan_loop(); 758 mod_tap_key.release(); 759 run_one_scan_loop(); 760 VERIFY_AND_CLEAR(driver); 761 } 762 763 TEST_F(FlowTapTest, rolling_mt_mt_mt) { 764 TestDriver driver; 765 InSequence s; 766 auto mod_tap_key1 = KeymapKey(0, 0, 0, CTL_T(KC_A)); 767 auto mod_tap_key2 = KeymapKey(0, 1, 0, GUI_T(KC_B)); 768 auto mod_tap_key3 = KeymapKey(0, 2, 0, ALT_T(KC_C)); 769 770 set_keymap({mod_tap_key1, mod_tap_key2, mod_tap_key3}); 771 772 // Press mod-tap keys. 773 EXPECT_NO_REPORT(driver); 774 idle_for(FLOW_TAP_TERM + 1); 775 mod_tap_key1.press(); 776 run_one_scan_loop(); 777 mod_tap_key2.press(); 778 run_one_scan_loop(); 779 mod_tap_key3.press(); 780 run_one_scan_loop(); 781 VERIFY_AND_CLEAR(driver); 782 783 // Release first mod-tap key. 784 EXPECT_REPORT(driver, (KC_A)); 785 EXPECT_REPORT(driver, (KC_A, KC_B)); 786 EXPECT_REPORT(driver, (KC_A, KC_B, KC_C)); 787 EXPECT_REPORT(driver, (KC_B, KC_C)); 788 mod_tap_key1.release(); 789 run_one_scan_loop(); 790 VERIFY_AND_CLEAR(driver); 791 792 // Hold for longer than the tapping term. 793 EXPECT_NO_REPORT(driver); 794 idle_for(TAPPING_TERM + 1); 795 VERIFY_AND_CLEAR(driver); 796 797 // Release other mod-tap keys. 798 EXPECT_REPORT(driver, (KC_C)); 799 EXPECT_EMPTY_REPORT(driver); 800 mod_tap_key2.release(); 801 run_one_scan_loop(); 802 mod_tap_key3.release(); 803 run_one_scan_loop(); 804 VERIFY_AND_CLEAR(driver); 805 } 806 807 TEST_F(FlowTapTest, roll_release_132) { 808 TestDriver driver; 809 InSequence s; 810 auto mod_tap_key1 = KeymapKey(0, 0, 0, CTL_T(KC_A)); 811 auto mod_tap_key2 = KeymapKey(0, 1, 0, GUI_T(KC_B)); 812 auto mod_tap_key3 = KeymapKey(0, 2, 0, ALT_T(KC_C)); 813 814 set_keymap({mod_tap_key1, mod_tap_key2, mod_tap_key3}); 815 816 // Press mod-tap keys. 817 EXPECT_NO_REPORT(driver); 818 idle_for(FLOW_TAP_TERM + 1); 819 mod_tap_key1.press(); 820 run_one_scan_loop(); 821 mod_tap_key2.press(); 822 idle_for(FLOW_TAP_TERM + 1); 823 mod_tap_key3.press(); 824 run_one_scan_loop(); 825 VERIFY_AND_CLEAR(driver); 826 827 // Release first mod-tap key. 828 EXPECT_REPORT(driver, (KC_A)); 829 EXPECT_REPORT(driver, (KC_A, KC_B)); 830 EXPECT_REPORT(driver, (KC_B)); 831 mod_tap_key1.release(); 832 run_one_scan_loop(); 833 VERIFY_AND_CLEAR(driver); 834 835 // Release other mod-tap keys. 836 EXPECT_REPORT(driver, (KC_B, KC_C)); 837 EXPECT_REPORT(driver, (KC_B)); 838 EXPECT_EMPTY_REPORT(driver); 839 mod_tap_key3.release(); 840 run_one_scan_loop(); 841 mod_tap_key2.release(); 842 run_one_scan_loop(); 843 VERIFY_AND_CLEAR(driver); 844 }