logo

qmk_firmware

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

test_key_roll.cpp (11949B)

    

  1. /* Copyright 2024 John Rigoni
  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 3 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 "keyboard_report_util.hpp"
  18. #include "keycode.h"
  19. #include "keycodes.h"
  20. #include "test_common.hpp"
  21. #include "action_tapping.h"
  22. #include "test_keymap_key.hpp"
  24. using testing::_;
  25. using testing::InSequence;
  27. class RetroTapKeyRoll : public TestFixture {};
  29. TEST_F(RetroTapKeyRoll, regular_to_left_gui_mod_over_tap_term) {
  30.     TestDriver driver;
  31.     InSequence s;
  32.     auto       mod_tap_hold_key = KeymapKey(0, 1, 0, LGUI_T(KC_P));
  33.     auto       regular_key      = KeymapKey(0, 2, 0, KC_B);
  35.     set_keymap({mod_tap_hold_key, regular_key});
  37.     EXPECT_REPORT(driver, (KC_B));
  38.     regular_key.press();
  39.     run_one_scan_loop();
  40.     VERIFY_AND_CLEAR(driver);
  42.     EXPECT_NO_REPORT(driver);
  43.     mod_tap_hold_key.press();
  44.     idle_for(TAPPING_TERM);
  45.     VERIFY_AND_CLEAR(driver);
  47.     EXPECT_REPORT(driver, (KC_B, KC_LEFT_GUI));
  48.     run_one_scan_loop();
  49.     VERIFY_AND_CLEAR(driver);
  51.     EXPECT_REPORT(driver, (KC_LEFT_GUI));
  52.     regular_key.release();
  53.     run_one_scan_loop();
  54.     VERIFY_AND_CLEAR(driver);
  56.     EXPECT_REPORT(driver, (KC_LEFT_GUI, DUMMY_MOD_NEUTRALIZER_KEYCODE));
  57.     EXPECT_REPORT(driver, (KC_LEFT_GUI));
  58.     EXPECT_EMPTY_REPORT(driver);
  59.     EXPECT_REPORT(driver, (KC_P));
  60.     EXPECT_EMPTY_REPORT(driver);
  61.     mod_tap_hold_key.release();
  62.     run_one_scan_loop();
  63.     VERIFY_AND_CLEAR(driver);
  64. }
  66. TEST_F(RetroTapKeyRoll, regular_to_mod_over_tap_term) {
  67.     TestDriver driver;
  68.     InSequence s;
  69.     auto       mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_A));
  70.     auto       regular_key      = KeymapKey(0, 2, 0, KC_B);
  72.     set_keymap({mod_tap_hold_key, regular_key});
  74.     EXPECT_REPORT(driver, (KC_B));
  75.     regular_key.press();
  76.     run_one_scan_loop();
  77.     VERIFY_AND_CLEAR(driver);
  79.     EXPECT_REPORT(driver, (KC_B, KC_LEFT_SHIFT));
  80.     mod_tap_hold_key.press();
  81.     idle_for(TAPPING_TERM);
  82.     run_one_scan_loop();
  83.     VERIFY_AND_CLEAR(driver);
  85.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  86.     regular_key.release();
  87.     run_one_scan_loop();
  88.     VERIFY_AND_CLEAR(driver);
  90.     EXPECT_EMPTY_REPORT(driver);
  91.     EXPECT_REPORT(driver, (KC_A));
  92.     EXPECT_EMPTY_REPORT(driver);
  93.     mod_tap_hold_key.release();
  94.     run_one_scan_loop();
  95.     VERIFY_AND_CLEAR(driver);
  96. }
  98. TEST_F(RetroTapKeyRoll, regular_to_mod_under_tap_term) {
  99.     TestDriver driver;
  100.     InSequence s;
  101.     auto       mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_A));
  102.     auto       regular_key      = KeymapKey(0, 2, 0, KC_B);
  104.     set_keymap({mod_tap_hold_key, regular_key});
  106.     EXPECT_REPORT(driver, (KC_B));
  107.     regular_key.press();
  108.     run_one_scan_loop();
  109.     VERIFY_AND_CLEAR(driver);
  111.     EXPECT_NO_REPORT(driver);
  112.     mod_tap_hold_key.press();
  113.     run_one_scan_loop();
  114.     VERIFY_AND_CLEAR(driver);
  116.     EXPECT_EMPTY_REPORT(driver);
  117.     regular_key.release();
  118.     run_one_scan_loop();
  119.     VERIFY_AND_CLEAR(driver);
  121.     EXPECT_REPORT(driver, (KC_A));
  122.     EXPECT_EMPTY_REPORT(driver);
  123.     mod_tap_hold_key.release();
  124.     run_one_scan_loop();
  125.     VERIFY_AND_CLEAR(driver);
  126. }
  128. TEST_F(RetroTapKeyRoll, mod_under_tap_term_to_regular) {
  129.     TestDriver driver;
  130.     InSequence s;
  131.     auto       mod_tap_hold_key = KeymapKey(0, 1, 0, LGUI_T(KC_P));
  132.     auto       regular_key      = KeymapKey(0, 2, 0, KC_B);
  134.     set_keymap({mod_tap_hold_key, regular_key});
  136.     EXPECT_NO_REPORT(driver);
  137.     mod_tap_hold_key.press();
  138.     run_one_scan_loop();
  139.     VERIFY_AND_CLEAR(driver);
  141.     EXPECT_NO_REPORT(driver);
  142.     regular_key.press();
  143.     run_one_scan_loop();
  144.     VERIFY_AND_CLEAR(driver);
  146.     EXPECT_REPORT(driver, (KC_P));
  147.     EXPECT_REPORT(driver, (KC_B, KC_P));
  148.     EXPECT_REPORT(driver, (KC_B));
  149.     mod_tap_hold_key.release();
  150.     run_one_scan_loop();
  151.     VERIFY_AND_CLEAR(driver);
  153.     EXPECT_EMPTY_REPORT(driver);
  154.     regular_key.release();
  155.     run_one_scan_loop();
  156.     VERIFY_AND_CLEAR(driver);
  157. }
  159. TEST_F(RetroTapKeyRoll, mod_over_tap_term_to_regular) {
  160.     TestDriver driver;
  161.     InSequence s;
  162.     auto       mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_A));
  163.     auto       regular_key      = KeymapKey(0, 2, 0, KC_B);
  165.     set_keymap({mod_tap_hold_key, regular_key});
  167.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  168.     mod_tap_hold_key.press();
  169.     idle_for(TAPPING_TERM);
  170.     run_one_scan_loop();
  171.     VERIFY_AND_CLEAR(driver);
  173.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_B));
  174.     regular_key.press();
  175.     run_one_scan_loop();
  176.     VERIFY_AND_CLEAR(driver);
  178.     EXPECT_REPORT(driver, (KC_B));
  179.     mod_tap_hold_key.release();
  180.     run_one_scan_loop();
  181.     VERIFY_AND_CLEAR(driver);
  183.     EXPECT_EMPTY_REPORT(driver);
  184.     regular_key.release();
  185.     run_one_scan_loop();
  186.     VERIFY_AND_CLEAR(driver);
  187. }
  189. TEST_F(RetroTapKeyRoll, mod_under_tap_term_to_mod_under_tap_term) {
  190.     TestDriver driver;
  191.     InSequence s;
  192.     auto       mod_tap_hold_gui   = KeymapKey(0, 1, 0, LGUI_T(KC_P));
  193.     auto       mod_tap_hold_lshft = KeymapKey(0, 2, 0, SFT_T(KC_A));
  195.     set_keymap({mod_tap_hold_gui, mod_tap_hold_lshft});
  197.     EXPECT_NO_REPORT(driver);
  198.     mod_tap_hold_lshft.press();
  199.     run_one_scan_loop();
  200.     VERIFY_AND_CLEAR(driver);
  202.     EXPECT_NO_REPORT(driver);
  203.     mod_tap_hold_gui.press();
  204.     run_one_scan_loop();
  205.     VERIFY_AND_CLEAR(driver);
  207.     EXPECT_REPORT(driver, (KC_A));
  208.     EXPECT_EMPTY_REPORT(driver);
  209.     mod_tap_hold_lshft.release();
  210.     run_one_scan_loop();
  211.     VERIFY_AND_CLEAR(driver);
  213.     EXPECT_REPORT(driver, (KC_P));
  214.     EXPECT_EMPTY_REPORT(driver);
  215.     mod_tap_hold_gui.release();
  216.     run_one_scan_loop();
  217.     VERIFY_AND_CLEAR(driver);
  218. }
  220. TEST_F(RetroTapKeyRoll, mod_over_tap_term_to_mod_under_tap_term) {
  221.     TestDriver driver;
  222.     InSequence s;
  223.     auto       mod_tap_hold_gui   = KeymapKey(0, 1, 0, LGUI_T(KC_P));
  224.     auto       mod_tap_hold_lshft = KeymapKey(0, 2, 0, SFT_T(KC_A));
  226.     set_keymap({mod_tap_hold_gui, mod_tap_hold_lshft});
  228.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  229.     mod_tap_hold_lshft.press();
  230.     idle_for(TAPPING_TERM);
  231.     run_one_scan_loop();
  232.     VERIFY_AND_CLEAR(driver);
  234.     EXPECT_NO_REPORT(driver);
  235.     mod_tap_hold_gui.press();
  236.     run_one_scan_loop();
  237.     VERIFY_AND_CLEAR(driver);
  239.     EXPECT_NO_REPORT(driver);
  240.     mod_tap_hold_lshft.release();
  241.     run_one_scan_loop();
  242.     VERIFY_AND_CLEAR(driver);
  244.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_P));
  245.     EXPECT_REPORT(driver, (KC_P));
  246.     EXPECT_EMPTY_REPORT(driver);
  247.     mod_tap_hold_gui.release();
  248.     run_one_scan_loop();
  249.     VERIFY_AND_CLEAR(driver);
  250. }
  252. TEST_F(RetroTapKeyRoll, mod_under_tap_term_to_mod_over_tap_term) {
  253.     TestDriver driver;
  254.     InSequence s;
  255.     auto       mod_tap_hold_gui   = KeymapKey(0, 1, 0, LGUI_T(KC_P));
  256.     auto       mod_tap_hold_lshft = KeymapKey(0, 2, 0, SFT_T(KC_A));
  258.     set_keymap({mod_tap_hold_gui, mod_tap_hold_lshft});
  260.     EXPECT_NO_REPORT(driver);
  261.     mod_tap_hold_lshft.press();
  262.     run_one_scan_loop();
  263.     VERIFY_AND_CLEAR(driver);
  265.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  266.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_LEFT_GUI));
  267.     mod_tap_hold_gui.press();
  268.     idle_for(TAPPING_TERM);
  269.     run_one_scan_loop();
  270.     VERIFY_AND_CLEAR(driver);
  272.     EXPECT_REPORT(driver, (KC_LEFT_GUI));
  273.     mod_tap_hold_lshft.release();
  274.     run_one_scan_loop();
  275.     VERIFY_AND_CLEAR(driver);
  277.     EXPECT_REPORT(driver, (KC_LEFT_GUI, DUMMY_MOD_NEUTRALIZER_KEYCODE));
  278.     EXPECT_REPORT(driver, (KC_LEFT_GUI));
  279.     EXPECT_EMPTY_REPORT(driver);
  280.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  281.     EXPECT_REPORT(driver, (KC_P, KC_LEFT_SHIFT));
  282.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  283.     EXPECT_EMPTY_REPORT(driver);
  284.     mod_tap_hold_gui.release();
  285.     run_one_scan_loop();
  286.     VERIFY_AND_CLEAR(driver);
  287. }
  289. TEST_F(RetroTapKeyRoll, mod_under_tap_term_to_mod_over_tap_term_offset) {
  290.     TestDriver driver;
  291.     InSequence s;
  292.     auto       mod_tap_hold_gui   = KeymapKey(0, 1, 0, LGUI_T(KC_P));
  293.     auto       mod_tap_hold_lshft = KeymapKey(0, 2, 0, SFT_T(KC_A));
  295.     set_keymap({mod_tap_hold_gui, mod_tap_hold_lshft});
  297.     EXPECT_NO_REPORT(driver);
  298.     mod_tap_hold_lshft.press();
  299.     run_one_scan_loop();
  300.     VERIFY_AND_CLEAR(driver);
  302.     EXPECT_NO_REPORT(driver);
  303.     mod_tap_hold_gui.press();
  304.     run_one_scan_loop();
  305.     VERIFY_AND_CLEAR(driver);
  307.     EXPECT_REPORT(driver, (KC_A));
  308.     EXPECT_EMPTY_REPORT(driver);
  309.     mod_tap_hold_lshft.release();
  310.     run_one_scan_loop();
  311.     VERIFY_AND_CLEAR(driver);
  313.     EXPECT_REPORT(driver, (KC_LEFT_GUI));
  314.     EXPECT_REPORT(driver, (KC_LEFT_GUI, DUMMY_MOD_NEUTRALIZER_KEYCODE));
  315.     EXPECT_REPORT(driver, (KC_LEFT_GUI));
  316.     EXPECT_EMPTY_REPORT(driver);
  317.     EXPECT_REPORT(driver, (KC_P));
  318.     EXPECT_EMPTY_REPORT(driver);
  319.     idle_for(TAPPING_TERM);
  320.     mod_tap_hold_gui.release();
  321.     run_one_scan_loop();
  322.     VERIFY_AND_CLEAR(driver);
  323. }
  325. TEST_F(RetroTapKeyRoll, mod_over_tap_term_to_mod_over_tap_term) {
  326.     TestDriver driver;
  327.     InSequence s;
  328.     auto       mod_tap_hold_gui   = KeymapKey(0, 1, 0, LGUI_T(KC_P));
  329.     auto       mod_tap_hold_lshft = KeymapKey(0, 2, 0, SFT_T(KC_A));
  331.     set_keymap({mod_tap_hold_gui, mod_tap_hold_lshft});
  333.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  334.     mod_tap_hold_lshft.press();
  335.     idle_for(TAPPING_TERM);
  336.     run_one_scan_loop();
  337.     VERIFY_AND_CLEAR(driver);
  339.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_LEFT_GUI));
  340.     mod_tap_hold_gui.press();
  341.     idle_for(TAPPING_TERM);
  342.     run_one_scan_loop();
  343.     VERIFY_AND_CLEAR(driver);
  345.     EXPECT_REPORT(driver, (KC_LEFT_GUI));
  346.     mod_tap_hold_lshft.release();
  347.     run_one_scan_loop();
  348.     VERIFY_AND_CLEAR(driver);
  350.     EXPECT_REPORT(driver, (KC_LEFT_GUI, DUMMY_MOD_NEUTRALIZER_KEYCODE));
  351.     EXPECT_REPORT(driver, (KC_LEFT_GUI));
  352.     EXPECT_EMPTY_REPORT(driver);
  353.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  354.     EXPECT_REPORT(driver, (KC_P, KC_LEFT_SHIFT));
  355.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  356.     EXPECT_EMPTY_REPORT(driver);
  357.     mod_tap_hold_gui.release();
  358.     run_one_scan_loop();
  359.     VERIFY_AND_CLEAR(driver);
  360. }
  362. TEST_F(RetroTapKeyRoll, mod_to_mod_to_mod) {
  363.     TestDriver driver;
  364.     InSequence s;
  365.     auto       mod_tap_hold_lalt  = KeymapKey(0, 1, 0, LALT_T(KC_R));
  366.     auto       mod_tap_hold_lshft = KeymapKey(0, 2, 0, SFT_T(KC_A));
  367.     auto       mod_tap_hold_lctrl = KeymapKey(0, 3, 0, LCTL_T(KC_C));
  369.     set_keymap({mod_tap_hold_lalt, mod_tap_hold_lshft, mod_tap_hold_lctrl});
  371.     EXPECT_REPORT(driver, (KC_LEFT_ALT));
  372.     mod_tap_hold_lalt.press();
  373.     idle_for(TAPPING_TERM);
  374.     run_one_scan_loop();
  375.     VERIFY_AND_CLEAR(driver);
  377.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_LEFT_ALT));
  378.     mod_tap_hold_lshft.press();
  379.     idle_for(TAPPING_TERM);
  380.     run_one_scan_loop();
  381.     VERIFY_AND_CLEAR(driver);
  383.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  384.     mod_tap_hold_lalt.release();
  385.     run_one_scan_loop();
  386.     VERIFY_AND_CLEAR(driver);
  388.     EXPECT_REPORT(driver, (KC_LEFT_CTRL, KC_LEFT_SHIFT));
  389.     EXPECT_NO_REPORT(driver);
  390.     mod_tap_hold_lctrl.press();
  391.     idle_for(TAPPING_TERM);
  392.     run_one_scan_loop();
  393.     VERIFY_AND_CLEAR(driver);
  395.     EXPECT_REPORT(driver, (KC_LEFT_CTRL));
  396.     mod_tap_hold_lshft.release();
  397.     run_one_scan_loop();
  398.     VERIFY_AND_CLEAR(driver);
  400.     EXPECT_EMPTY_REPORT(driver);
  401.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  402.     EXPECT_REPORT(driver, (KC_C, KC_LEFT_SHIFT));
  403.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  404.     EXPECT_EMPTY_REPORT(driver);
  405.     mod_tap_hold_lctrl.release();
  406.     run_one_scan_loop();
  407.     VERIFY_AND_CLEAR(driver);
  408. }