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 */ 16 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" 23 24 using testing::_; 25 using testing::InSequence; 26 27 class DefaultTapHold : public TestFixture {}; 28 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); 34 35 set_keymap({mod_tap_hold_key, regular_key}); 36 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); 42 43 /* Press regular key. */ 44 EXPECT_NO_REPORT(driver); 45 regular_key.press(); 46 run_one_scan_loop(); 47 VERIFY_AND_CLEAR(driver); 48 49 /* Release regular key. */ 50 EXPECT_NO_REPORT(driver); 51 regular_key.release(); 52 run_one_scan_loop(); 53 VERIFY_AND_CLEAR(driver); 54 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); 63 64 /* Idle for tapping term of mod tap hold key. */ 65 idle_for(TAPPING_TERM - 3); 66 VERIFY_AND_CLEAR(driver); 67 } 68 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)); 74 75 set_keymap({first_mod_tap_hold_key, second_mod_tap_hold_key}); 76 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); 82 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); 88 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); 94 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 } 104 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); 111 112 set_keymap({layer_tap_hold_key, regular_key, layer_key}); 113 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); 119 120 /* Press regular key */ 121 EXPECT_NO_REPORT(driver); 122 regular_key.press(); 123 run_one_scan_loop(); 124 VERIFY_AND_CLEAR(driver); 125 126 /* Release regular key */ 127 EXPECT_NO_REPORT(driver); 128 regular_key.release(); 129 run_one_scan_loop(); 130 VERIFY_AND_CLEAR(driver); 131 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 } 141 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)); 146 147 set_keymap({mod_tap_hold_key}); 148 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); 154 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); 161 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); 167 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 } 174 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)); 179 180 set_keymap({mod_tap_hold_key}); 181 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); 187 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); 194 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); 200 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 } 207 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)); 212 213 set_keymap({mod_tap_hold_key}); 214 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); 220 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 }