logo

qmk_firmware

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

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.  */
  17. #include "action_util.h"
  18. #include "keyboard_report_util.hpp"
  19. #include "test_common.hpp"
  21. using testing::_;
  22. using testing::InSequence;
  24. class OneShot : public TestFixture {};
  25. class OneShotParametrizedTestFixture : public ::testing::WithParamInterface<std::pair<KeymapKey, KeymapKey>>, public OneShot {};
  27. TEST_F(OneShot, OSMWithoutAdditionalKeypressDoesNothing) {
  28.     TestDriver driver;
  29.     auto       osm_key = KeymapKey(0, 0, 0, OSM(MOD_LSFT), KC_LSFT);
  31.     set_keymap({osm_key});
  33.     /* Press and release OSM key*/
  34.     EXPECT_NO_REPORT(driver);
  35.     tap_key(osm_key);
  36.     VERIFY_AND_CLEAR(driver);
  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);
  43.     /* Make unit-test pass */
  44.     clear_oneshot_mods();
  45. }
  47. #if defined(ONESHOT_TIMEOUT)
  49. TEST_P(OneShotParametrizedTestFixture, OSMExpiredDoesNothing) {
  50.     TestDriver driver;
  51.     KeymapKey  osm_key     = GetParam().first;
  52.     KeymapKey  regular_key = GetParam().second;
  54.     set_keymap({osm_key, regular_key});
  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);
  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);
  70.     /* Release regular key */
  71.     EXPECT_EMPTY_REPORT(driver);
  72.     regular_key.release();
  73.     run_one_scan_loop();
  74.     VERIFY_AND_CLEAR(driver);
  75. }
  77. #endif
  79. TEST_P(OneShotParametrizedTestFixture, OSMWithAdditionalKeypress) {
  80.     TestDriver driver;
  81.     KeymapKey  osm_key     = GetParam().first;
  82.     KeymapKey  regular_key = GetParam().second;
  84.     set_keymap({osm_key, regular_key});
  86.     /* Press and release OSM */
  87.     EXPECT_NO_REPORT(driver);
  88.     tap_key(osm_key);
  89.     VERIFY_AND_CLEAR(driver);
  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);
  97.     /* Release regular key */
  98.     EXPECT_EMPTY_REPORT(driver);
  99.     regular_key.release();
  100.     run_one_scan_loop();
  101.     VERIFY_AND_CLEAR(driver);
  102. }
  104. TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypress) {
  105.     TestDriver          driver;
  106.     testing::InSequence s;
  108.     KeymapKey osm_key     = GetParam().first;
  109.     KeymapKey regular_key = GetParam().second;
  111.     set_keymap({osm_key, regular_key});
  113.     /* Press OSM */
  114.     EXPECT_NO_REPORT(driver);
  115.     osm_key.press();
  116.     run_one_scan_loop();
  117.     VERIFY_AND_CLEAR(driver);
  119.     /* Press regular key */
  120.     EXPECT_NO_REPORT(driver);
  121.     regular_key.press();
  122.     run_one_scan_loop();
  123.     VERIFY_AND_CLEAR(driver);
  125.     /* Release regular key */
  126.     EXPECT_NO_REPORT(driver);
  127.     regular_key.release();
  128.     run_one_scan_loop();
  129.     VERIFY_AND_CLEAR(driver);
  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. }
  139. // clang-format off
  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
  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};
  164.     set_keymap({osm_key1, osm_key2, regular_key});
  166.     /* Press and release OSM1 */
  167.     EXPECT_NO_REPORT(driver);
  168.     tap_key(osm_key1);
  169.     VERIFY_AND_CLEAR(driver);
  171.     /* Press and release OSM2 */
  172.     EXPECT_NO_REPORT(driver);
  173.     tap_key(osm_key2);
  174.     VERIFY_AND_CLEAR(driver);
  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);
  182.     /* Release regular key */
  183.     EXPECT_EMPTY_REPORT(driver);
  184.     regular_key.release();
  185.     run_one_scan_loop();
  186.     VERIFY_AND_CLEAR(driver);
  187. }
  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};
  196.     set_keymap({osm_key1, osm_key2, regular_key});
  198.     /* Press and release OSM1 */
  199.     EXPECT_NO_REPORT(driver);
  200.     tap_key(osm_key1);
  201.     VERIFY_AND_CLEAR(driver);
  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);
  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);
  215.     /* Release regular key */
  216.     EXPECT_EMPTY_REPORT(driver);
  217.     regular_key.release();
  218.     run_one_scan_loop();
  219.     VERIFY_AND_CLEAR(driver);
  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);
  227.     /* Release regular key */
  228.     EXPECT_EMPTY_REPORT(driver);
  229.     regular_key.release();
  230.     run_one_scan_loop();
  231.     VERIFY_AND_CLEAR(driver);
  232. }
  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};
  241.     set_keymap({osm_key1, osm_key2, regular_key});
  243.     /* Press and release OSM1 */
  244.     EXPECT_NO_REPORT(driver);
  245.     tap_key(osm_key1);
  246.     VERIFY_AND_CLEAR(driver);
  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);
  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);
  261.     /* Release OSM2 */
  262.     EXPECT_EMPTY_REPORT(driver);
  263.     osm_key2.release();
  264.     run_one_scan_loop();
  265.     VERIFY_AND_CLEAR(driver);
  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);
  273.     /* Release regular key */
  274.     EXPECT_EMPTY_REPORT(driver);
  275.     regular_key.release();
  276.     run_one_scan_loop();
  277.     VERIFY_AND_CLEAR(driver);
  278. }
  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};
  286.     set_keymap({osl_key, regular_key});
  288.     /* Press OSL key */
  289.     EXPECT_NO_REPORT(driver);
  290.     osl_key.press();
  291.     run_one_scan_loop();
  292.     VERIFY_AND_CLEAR(driver);
  294.     /* Release OSL key */
  295.     EXPECT_NO_REPORT(driver);
  296.     osl_key.release();
  297.     run_one_scan_loop();
  298.     VERIFY_AND_CLEAR(driver);
  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);
  307.     /* Release regular key */
  308.     EXPECT_NO_REPORT(driver);
  309.     regular_key.release();
  310.     run_one_scan_loop();
  311.     VERIFY_AND_CLEAR(driver);
  312. }
  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};
  321.     set_keymap({osl_key, osm_key, regular_key});
  323.     /* Press OSL key */
  324.     EXPECT_NO_REPORT(driver);
  325.     osl_key.press();
  326.     run_one_scan_loop();
  327.     VERIFY_AND_CLEAR(driver);
  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);
  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);
  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);
  350.     /* Release regular key */
  351.     EXPECT_NO_REPORT(driver);
  352.     regular_key.release();
  353.     run_one_scan_loop();
  354.     VERIFY_AND_CLEAR(driver);
  355. }
  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};
  364.     set_keymap({osl_key, mo_key, regular_key});
  366.     /* Press OSL key */
  367.     EXPECT_NO_REPORT(driver);
  368.     osl_key.press();
  369.     run_one_scan_loop();
  370.     VERIFY_AND_CLEAR(driver);
  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);
  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);
  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);
  393.     /* Release regular key */
  394.     EXPECT_EMPTY_REPORT(driver);
  395.     regular_key.release();
  396.     run_one_scan_loop();
  397.     VERIFY_AND_CLEAR(driver);
  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. }
  407. class OneShotLayerParametrizedTestFixture : public ::testing::WithParamInterface<uint16_t>, public OneShot {};
  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};
  416.     set_keymap({osl_key, action_key, regular_key});
  418.     /* Tap OSL key */
  419.     EXPECT_NO_REPORT(driver);
  420.     tap_key(osl_key);
  421.     run_one_scan_loop();
  422.     VERIFY_AND_CLEAR(driver);
  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);
  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);
  438.     /* Release regular key */
  439.     EXPECT_EMPTY_REPORT(driver);
  440.     regular_key.release();
  441.     run_one_scan_loop();
  442.     VERIFY_AND_CLEAR(driver);
  443. }
  445. INSTANTIATE_TEST_CASE_P(OneShotLayerTests, OneShotLayerParametrizedTestFixture, ::testing::Values(TG(2), TO(2)));
  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};
  454.     set_keymap({osl_key, df_key, regular_key});
  456.     layer_state_t default_layer_state_bak = default_layer_state;
  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);
  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);
  471.     VERIFY_AND_CLEAR(driver);
  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);
  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);
  486.     /* Release regular key */
  487.     EXPECT_EMPTY_REPORT(driver);
  488.     regular_key.release();
  489.     run_one_scan_loop();
  490.     VERIFY_AND_CLEAR(driver);
  492.     default_layer_state = default_layer_state_bak;
  493. }
  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};
  502.     set_keymap({osl1_key, osl2_key, regular_key});
  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);
  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);
  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);
  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. }
  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));
  543.     set_keymap({osl_key, lt_key});
  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);
  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. }
  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);
  568.     set_keymap({osl_key, lt_key, regular_key});
  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);
  577.     /* Press LT key. */
  578.     EXPECT_NO_REPORT(driver);
  579.     lt_key.press();
  580.     run_one_scan_loop();
  581.     VERIFY_AND_CLEAR(driver);
  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));
  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);
  595.     /* Release regular key. */
  596.     EXPECT_EMPTY_REPORT(driver);
  597.     regular_key.release();
  598.     run_one_scan_loop();
  599.     VERIFY_AND_CLEAR(driver);
  600. }
  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);
  609.     set_keymap({osl_key, mod_tap_hold_key, regular_key});
  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);
  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);
  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);
  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);
  637.     /* Release regular key. */
  638.     EXPECT_EMPTY_REPORT(driver);
  639.     regular_key.release();
  640.     run_one_scan_loop();
  641.     VERIFY_AND_CLEAR(driver);
  642. }
  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);
  651.     set_keymap({osl_key, mod_tap_hold_key, regular_key});
  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);
  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);
  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);
  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);
  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);
  684.     /* Release regular key. */
  685.     EXPECT_NO_REPORT(driver);
  686.     regular_key.release();
  687.     run_one_scan_loop();
  688.     VERIFY_AND_CLEAR(driver);
  689. }