logo

qmk_firmware

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

test_tap_hold.cpp (6524B)

    

  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 "keyboard_report_util.hpp"
  18. #include "keycode.h"
  19. #include "test_common.hpp"
  20. #include "action_tapping.h"
  21. #include "test_fixture.hpp"
  22. #include "test_keymap_key.hpp"
  24. using testing::_;
  25. using testing::InSequence;
  27. class DefaultTapHold : public TestFixture {};
  29. TEST_F(DefaultTapHold, tap_regular_key_while_mod_tap_key_is_held) {
  30.     TestDriver driver;
  31.     InSequence s;
  32.     auto       mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P));
  33.     auto       regular_key      = KeymapKey(0, 2, 0, KC_A);
  35.     set_keymap({mod_tap_hold_key, regular_key});
  37.     /* Press mod-tap-hold key. */
  38.     EXPECT_NO_REPORT(driver);
  39.     mod_tap_hold_key.press();
  40.     run_one_scan_loop();
  41.     VERIFY_AND_CLEAR(driver);
  43.     /* Press regular key. */
  44.     EXPECT_NO_REPORT(driver);
  45.     regular_key.press();
  46.     run_one_scan_loop();
  47.     VERIFY_AND_CLEAR(driver);
  49.     /* Release regular key. */
  50.     EXPECT_NO_REPORT(driver);
  51.     regular_key.release();
  52.     run_one_scan_loop();
  53.     VERIFY_AND_CLEAR(driver);
  55.     /* Release mod-tap-hold key. */
  56.     EXPECT_REPORT(driver, (KC_P));
  57.     EXPECT_REPORT(driver, (KC_P, KC_A));
  58.     EXPECT_REPORT(driver, (KC_P));
  59.     EXPECT_EMPTY_REPORT(driver);
  60.     mod_tap_hold_key.release();
  61.     run_one_scan_loop();
  62.     VERIFY_AND_CLEAR(driver);
  64.     /* Idle for tapping term of mod tap hold key. */
  65.     idle_for(TAPPING_TERM - 3);
  66.     VERIFY_AND_CLEAR(driver);
  67. }
  69. TEST_F(DefaultTapHold, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) {
  70.     TestDriver driver;
  71.     InSequence s;
  72.     auto       first_mod_tap_hold_key  = KeymapKey(0, 1, 0, SFT_T(KC_P));
  73.     auto       second_mod_tap_hold_key = KeymapKey(0, 2, 0, RSFT_T(KC_A));
  75.     set_keymap({first_mod_tap_hold_key, second_mod_tap_hold_key});
  77.     /* Press first mod-tap-hold key */
  78.     EXPECT_NO_REPORT(driver);
  79.     first_mod_tap_hold_key.press();
  80.     run_one_scan_loop();
  81.     VERIFY_AND_CLEAR(driver);
  83.     /* Press second tap-hold key */
  84.     EXPECT_NO_REPORT(driver);
  85.     second_mod_tap_hold_key.press();
  86.     run_one_scan_loop();
  87.     VERIFY_AND_CLEAR(driver);
  89.     /* Release second tap-hold key */
  90.     EXPECT_NO_REPORT(driver);
  91.     second_mod_tap_hold_key.release();
  92.     run_one_scan_loop();
  93.     VERIFY_AND_CLEAR(driver);
  95.     /* Release first mod-tap-hold key */
  96.     EXPECT_REPORT(driver, (KC_P));
  97.     EXPECT_REPORT(driver, (KC_P, KC_A));
  98.     EXPECT_REPORT(driver, (KC_P));
  99.     EXPECT_EMPTY_REPORT(driver);
  100.     first_mod_tap_hold_key.release();
  101.     run_one_scan_loop();
  102.     VERIFY_AND_CLEAR(driver);
  103. }
  105. TEST_F(DefaultTapHold, tap_regular_key_while_layer_tap_key_is_held) {
  106.     TestDriver driver;
  107.     InSequence s;
  108.     auto       layer_tap_hold_key = KeymapKey(0, 1, 0, LT(1, KC_P));
  109.     auto       regular_key        = KeymapKey(0, 2, 0, KC_A);
  110.     auto       layer_key          = KeymapKey(1, 2, 0, KC_B);
  112.     set_keymap({layer_tap_hold_key, regular_key, layer_key});
  114.     /* Press layer-tap-hold key */
  115.     EXPECT_NO_REPORT(driver);
  116.     layer_tap_hold_key.press();
  117.     run_one_scan_loop();
  118.     VERIFY_AND_CLEAR(driver);
  120.     /* Press regular key */
  121.     EXPECT_NO_REPORT(driver);
  122.     regular_key.press();
  123.     run_one_scan_loop();
  124.     VERIFY_AND_CLEAR(driver);
  126.     /* Release regular key */
  127.     EXPECT_NO_REPORT(driver);
  128.     regular_key.release();
  129.     run_one_scan_loop();
  130.     VERIFY_AND_CLEAR(driver);
  132.     /* Release layer-tap-hold key */
  133.     EXPECT_REPORT(driver, (KC_P));
  134.     EXPECT_REPORT(driver, (KC_P, KC_A));
  135.     EXPECT_REPORT(driver, (KC_P));
  136.     EXPECT_EMPTY_REPORT(driver);
  137.     layer_tap_hold_key.release();
  138.     run_one_scan_loop();
  139.     VERIFY_AND_CLEAR(driver);
  140. }
  142. TEST_F(DefaultTapHold, tap_mod_tap_hold_key_two_times) {
  143.     TestDriver driver;
  144.     InSequence s;
  145.     auto       mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P));
  147.     set_keymap({mod_tap_hold_key});
  149.     /* Press mod-tap-hold key. */
  150.     EXPECT_NO_REPORT(driver);
  151.     mod_tap_hold_key.press();
  152.     run_one_scan_loop();
  153.     VERIFY_AND_CLEAR(driver);
  155.     /* Release mod-tap-hold key. */
  156.     EXPECT_REPORT(driver, (KC_P));
  157.     EXPECT_EMPTY_REPORT(driver);
  158.     mod_tap_hold_key.release();
  159.     run_one_scan_loop();
  160.     VERIFY_AND_CLEAR(driver);
  162.     /* Press mod-tap-hold key again. */
  163.     EXPECT_REPORT(driver, (KC_P));
  164.     mod_tap_hold_key.press();
  165.     idle_for(TAPPING_TERM);
  166.     VERIFY_AND_CLEAR(driver);
  168.     /* Release mod-tap-hold key. */
  169.     EXPECT_EMPTY_REPORT(driver);
  170.     mod_tap_hold_key.release();
  171.     run_one_scan_loop();
  172.     VERIFY_AND_CLEAR(driver);
  173. }
  175. TEST_F(DefaultTapHold, tap_mod_tap_hold_key_twice_and_hold_on_second_time) {
  176.     TestDriver driver;
  177.     InSequence s;
  178.     auto       mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P));
  180.     set_keymap({mod_tap_hold_key});
  182.     /* Press mod-tap-hold key. */
  183.     EXPECT_NO_REPORT(driver);
  184.     mod_tap_hold_key.press();
  185.     run_one_scan_loop();
  186.     VERIFY_AND_CLEAR(driver);
  188.     /* Release mod-tap-hold key. */
  189.     EXPECT_REPORT(driver, (KC_P));
  190.     EXPECT_EMPTY_REPORT(driver);
  191.     mod_tap_hold_key.release();
  192.     run_one_scan_loop();
  193.     VERIFY_AND_CLEAR(driver);
  195.     /* Press mod-tap-hold key again. */
  196.     EXPECT_REPORT(driver, (KC_P));
  197.     mod_tap_hold_key.press();
  198.     idle_for(TAPPING_TERM);
  199.     VERIFY_AND_CLEAR(driver);
  201.     /* Release mod-tap-hold key. */
  202.     EXPECT_EMPTY_REPORT(driver);
  203.     mod_tap_hold_key.release();
  204.     run_one_scan_loop();
  205.     VERIFY_AND_CLEAR(driver);
  206. }
  208. TEST_F(DefaultTapHold, tap_and_hold_mod_tap_hold_key) {
  209.     TestDriver driver;
  210.     InSequence s;
  211.     auto       mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P));
  213.     set_keymap({mod_tap_hold_key});
  215.     /* Press mod-tap-hold key. */
  216.     EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
  217.     mod_tap_hold_key.press();
  218.     idle_for(TAPPING_TERM + 1);
  219.     VERIFY_AND_CLEAR(driver);
  221.     /* Release mod-tap-hold key. */
  222.     EXPECT_EMPTY_REPORT(driver);
  223.     mod_tap_hold_key.release();
  224.     run_one_scan_loop();
  225.     VERIFY_AND_CLEAR(driver);
  226. }