logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

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.
  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"
  22. using testing::_;
  23. using testing::AnyNumber;
  24. using testing::InSequence;
  26. class FlowTapTest : public TestFixture {};
  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));
  37.     set_keymap({regular_key, mod_tap_key1, mod_tap_key2, mod_tap_key3});
  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);
  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);
  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);
  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);
  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);
  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);
  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);
  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);
  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);
  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);
  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. }
  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));
  118.     set_keymap({ctrl_key, shft_key, alt_key, gui_key, regular_key, mod_tap_key});
  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();
  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);
  132.         EXPECT_REPORT(driver, (mod_key->code));
  133.         regular_key.release();
  134.         run_one_scan_loop();
  135.         VERIFY_AND_CLEAR(driver);
  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);
  143.         // Release mod-tap.
  144.         EXPECT_REPORT(driver, (mod_key->code));
  145.         mod_tap_key.release();
  146.         run_one_scan_loop();
  148.         // Release mod key.
  149.         EXPECT_EMPTY_REPORT(driver);
  150.         mod_key->release();
  151.         run_one_scan_loop();
  152.         VERIFY_AND_CLEAR(driver);
  153.     }
  155.     // Hold Shift key.
  156.     EXPECT_REPORT(driver, (KC_LSFT));
  157.     shft_key.press();
  158.     run_one_scan_loop();
  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);
  166.     EXPECT_REPORT(driver, (KC_LSFT));
  167.     regular_key.release();
  168.     run_one_scan_loop();
  169.     VERIFY_AND_CLEAR(driver);
  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);
  177.     // Release mod-tap.
  178.     EXPECT_REPORT(driver, (KC_LSFT));
  179.     mod_tap_key.release();
  180.     run_one_scan_loop();
  182.     // Release Shift key.
  183.     EXPECT_EMPTY_REPORT(driver);
  184.     shft_key.release();
  185.     run_one_scan_loop();
  186.     VERIFY_AND_CLEAR(driver);
  187. }
  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));
  197.     set_keymap({regular_key, mod_tap_key1, mod_tap_key2});
  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);
  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);
  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);
  218.     // Hold for longer than the tapping term.
  219.     EXPECT_NO_REPORT(driver);
  220.     idle_for(TAPPING_TERM + 1);
  221.     VERIFY_AND_CLEAR(driver);
  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. }
  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));
  239.     set_keymap({regular_key, mod_tap_key});
  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);
  247.     EXPECT_NO_REPORT(driver);
  248.     idle_for(FLOW_TAP_TERM + 1);
  249.     VERIFY_AND_CLEAR(driver);
  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);
  257.     // Hold for the tapping term.
  258.     EXPECT_REPORT(driver, (KC_LSFT));
  259.     idle_for(TAPPING_TERM);
  260.     VERIFY_AND_CLEAR(driver);
  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. }
  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));
  276.     set_keymap({regular_key, mod_tap_key1, mod_tap_key2});
  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);
  284.     EXPECT_NO_REPORT(driver);
  285.     idle_for(FLOW_TAP_TERM + 1);
  286.     VERIFY_AND_CLEAR(driver);
  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);
  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);
  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. }
  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));
  324.     set_keymap({regular_key, mod_key, mod_tap_key});
  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);
  332.     EXPECT_NO_REPORT(driver);
  333.     idle_for(FLOW_TAP_TERM + 1);
  334.     VERIFY_AND_CLEAR(driver);
  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);
  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);
  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. }
  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);
  371.     set_keymap({regular_key, layer_tap_key, regular_key2});
  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);
  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);
  385.     EXPECT_NO_REPORT(driver);
  386.     idle_for(TAPPING_TERM + 1);
  387.     VERIFY_AND_CLEAR(driver);
  389.     // Release layer-tap key.
  390.     EXPECT_EMPTY_REPORT(driver);
  391.     layer_tap_key.release();
  392.     run_one_scan_loop();
  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);
  400.     EXPECT_NO_REPORT(driver);
  401.     idle_for(FLOW_TAP_TERM + 1);
  402.     VERIFY_AND_CLEAR(driver);
  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);
  410.     EXPECT_NO_REPORT(driver);
  411.     idle_for(TAPPING_TERM + 1);
  412.     EXPECT_EQ(layer_state, 1 << 1);
  413.     VERIFY_AND_CLEAR(driver);
  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);
  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. }
  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));
  436.     set_keymap({no_key, regular_key, layer_tap_key, mod_tap_key});
  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);
  447.     EXPECT_REPORT(driver, (KC_LCTL));
  448.     mod_tap_key.press();
  449.     idle_for(TAPPING_TERM + 1);
  450.     VERIFY_AND_CLEAR(driver);
  452.     EXPECT_EMPTY_REPORT(driver);
  453.     mod_tap_key.release();
  454.     run_one_scan_loop();
  455.     VERIFY_AND_CLEAR(driver);
  456. }
  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);
  470.     set_keymap({regular_key1, layer_tap_key, mod_tap_key1, mod_tap_key2, regular_key2});
  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);
  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);
  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);
  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);
  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);
  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);
  510.     EXPECT_EMPTY_REPORT(driver);
  511.     mod_tap_key1.release();
  512.     run_one_scan_loop();
  513.     VERIFY_AND_CLEAR(driver);
  514. }
  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));
  524.     set_keymap({no_key, regular_key, layer_tap_key, mod_tap_key});
  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);
  535.     EXPECT_REPORT(driver, (KC_B));
  536.     mod_tap_key.press();
  537.     run_one_scan_loop();
  538.     VERIFY_AND_CLEAR(driver);
  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. }
  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));
  554.     set_keymap({regular_key, mod_tap_key, layer_tap_key});
  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);
  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);
  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);
  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. }
  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));
  587.     set_keymap({regular_key, osm_key});
  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);
  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);
  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. }
  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));
  621.     set_keymap({mod_tap_key});
  623.     EXPECT_REPORT(driver, (KC_A));
  624.     EXPECT_EMPTY_REPORT(driver);
  625.     tap_key(mod_tap_key);
  626.     VERIFY_AND_CLEAR(driver);
  628.     EXPECT_REPORT(driver, (KC_A));
  629.     mod_tap_key.press();
  630.     run_one_scan_loop();
  631.     VERIFY_AND_CLEAR(driver);
  633.     EXPECT_NO_REPORT(driver);
  634.     idle_for(TAPPING_TERM + 1);
  635.     VERIFY_AND_CLEAR(driver);
  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. }
  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));
  650.     set_keymap({mod_tap_key1, mod_tap_key2});
  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);
  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);
  667.     // Hold for longer than the tapping term.
  668.     EXPECT_NO_REPORT(driver);
  669.     idle_for(TAPPING_TERM + 1);
  670.     VERIFY_AND_CLEAR(driver);
  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. }
  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);
  686.     set_keymap({layer_tap_key, mod_tap_key, regular_key});
  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);
  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);
  706.     // Hold for longer than the tapping term.
  707.     EXPECT_NO_REPORT(driver);
  708.     idle_for(TAPPING_TERM + 1);
  709.     VERIFY_AND_CLEAR(driver);
  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. }
  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));
  728.     set_keymap({layer_tap_key, regular_key, mod_tap_key});
  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);
  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);
  748.     // Hold for longer than the tapping term.
  749.     EXPECT_NO_REPORT(driver);
  750.     idle_for(TAPPING_TERM + 1);
  751.     VERIFY_AND_CLEAR(driver);
  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. }
  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));
  770.     set_keymap({mod_tap_key1, mod_tap_key2, mod_tap_key3});
  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);
  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);
  792.     // Hold for longer than the tapping term.
  793.     EXPECT_NO_REPORT(driver);
  794.     idle_for(TAPPING_TERM + 1);
  795.     VERIFY_AND_CLEAR(driver);
  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. }
  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));
  814.     set_keymap({mod_tap_key1, mod_tap_key2, mod_tap_key3});
  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);
  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);
  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. }