test_tap_hold.cpp (33912B)
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 extern "C" bool get_speculative_hold(uint16_t keycode, keyrecord_t *record) { 27 return true; 28 } 29 30 class SpeculativeHoldFlowTapTest : public TestFixture {}; 31 32 TEST_F(SpeculativeHoldFlowTapTest, tap_mod_tap) { 33 TestDriver driver; 34 InSequence s; 35 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); 36 37 set_keymap({mod_tap_key}); 38 39 // Press mod-tap-hold key. Mod is held speculatively. 40 EXPECT_REPORT(driver, (KC_LSFT)); 41 mod_tap_key.press(); 42 idle_for(10); 43 VERIFY_AND_CLEAR(driver); 44 EXPECT_EQ(get_speculative_mods(), MOD_BIT_LSHIFT); 45 46 // Release mod-tap-hold key. 47 EXPECT_EMPTY_REPORT(driver); // Speculative mod canceled. 48 EXPECT_REPORT(driver, (KC_P)); 49 EXPECT_EMPTY_REPORT(driver); 50 mod_tap_key.release(); 51 run_one_scan_loop(); 52 VERIFY_AND_CLEAR(driver); 53 // All mods are released. 54 EXPECT_EQ(get_speculative_mods(), 0); 55 EXPECT_EQ(get_mods(), 0); 56 57 // Idle for tapping term of mod tap hold key. 58 idle_for(TAPPING_TERM - 10); 59 VERIFY_AND_CLEAR(driver); 60 } 61 62 TEST_F(SpeculativeHoldFlowTapTest, hold_two_mod_taps) { 63 TestDriver driver; 64 InSequence s; 65 auto mod_tap_key1 = KeymapKey(0, 1, 0, LCTL_T(KC_A)); 66 auto mod_tap_key2 = KeymapKey(0, 2, 0, RALT_T(KC_B)); 67 68 set_keymap({mod_tap_key1, mod_tap_key2}); 69 70 // Press first mod-tap key. 71 EXPECT_REPORT(driver, (KC_LCTL)); 72 mod_tap_key1.press(); 73 idle_for(FLOW_TAP_TERM + 1); 74 VERIFY_AND_CLEAR(driver); 75 EXPECT_EQ(get_speculative_mods(), MOD_BIT_LCTRL); 76 77 // Press second mod-tap key. 78 EXPECT_REPORT(driver, (KC_LCTL, KC_RALT)); 79 mod_tap_key2.press(); 80 run_one_scan_loop(); 81 VERIFY_AND_CLEAR(driver); 82 EXPECT_EQ(get_speculative_mods(), MOD_BIT_LCTRL | MOD_BIT_RALT); 83 84 EXPECT_NO_REPORT(driver); 85 idle_for(TAPPING_TERM + 1); 86 VERIFY_AND_CLEAR(driver); 87 EXPECT_EQ(get_speculative_mods(), 0); 88 EXPECT_EQ(get_mods(), MOD_BIT_LCTRL | MOD_BIT_RALT); 89 90 // Release first mod-tap key. 91 EXPECT_REPORT(driver, (KC_RALT)); 92 mod_tap_key1.release(); 93 run_one_scan_loop(); 94 VERIFY_AND_CLEAR(driver); 95 96 // Release second mod-tap key. 97 EXPECT_EMPTY_REPORT(driver); 98 mod_tap_key2.release(); 99 run_one_scan_loop(); 100 VERIFY_AND_CLEAR(driver); 101 } 102 103 TEST_F(SpeculativeHoldFlowTapTest, two_mod_taps_same_mods) { 104 TestDriver driver; 105 InSequence s; 106 auto mod_tap_key1 = KeymapKey(0, 1, 0, GUI_T(KC_A)); 107 auto mod_tap_key2 = KeymapKey(0, 2, 0, GUI_T(KC_B)); 108 109 set_keymap({mod_tap_key1, mod_tap_key2}); 110 111 // Press first mod-tap key. 112 EXPECT_REPORT(driver, (KC_LGUI)); 113 mod_tap_key1.press(); 114 idle_for(FLOW_TAP_TERM + 1); 115 VERIFY_AND_CLEAR(driver); 116 117 // Tap second mod-tap key. 118 EXPECT_NO_REPORT(driver); 119 mod_tap_key2.press(); 120 run_one_scan_loop(); 121 VERIFY_AND_CLEAR(driver); 122 123 EXPECT_REPORT(driver, (KC_LGUI, KC_B)); 124 EXPECT_REPORT(driver, (KC_LGUI)); 125 mod_tap_key2.release(); 126 run_one_scan_loop(); 127 VERIFY_AND_CLEAR(driver); 128 129 // Release first mod-tap key. 130 EXPECT_EMPTY_REPORT(driver); 131 mod_tap_key1.release(); 132 run_one_scan_loop(); 133 VERIFY_AND_CLEAR(driver); 134 // All mods are released. 135 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 136 } 137 138 // Test an input of quick distinct taps. All should be settled as tapped. 139 TEST_F(SpeculativeHoldFlowTapTest, distinct_taps) { 140 TestDriver driver; 141 InSequence s; 142 auto regular_key = KeymapKey(0, 0, 0, KC_A); 143 auto mod_tap_key1 = KeymapKey(0, 1, 0, SFT_T(KC_B)); 144 auto mod_tap_key2 = KeymapKey(0, 2, 0, CTL_T(KC_C)); 145 auto mod_tap_key3 = KeymapKey(0, 3, 0, ALT_T(KC_D)); 146 147 set_keymap({regular_key, mod_tap_key1, mod_tap_key2, mod_tap_key3}); 148 149 // Tap regular key. 150 EXPECT_REPORT(driver, (KC_A)); 151 EXPECT_EMPTY_REPORT(driver); 152 tap_key(regular_key, FLOW_TAP_TERM + 1); 153 VERIFY_AND_CLEAR(driver); 154 155 // Tap mod-tap 1. 156 EXPECT_REPORT(driver, (KC_B)); 157 mod_tap_key1.press(); 158 run_one_scan_loop(); 159 VERIFY_AND_CLEAR(driver); 160 161 EXPECT_EMPTY_REPORT(driver); 162 idle_for(FLOW_TAP_TERM + 1); 163 mod_tap_key1.release(); 164 run_one_scan_loop(); 165 VERIFY_AND_CLEAR(driver); 166 167 // Tap mod-tap 2. 168 EXPECT_REPORT(driver, (KC_C)); 169 mod_tap_key2.press(); 170 run_one_scan_loop(); 171 VERIFY_AND_CLEAR(driver); 172 173 EXPECT_EMPTY_REPORT(driver); 174 idle_for(FLOW_TAP_TERM + 1); 175 mod_tap_key2.release(); 176 run_one_scan_loop(); 177 VERIFY_AND_CLEAR(driver); 178 179 // Tap mod-tap 3. 180 EXPECT_REPORT(driver, (KC_D)); 181 mod_tap_key3.press(); 182 run_one_scan_loop(); 183 VERIFY_AND_CLEAR(driver); 184 185 EXPECT_EMPTY_REPORT(driver); 186 idle_for(FLOW_TAP_TERM + 1); 187 mod_tap_key3.release(); 188 idle_for(FLOW_TAP_TERM + 1); // Pause between taps. 189 VERIFY_AND_CLEAR(driver); 190 191 // Tap mod-tap 1. 192 EXPECT_REPORT(driver, (KC_LSFT)); 193 mod_tap_key1.press(); 194 run_one_scan_loop(); 195 VERIFY_AND_CLEAR(driver); 196 197 EXPECT_EMPTY_REPORT(driver); 198 EXPECT_REPORT(driver, (KC_B)); 199 EXPECT_EMPTY_REPORT(driver); 200 idle_for(FLOW_TAP_TERM + 1); 201 mod_tap_key1.release(); 202 run_one_scan_loop(); 203 VERIFY_AND_CLEAR(driver); 204 205 // Tap mod-tap 2. 206 EXPECT_REPORT(driver, (KC_C)); 207 mod_tap_key2.press(); 208 run_one_scan_loop(); 209 VERIFY_AND_CLEAR(driver); 210 211 EXPECT_EMPTY_REPORT(driver); 212 idle_for(TAPPING_TERM + 1); 213 mod_tap_key2.release(); 214 idle_for(FLOW_TAP_TERM + 1); 215 VERIFY_AND_CLEAR(driver); 216 // All mods are released. 217 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 218 } 219 220 // By default, Flow Tap is disabled when mods other than Shift and AltGr are on. 221 TEST_F(SpeculativeHoldFlowTapTest, hotkey_taps) { 222 TestDriver driver; 223 InSequence s; 224 auto ctrl_key = KeymapKey(0, 0, 0, KC_LCTL); 225 auto shft_key = KeymapKey(0, 1, 0, KC_LSFT); 226 auto alt_key = KeymapKey(0, 2, 0, KC_LALT); 227 auto gui_key = KeymapKey(0, 3, 0, KC_LGUI); 228 auto regular_key = KeymapKey(0, 4, 0, KC_A); 229 auto mod_tap_key = KeymapKey(0, 5, 0, RCTL_T(KC_B)); 230 231 set_keymap({ctrl_key, shft_key, alt_key, gui_key, regular_key, mod_tap_key}); 232 233 for (KeymapKey *mod_key : {&ctrl_key, &alt_key, &gui_key}) { 234 // Hold mod key. 235 EXPECT_REPORT(driver, (mod_key->code)); 236 mod_key->press(); 237 run_one_scan_loop(); 238 239 // Tap regular key. 240 EXPECT_REPORT(driver, (mod_key->code, KC_A)); 241 regular_key.press(); 242 run_one_scan_loop(); 243 VERIFY_AND_CLEAR(driver); 244 245 EXPECT_REPORT(driver, (mod_key->code)); 246 regular_key.release(); 247 run_one_scan_loop(); 248 VERIFY_AND_CLEAR(driver); 249 250 // Press mod-tap, where Flow Tap is disabled due to the held mod. 251 EXPECT_REPORT(driver, (mod_key->code, KC_RCTL)); 252 mod_tap_key.press(); 253 idle_for(TAPPING_TERM + 1); 254 VERIFY_AND_CLEAR(driver); 255 256 // Release mod-tap. 257 EXPECT_REPORT(driver, (mod_key->code)); 258 mod_tap_key.release(); 259 run_one_scan_loop(); 260 261 // Release mod key. 262 EXPECT_EMPTY_REPORT(driver); 263 mod_key->release(); 264 run_one_scan_loop(); 265 VERIFY_AND_CLEAR(driver); 266 } 267 268 // Hold Shift key. 269 EXPECT_REPORT(driver, (KC_LSFT)); 270 shft_key.press(); 271 run_one_scan_loop(); 272 273 // Tap regular key. 274 EXPECT_REPORT(driver, (KC_LSFT, KC_A)); 275 regular_key.press(); 276 run_one_scan_loop(); 277 VERIFY_AND_CLEAR(driver); 278 279 EXPECT_REPORT(driver, (KC_LSFT)); 280 regular_key.release(); 281 run_one_scan_loop(); 282 VERIFY_AND_CLEAR(driver); 283 284 // Press mod-tap, where Flow Tap applies to settle as tapped. 285 EXPECT_REPORT(driver, (KC_LSFT, KC_B)); 286 mod_tap_key.press(); 287 idle_for(TAPPING_TERM + 1); 288 VERIFY_AND_CLEAR(driver); 289 290 // Release mod-tap. 291 EXPECT_REPORT(driver, (KC_LSFT)); 292 mod_tap_key.release(); 293 run_one_scan_loop(); 294 295 // Release Shift key. 296 EXPECT_EMPTY_REPORT(driver); 297 shft_key.release(); 298 run_one_scan_loop(); 299 VERIFY_AND_CLEAR(driver); 300 // All mods are released. 301 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 302 } 303 304 // Test input with two mod-taps in a rolled press quickly after a regular key. 305 TEST_F(SpeculativeHoldFlowTapTest, rolled_press) { 306 TestDriver driver; 307 InSequence s; 308 auto regular_key = KeymapKey(0, 0, 0, KC_A); 309 auto mod_tap_key1 = KeymapKey(0, 1, 0, SFT_T(KC_B)); 310 auto mod_tap_key2 = KeymapKey(0, 2, 0, CTL_T(KC_C)); 311 312 set_keymap({regular_key, mod_tap_key1, mod_tap_key2}); 313 314 // Tap regular key. 315 EXPECT_REPORT(driver, (KC_A)); 316 EXPECT_EMPTY_REPORT(driver); 317 tap_key(regular_key); 318 VERIFY_AND_CLEAR(driver); 319 320 // Press mod-tap key 1 quickly after regular key. The mod-tap should settle 321 // immediately as tapped, sending `KC_B`. 322 EXPECT_REPORT(driver, (KC_B)); 323 mod_tap_key1.press(); 324 run_one_scan_loop(); 325 VERIFY_AND_CLEAR(driver); 326 327 // Press mod-tap key 2 quickly. 328 EXPECT_REPORT(driver, (KC_B, KC_C)); 329 mod_tap_key2.press(); 330 run_one_scan_loop(); 331 VERIFY_AND_CLEAR(driver); 332 333 // Hold for longer than the tapping term. 334 EXPECT_NO_REPORT(driver); 335 idle_for(TAPPING_TERM + 1); 336 VERIFY_AND_CLEAR(driver); 337 338 // Release mod-tap keys. 339 EXPECT_REPORT(driver, (KC_C)); 340 EXPECT_EMPTY_REPORT(driver); 341 mod_tap_key1.release(); 342 run_one_scan_loop(); 343 mod_tap_key2.release(); 344 run_one_scan_loop(); 345 VERIFY_AND_CLEAR(driver); 346 // All mods are released. 347 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 348 } 349 350 TEST_F(SpeculativeHoldFlowTapTest, long_flow_tap_settled_as_held) { 351 TestDriver driver; 352 InSequence s; 353 auto regular_key = KeymapKey(0, 0, 0, KC_A); 354 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_B)); 355 356 set_keymap({regular_key, mod_tap_key}); 357 358 // Tap regular key. 359 EXPECT_REPORT(driver, (KC_A)); 360 EXPECT_EMPTY_REPORT(driver); 361 tap_key(regular_key); 362 VERIFY_AND_CLEAR(driver); 363 364 EXPECT_NO_REPORT(driver); 365 idle_for(FLOW_TAP_TERM + 1); 366 VERIFY_AND_CLEAR(driver); 367 368 // Press mod-tap key. 369 EXPECT_REPORT(driver, (KC_LSFT)); 370 mod_tap_key.press(); 371 run_one_scan_loop(); 372 VERIFY_AND_CLEAR(driver); 373 374 // Hold for the tapping term. 375 EXPECT_NO_REPORT(driver); 376 idle_for(TAPPING_TERM); 377 VERIFY_AND_CLEAR(driver); 378 379 // Release mod-tap key. 380 EXPECT_EMPTY_REPORT(driver); 381 mod_tap_key.release(); 382 run_one_scan_loop(); 383 VERIFY_AND_CLEAR(driver); 384 // All mods are released. 385 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 386 } 387 388 TEST_F(SpeculativeHoldFlowTapTest, holding_multiple_mod_taps) { 389 TestDriver driver; 390 InSequence s; 391 auto regular_key = KeymapKey(0, 0, 0, KC_A); 392 auto mod_tap_key1 = KeymapKey(0, 1, 0, SFT_T(KC_B)); 393 auto mod_tap_key2 = KeymapKey(0, 2, 0, CTL_T(KC_C)); 394 395 set_keymap({regular_key, mod_tap_key1, mod_tap_key2}); 396 397 // Tap regular key. 398 EXPECT_REPORT(driver, (KC_A)); 399 EXPECT_EMPTY_REPORT(driver); 400 tap_key(regular_key); 401 VERIFY_AND_CLEAR(driver); 402 403 EXPECT_NO_REPORT(driver); 404 idle_for(FLOW_TAP_TERM + 1); 405 VERIFY_AND_CLEAR(driver); 406 407 // Press mod-tap keys. 408 EXPECT_REPORT(driver, (KC_LSFT)); 409 mod_tap_key1.press(); 410 run_one_scan_loop(); 411 VERIFY_AND_CLEAR(driver); 412 413 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL)); 414 mod_tap_key2.press(); 415 idle_for(TAPPING_TERM - 5); // Hold almost until tapping term. 416 VERIFY_AND_CLEAR(driver); 417 418 // Press regular key. 419 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL, KC_A)); 420 regular_key.press(); 421 idle_for(10); 422 VERIFY_AND_CLEAR(driver); 423 424 // Release keys. 425 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL)); 426 EXPECT_REPORT(driver, (KC_LCTL)); 427 EXPECT_EMPTY_REPORT(driver); 428 regular_key.release(); 429 run_one_scan_loop(); 430 mod_tap_key1.release(); 431 run_one_scan_loop(); 432 mod_tap_key2.release(); 433 run_one_scan_loop(); 434 VERIFY_AND_CLEAR(driver); 435 // All mods are released. 436 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 437 } 438 439 TEST_F(SpeculativeHoldFlowTapTest, holding_mod_tap_with_regular_mod) { 440 TestDriver driver; 441 InSequence s; 442 auto regular_key = KeymapKey(0, 0, 0, KC_A); 443 auto mod_key = KeymapKey(0, 1, 0, KC_LSFT); 444 auto mod_tap_key = KeymapKey(0, 2, 0, CTL_T(KC_C)); 445 446 set_keymap({regular_key, mod_key, mod_tap_key}); 447 448 // Tap regular key. 449 EXPECT_REPORT(driver, (KC_A)); 450 EXPECT_EMPTY_REPORT(driver); 451 tap_key(regular_key); 452 VERIFY_AND_CLEAR(driver); 453 454 EXPECT_NO_REPORT(driver); 455 idle_for(FLOW_TAP_TERM + 1); 456 VERIFY_AND_CLEAR(driver); 457 458 // Press mod and mod-tap keys. 459 EXPECT_REPORT(driver, (KC_LSFT)); 460 mod_key.press(); 461 run_one_scan_loop(); 462 VERIFY_AND_CLEAR(driver); 463 464 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL)); 465 mod_tap_key.press(); 466 idle_for(TAPPING_TERM - 5); // Hold almost until tapping term. 467 VERIFY_AND_CLEAR(driver); 468 469 // Press regular key. 470 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL, KC_A)); 471 regular_key.press(); 472 idle_for(10); 473 VERIFY_AND_CLEAR(driver); 474 475 // Release keys. 476 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL)); 477 EXPECT_REPORT(driver, (KC_LCTL)); 478 EXPECT_EMPTY_REPORT(driver); 479 regular_key.release(); 480 run_one_scan_loop(); 481 mod_key.release(); 482 run_one_scan_loop(); 483 mod_tap_key.release(); 484 run_one_scan_loop(); 485 VERIFY_AND_CLEAR(driver); 486 // All mods are released. 487 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 488 } 489 490 TEST_F(SpeculativeHoldFlowTapTest, layer_tap_ignored_with_disabled_key) { 491 TestDriver driver; 492 InSequence s; 493 auto no_key = KeymapKey(0, 0, 0, KC_NO); 494 auto regular_key = KeymapKey(1, 0, 0, KC_ESC); 495 auto layer_tap_key = KeymapKey(0, 1, 0, LT(1, KC_A)); 496 auto mod_tap_key = KeymapKey(0, 2, 0, CTL_T(KC_B)); 497 498 set_keymap({no_key, regular_key, layer_tap_key, mod_tap_key}); 499 500 EXPECT_REPORT(driver, (KC_ESC)); 501 EXPECT_EMPTY_REPORT(driver); 502 layer_tap_key.press(); 503 idle_for(TAPPING_TERM + 1); 504 tap_key(regular_key); 505 layer_tap_key.release(); 506 run_one_scan_loop(); 507 VERIFY_AND_CLEAR(driver); 508 509 EXPECT_REPORT(driver, (KC_LCTL)); 510 mod_tap_key.press(); 511 idle_for(TAPPING_TERM + 1); 512 VERIFY_AND_CLEAR(driver); 513 514 EXPECT_EMPTY_REPORT(driver); 515 mod_tap_key.release(); 516 run_one_scan_loop(); 517 VERIFY_AND_CLEAR(driver); 518 // All mods are released. 519 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 520 } 521 522 TEST_F(SpeculativeHoldFlowTapTest, layer_tap_ignored_with_disabled_key_complex) { 523 TestDriver driver; 524 InSequence s; 525 auto regular_key1 = KeymapKey(0, 0, 0, KC_Q); 526 auto layer_tap_key = KeymapKey(0, 1, 0, LT(1, KC_SPC)); 527 auto mod_tap_key1 = KeymapKey(0, 2, 0, CTL_T(KC_T)); 528 // Place RALT_T(KC_I), where Flow Tap is enabled, in the same position on 529 // layer 0 as KC_RGHT, where Flow Tap is disabled. This tests that Flow Tap 530 // tracks the keycode from the correct layer. 531 auto mod_tap_key2 = KeymapKey(0, 3, 0, RALT_T(KC_I)); 532 auto regular_key2 = KeymapKey(1, 3, 0, KC_RGHT); 533 534 set_keymap({regular_key1, layer_tap_key, mod_tap_key1, mod_tap_key2, regular_key2}); 535 536 // Tap regular key 1. 537 EXPECT_REPORT(driver, (KC_Q)); 538 EXPECT_EMPTY_REPORT(driver); 539 tap_key(regular_key1); 540 idle_for(FLOW_TAP_TERM + 1); 541 VERIFY_AND_CLEAR(driver); 542 543 // Hold layer-tap key. 544 EXPECT_NO_REPORT(driver); 545 layer_tap_key.press(); 546 run_one_scan_loop(); 547 VERIFY_AND_CLEAR(driver); 548 549 // Tap regular key 2. 550 EXPECT_REPORT(driver, (KC_RALT)); 551 EXPECT_EMPTY_REPORT(driver); 552 EXPECT_REPORT(driver, (KC_RGHT)); 553 EXPECT_EMPTY_REPORT(driver); 554 tap_key(regular_key2); 555 VERIFY_AND_CLEAR(driver); 556 557 // Release layer-tap key. 558 EXPECT_NO_REPORT(driver); 559 layer_tap_key.release(); 560 run_one_scan_loop(); 561 VERIFY_AND_CLEAR(driver); 562 563 // Quickly hold mod-tap key 1. 564 EXPECT_REPORT(driver, (KC_LCTL)); 565 mod_tap_key1.press(); 566 run_one_scan_loop(); 567 VERIFY_AND_CLEAR(driver); 568 569 EXPECT_REPORT(driver, (KC_LCTL, KC_Q)); 570 EXPECT_REPORT(driver, (KC_LCTL)); 571 tap_key(regular_key1); 572 VERIFY_AND_CLEAR(driver); 573 574 EXPECT_EMPTY_REPORT(driver); 575 mod_tap_key1.release(); 576 run_one_scan_loop(); 577 VERIFY_AND_CLEAR(driver); 578 // All mods are released. 579 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 580 } 581 582 TEST_F(SpeculativeHoldFlowTapTest, layer_tap_ignored_with_enabled_key) { 583 TestDriver driver; 584 InSequence s; 585 auto no_key = KeymapKey(0, 0, 0, KC_NO); 586 auto regular_key = KeymapKey(1, 0, 0, KC_C); 587 auto layer_tap_key = KeymapKey(0, 1, 0, LT(1, KC_A)); 588 auto mod_tap_key = KeymapKey(0, 2, 0, CTL_T(KC_B)); 589 590 set_keymap({no_key, regular_key, layer_tap_key, mod_tap_key}); 591 592 EXPECT_REPORT(driver, (KC_C)); 593 EXPECT_EMPTY_REPORT(driver); 594 layer_tap_key.press(); 595 idle_for(TAPPING_TERM + 1); 596 tap_key(regular_key); 597 layer_tap_key.release(); 598 run_one_scan_loop(); 599 VERIFY_AND_CLEAR(driver); 600 601 EXPECT_REPORT(driver, (KC_B)); 602 mod_tap_key.press(); 603 run_one_scan_loop(); 604 VERIFY_AND_CLEAR(driver); 605 606 EXPECT_EMPTY_REPORT(driver); 607 idle_for(TAPPING_TERM + 1); 608 mod_tap_key.release(); 609 run_one_scan_loop(); 610 VERIFY_AND_CLEAR(driver); 611 // All mods are released. 612 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 613 } 614 615 TEST_F(SpeculativeHoldFlowTapTest, quick_tap) { 616 TestDriver driver; 617 InSequence s; 618 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_A)); 619 620 set_keymap({mod_tap_key}); 621 622 EXPECT_REPORT(driver, (KC_LSFT)); 623 EXPECT_EMPTY_REPORT(driver); 624 EXPECT_REPORT(driver, (KC_A)); 625 EXPECT_EMPTY_REPORT(driver); 626 tap_key(mod_tap_key); 627 VERIFY_AND_CLEAR(driver); 628 629 EXPECT_REPORT(driver, (KC_A)); 630 mod_tap_key.press(); 631 run_one_scan_loop(); 632 VERIFY_AND_CLEAR(driver); 633 634 EXPECT_NO_REPORT(driver); 635 idle_for(TAPPING_TERM + 1); 636 VERIFY_AND_CLEAR(driver); 637 638 // Release mod-tap key. 639 EXPECT_EMPTY_REPORT(driver); 640 mod_tap_key.release(); 641 run_one_scan_loop(); 642 VERIFY_AND_CLEAR(driver); 643 // All mods are released. 644 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 645 } 646 647 TEST_F(SpeculativeHoldFlowTapTest, rolling_mt_mt) { 648 TestDriver driver; 649 InSequence s; 650 auto mod_tap_key1 = KeymapKey(0, 1, 0, SFT_T(KC_A)); 651 auto mod_tap_key2 = KeymapKey(0, 2, 0, CTL_T(KC_B)); 652 653 set_keymap({mod_tap_key1, mod_tap_key2}); 654 655 EXPECT_NO_REPORT(driver); 656 EXPECT_REPORT(driver, (KC_LSFT)); 657 EXPECT_REPORT(driver, (KC_LSFT, KC_LCTL)); 658 idle_for(FLOW_TAP_TERM + 1); 659 mod_tap_key1.press(); 660 run_one_scan_loop(); 661 mod_tap_key2.press(); 662 run_one_scan_loop(); 663 VERIFY_AND_CLEAR(driver); 664 665 EXPECT_EMPTY_REPORT(driver); 666 EXPECT_REPORT(driver, (KC_A)); 667 EXPECT_REPORT(driver, (KC_A, KC_B)); 668 EXPECT_REPORT(driver, (KC_B)); 669 mod_tap_key1.release(); 670 run_one_scan_loop(); 671 VERIFY_AND_CLEAR(driver); 672 673 // Hold for longer than the tapping term. 674 EXPECT_NO_REPORT(driver); 675 idle_for(TAPPING_TERM + 1); 676 VERIFY_AND_CLEAR(driver); 677 678 // Release mod-tap keys. 679 EXPECT_EMPTY_REPORT(driver); 680 mod_tap_key2.release(); 681 run_one_scan_loop(); 682 VERIFY_AND_CLEAR(driver); 683 // All mods are released. 684 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 685 } 686 687 TEST_F(SpeculativeHoldFlowTapTest, rolling_lt_mt_regular) { 688 TestDriver driver; 689 InSequence s; 690 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 691 auto mod_tap_key = KeymapKey(0, 1, 0, CTL_T(KC_B)); 692 auto regular_key = KeymapKey(0, 2, 0, KC_C); 693 694 set_keymap({layer_tap_key, mod_tap_key, regular_key}); 695 696 EXPECT_REPORT(driver, (KC_LCTL)); 697 idle_for(FLOW_TAP_TERM + 1); 698 layer_tap_key.press(); 699 run_one_scan_loop(); 700 mod_tap_key.press(); 701 run_one_scan_loop(); 702 regular_key.press(); 703 run_one_scan_loop(); 704 VERIFY_AND_CLEAR(driver); 705 706 EXPECT_EMPTY_REPORT(driver); 707 EXPECT_REPORT(driver, (KC_A)); 708 EXPECT_REPORT(driver, (KC_A, KC_B)); 709 EXPECT_REPORT(driver, (KC_A, KC_B, KC_C)); 710 EXPECT_REPORT(driver, (KC_B, KC_C)); 711 layer_tap_key.release(); 712 run_one_scan_loop(); 713 VERIFY_AND_CLEAR(driver); 714 715 // Hold for longer than the tapping term. 716 EXPECT_NO_REPORT(driver); 717 idle_for(TAPPING_TERM + 1); 718 VERIFY_AND_CLEAR(driver); 719 720 // Release mod-tap keys. 721 EXPECT_REPORT(driver, (KC_C)); 722 EXPECT_EMPTY_REPORT(driver); 723 mod_tap_key.release(); 724 run_one_scan_loop(); 725 regular_key.release(); 726 run_one_scan_loop(); 727 VERIFY_AND_CLEAR(driver); 728 // All mods are released. 729 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 730 } 731 732 TEST_F(SpeculativeHoldFlowTapTest, rolling_lt_regular_mt) { 733 TestDriver driver; 734 InSequence s; 735 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 736 auto regular_key = KeymapKey(0, 1, 0, KC_B); 737 auto mod_tap_key = KeymapKey(0, 2, 0, CTL_T(KC_C)); 738 739 set_keymap({layer_tap_key, regular_key, mod_tap_key}); 740 741 EXPECT_NO_REPORT(driver); 742 idle_for(FLOW_TAP_TERM + 1); 743 layer_tap_key.press(); 744 run_one_scan_loop(); 745 regular_key.press(); 746 run_one_scan_loop(); 747 mod_tap_key.press(); 748 run_one_scan_loop(); 749 VERIFY_AND_CLEAR(driver); 750 751 EXPECT_REPORT(driver, (KC_A)); 752 EXPECT_REPORT(driver, (KC_A, KC_B)); 753 EXPECT_REPORT(driver, (KC_A, KC_B, KC_C)); 754 EXPECT_REPORT(driver, (KC_B, KC_C)); 755 layer_tap_key.release(); 756 run_one_scan_loop(); 757 VERIFY_AND_CLEAR(driver); 758 759 // Hold for longer than the tapping term. 760 EXPECT_NO_REPORT(driver); 761 idle_for(TAPPING_TERM + 1); 762 VERIFY_AND_CLEAR(driver); 763 764 // Release mod-tap keys. 765 EXPECT_REPORT(driver, (KC_C)); 766 EXPECT_EMPTY_REPORT(driver); 767 regular_key.release(); 768 run_one_scan_loop(); 769 mod_tap_key.release(); 770 run_one_scan_loop(); 771 VERIFY_AND_CLEAR(driver); 772 // All mods are released. 773 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 774 } 775 776 TEST_F(SpeculativeHoldFlowTapTest, rolling_mt_mt_mt) { 777 TestDriver driver; 778 InSequence s; 779 auto mod_tap_key1 = KeymapKey(0, 0, 0, CTL_T(KC_A)); 780 auto mod_tap_key2 = KeymapKey(0, 1, 0, GUI_T(KC_B)); 781 auto mod_tap_key3 = KeymapKey(0, 2, 0, ALT_T(KC_C)); 782 783 set_keymap({mod_tap_key1, mod_tap_key2, mod_tap_key3}); 784 785 // Press mod-tap keys. 786 EXPECT_REPORT(driver, (KC_LCTL)); 787 EXPECT_REPORT(driver, (KC_LCTL, KC_LGUI)); 788 EXPECT_REPORT(driver, (KC_LCTL, KC_LGUI, KC_LALT)); 789 idle_for(FLOW_TAP_TERM + 1); 790 mod_tap_key1.press(); 791 run_one_scan_loop(); 792 mod_tap_key2.press(); 793 run_one_scan_loop(); 794 mod_tap_key3.press(); 795 run_one_scan_loop(); 796 VERIFY_AND_CLEAR(driver); 797 798 // Release first mod-tap key. 799 EXPECT_EMPTY_REPORT(driver); 800 EXPECT_REPORT(driver, (KC_A)); 801 EXPECT_REPORT(driver, (KC_A, KC_B)); 802 EXPECT_REPORT(driver, (KC_A, KC_B, KC_C)); 803 EXPECT_REPORT(driver, (KC_B, KC_C)); 804 mod_tap_key1.release(); 805 run_one_scan_loop(); 806 VERIFY_AND_CLEAR(driver); 807 808 // Hold for longer than the tapping term. 809 EXPECT_NO_REPORT(driver); 810 idle_for(TAPPING_TERM + 1); 811 VERIFY_AND_CLEAR(driver); 812 813 // Release other mod-tap keys. 814 EXPECT_REPORT(driver, (KC_C)); 815 EXPECT_EMPTY_REPORT(driver); 816 mod_tap_key2.release(); 817 run_one_scan_loop(); 818 mod_tap_key3.release(); 819 run_one_scan_loop(); 820 VERIFY_AND_CLEAR(driver); 821 // All mods are released. 822 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 823 } 824 825 TEST_F(SpeculativeHoldFlowTapTest, roll_release_132) { 826 TestDriver driver; 827 InSequence s; 828 auto mod_tap_key1 = KeymapKey(0, 0, 0, CTL_T(KC_A)); 829 auto mod_tap_key2 = KeymapKey(0, 1, 0, GUI_T(KC_B)); 830 auto mod_tap_key3 = KeymapKey(0, 2, 0, ALT_T(KC_C)); 831 832 set_keymap({mod_tap_key1, mod_tap_key2, mod_tap_key3}); 833 834 // Press mod-tap keys. 835 EXPECT_REPORT(driver, (KC_LCTL)); 836 EXPECT_REPORT(driver, (KC_LCTL, KC_LGUI)); 837 EXPECT_REPORT(driver, (KC_LCTL, KC_LGUI, KC_LALT)); 838 idle_for(FLOW_TAP_TERM + 1); 839 mod_tap_key1.press(); 840 run_one_scan_loop(); 841 mod_tap_key2.press(); 842 idle_for(FLOW_TAP_TERM + 1); 843 mod_tap_key3.press(); 844 run_one_scan_loop(); 845 VERIFY_AND_CLEAR(driver); 846 847 // Release first mod-tap key. 848 EXPECT_EMPTY_REPORT(driver); 849 EXPECT_REPORT(driver, (KC_A)); 850 EXPECT_REPORT(driver, (KC_A, KC_B)); 851 EXPECT_REPORT(driver, (KC_B)); 852 mod_tap_key1.release(); 853 run_one_scan_loop(); 854 VERIFY_AND_CLEAR(driver); 855 856 // Release other mod-tap keys. 857 EXPECT_REPORT(driver, (KC_B, KC_C)); 858 EXPECT_REPORT(driver, (KC_B)); 859 EXPECT_EMPTY_REPORT(driver); 860 mod_tap_key3.release(); 861 run_one_scan_loop(); 862 mod_tap_key2.release(); 863 run_one_scan_loop(); 864 VERIFY_AND_CLEAR(driver); 865 // All mods are released. 866 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 867 } 868 869 // Test with layer tap and speculative mod tap keys on the same layer, rolling 870 // from LT to MT key: 871 // "LT down, MT down, (wait out tapping term), LT up, MT up." 872 TEST_F(SpeculativeHoldFlowTapTest, lt_mt_same_layer_roll) { 873 TestDriver driver; 874 InSequence s; 875 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 876 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_B)); 877 auto regular_key = KeymapKey(1, 1, 0, KC_C); 878 879 set_keymap({layer_tap_key, mod_tap_key, regular_key}); 880 881 // Press layer tap key. 882 EXPECT_NO_REPORT(driver); 883 layer_tap_key.press(); 884 idle_for(FLOW_TAP_TERM + 1); 885 VERIFY_AND_CLEAR(driver); 886 887 // Press mod-tap key, after flow tap term but within tapping term. The 888 // speculative mod activates. 889 EXPECT_REPORT(driver, (KC_LSFT)); 890 mod_tap_key.press(); 891 run_one_scan_loop(); 892 VERIFY_AND_CLEAR(driver); 893 894 // Wait for the layer tap key to settle. 895 EXPECT_EMPTY_REPORT(driver); 896 EXPECT_REPORT(driver, (KC_C)); 897 idle_for(TAPPING_TERM - FLOW_TAP_TERM); 898 VERIFY_AND_CLEAR(driver); 899 900 // Release keys. 901 EXPECT_EMPTY_REPORT(driver); 902 layer_tap_key.release(); 903 run_one_scan_loop(); 904 mod_tap_key.release(); 905 idle_for(FLOW_TAP_TERM + 1); 906 VERIFY_AND_CLEAR(driver); 907 // All mods are released. 908 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 909 } 910 911 // Test with layer tap and speculative mod tap keys on the same layer, trying 912 // a nested press from LT to MT key: 913 // "LT down, MT down, (wait out tapping term), MT up, LT up." 914 TEST_F(SpeculativeHoldFlowTapTest, lt_mt_same_layer_nested_press) { 915 TestDriver driver; 916 InSequence s; 917 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 918 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_B)); 919 auto regular_key = KeymapKey(1, 1, 0, KC_C); 920 921 set_keymap({layer_tap_key, mod_tap_key, regular_key}); 922 923 EXPECT_NO_REPORT(driver); 924 layer_tap_key.press(); 925 idle_for(FLOW_TAP_TERM + 1); 926 VERIFY_AND_CLEAR(driver); 927 928 EXPECT_REPORT(driver, (KC_LSFT)); 929 mod_tap_key.press(); 930 run_one_scan_loop(); 931 VERIFY_AND_CLEAR(driver); 932 933 EXPECT_EMPTY_REPORT(driver); 934 EXPECT_REPORT(driver, (KC_C)); 935 idle_for(TAPPING_TERM - FLOW_TAP_TERM); 936 VERIFY_AND_CLEAR(driver); 937 938 // Release keys: MT first, LT second. 939 EXPECT_EMPTY_REPORT(driver); 940 mod_tap_key.release(); 941 run_one_scan_loop(); 942 layer_tap_key.release(); 943 idle_for(FLOW_TAP_TERM + 1); 944 VERIFY_AND_CLEAR(driver); 945 // All mods are released. 946 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 947 } 948 949 // Test with layer tap and speculative mod tap keys on the same layer, trying 950 // a nested press with the MT first: 951 // "MT down, LT down, (wait out tapping term), LT up, MT up." 952 TEST_F(SpeculativeHoldFlowTapTest, mt_lt_same_layer_nested_press) { 953 TestDriver driver; 954 InSequence s; 955 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 956 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_B)); 957 auto regular_key = KeymapKey(1, 1, 0, KC_C); 958 959 set_keymap({layer_tap_key, mod_tap_key, regular_key}); 960 961 EXPECT_REPORT(driver, (KC_LSFT)); 962 mod_tap_key.press(); 963 run_one_scan_loop(); 964 965 EXPECT_NO_REPORT(driver); 966 layer_tap_key.press(); 967 idle_for(TAPPING_TERM + 1); 968 VERIFY_AND_CLEAR(driver); 969 970 EXPECT_EMPTY_REPORT(driver); 971 layer_tap_key.release(); 972 run_one_scan_loop(); 973 mod_tap_key.release(); 974 idle_for(FLOW_TAP_TERM + 1); 975 VERIFY_AND_CLEAR(driver); 976 // All mods are released. 977 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 978 } 979 980 // Test with a speculative mod tap key reached by a layer tap key, rolling from 981 // LT to MT key: 982 // "LT down, MT down, (wait out tapping term), LT up, MT up." 983 TEST_F(SpeculativeHoldFlowTapTest, lt_mt_different_layer_roll) { 984 TestDriver driver; 985 InSequence s; 986 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 987 auto regular_key = KeymapKey(0, 1, 0, KC_B); 988 auto placeholder_key = KeymapKey(1, 0, 0, KC_NO); 989 auto mod_tap_key = KeymapKey(1, 1, 0, SFT_T(KC_C)); 990 991 set_keymap({layer_tap_key, regular_key, placeholder_key, mod_tap_key}); 992 993 // Press layer tap key. 994 EXPECT_NO_REPORT(driver); 995 layer_tap_key.press(); 996 idle_for(FLOW_TAP_TERM + 1); 997 // Press mod tap key. 998 mod_tap_key.press(); 999 idle_for(TAPPING_TERM - FLOW_TAP_TERM); 1000 VERIFY_AND_CLEAR(driver); 1001 1002 // Release keys. 1003 EXPECT_REPORT(driver, (KC_B)); 1004 layer_tap_key.release(); 1005 idle_for(TAPPING_TERM); 1006 VERIFY_AND_CLEAR(driver); 1007 1008 EXPECT_EMPTY_REPORT(driver); 1009 mod_tap_key.release(); 1010 idle_for(FLOW_TAP_TERM + 1); 1011 VERIFY_AND_CLEAR(driver); 1012 // All mods are released. 1013 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 1014 } 1015 1016 // Test with a speculative mod tap key reached by a layer tap key, slowly 1017 // rolling from LT to MT key: 1018 // "LT down, (wait), MT down, (wait), LT up, MT up." 1019 TEST_F(SpeculativeHoldFlowTapTest, lt_mt_different_layer_slow_roll) { 1020 TestDriver driver; 1021 InSequence s; 1022 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 1023 auto regular_key = KeymapKey(0, 1, 0, KC_B); 1024 auto placeholder_key = KeymapKey(1, 0, 0, KC_NO); 1025 auto mod_tap_key = KeymapKey(1, 1, 0, SFT_T(KC_C)); 1026 1027 set_keymap({layer_tap_key, regular_key, placeholder_key, mod_tap_key}); 1028 1029 EXPECT_NO_REPORT(driver); 1030 layer_tap_key.press(); 1031 idle_for(TAPPING_TERM + 1); 1032 1033 EXPECT_REPORT(driver, (KC_LSFT)); 1034 mod_tap_key.press(); 1035 idle_for(FLOW_TAP_TERM + 1); 1036 VERIFY_AND_CLEAR(driver); 1037 1038 EXPECT_EMPTY_REPORT(driver); 1039 EXPECT_REPORT(driver, (KC_B)); 1040 EXPECT_EMPTY_REPORT(driver); 1041 layer_tap_key.release(); 1042 run_one_scan_loop(); 1043 mod_tap_key.release(); 1044 idle_for(FLOW_TAP_TERM + 1); 1045 VERIFY_AND_CLEAR(driver); 1046 // All mods are released. 1047 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 1048 } 1049 1050 // Test with a speculative mod tap key reached by a layer tap key, trying a 1051 // nested press: 1052 // "LT down, MT down, (wait out tapping term), MT up, LT up." 1053 TEST_F(SpeculativeHoldFlowTapTest, lt_mt_different_layer_nested_press) { 1054 TestDriver driver; 1055 InSequence s; 1056 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 1057 auto regular_key = KeymapKey(0, 1, 0, KC_B); 1058 auto placeholder_key = KeymapKey(1, 0, 0, KC_NO); 1059 auto mod_tap_key = KeymapKey(1, 1, 0, SFT_T(KC_C)); 1060 1061 set_keymap({layer_tap_key, regular_key, placeholder_key, mod_tap_key}); 1062 1063 EXPECT_NO_REPORT(driver); 1064 layer_tap_key.press(); 1065 idle_for(FLOW_TAP_TERM + 1); 1066 mod_tap_key.press(); 1067 idle_for(TAPPING_TERM - FLOW_TAP_TERM); 1068 VERIFY_AND_CLEAR(driver); 1069 1070 // Release keys. 1071 EXPECT_REPORT(driver, (KC_C)); 1072 EXPECT_EMPTY_REPORT(driver); 1073 mod_tap_key.release(); 1074 run_one_scan_loop(); 1075 layer_tap_key.release(); 1076 idle_for(FLOW_TAP_TERM + 1); 1077 VERIFY_AND_CLEAR(driver); 1078 // All mods are released. 1079 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 1080 } 1081 1082 // Test with a speculative mod tap key reached by a layer tap key, trying a 1083 // slow nested press: 1084 // "LT down, (wait), MT down, MT up, LT up." 1085 TEST_F(SpeculativeHoldFlowTapTest, lt_mt_different_layer_slow_nested_press) { 1086 TestDriver driver; 1087 InSequence s; 1088 auto layer_tap_key = KeymapKey(0, 0, 0, LT(1, KC_A)); 1089 auto regular_key = KeymapKey(0, 1, 0, KC_B); 1090 auto placeholder_key = KeymapKey(1, 0, 0, KC_NO); 1091 auto mod_tap_key = KeymapKey(1, 1, 0, SFT_T(KC_C)); 1092 1093 set_keymap({layer_tap_key, regular_key, placeholder_key, mod_tap_key}); 1094 1095 EXPECT_NO_REPORT(driver); 1096 layer_tap_key.press(); 1097 idle_for(TAPPING_TERM + 1); 1098 1099 EXPECT_REPORT(driver, (KC_LSFT)); 1100 mod_tap_key.press(); 1101 idle_for(FLOW_TAP_TERM + 1); 1102 VERIFY_AND_CLEAR(driver); 1103 1104 EXPECT_EMPTY_REPORT(driver); 1105 EXPECT_REPORT(driver, (KC_C)); 1106 EXPECT_EMPTY_REPORT(driver); 1107 mod_tap_key.release(); 1108 run_one_scan_loop(); 1109 layer_tap_key.release(); 1110 idle_for(FLOW_TAP_TERM + 1); 1111 VERIFY_AND_CLEAR(driver); 1112 // All mods are released. 1113 EXPECT_EQ(get_mods() | get_speculative_mods(), 0); 1114 }