test_quick_tap.cpp (5695B)
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 "config.h" 18 #include "keyboard_report_util.hpp" 19 #include "keycode.h" 20 #include "test_common.hpp" 21 #include "action_tapping.h" 22 #include "test_fixture.hpp" 23 #include "test_keymap_key.hpp" 24 25 using testing::_; 26 using testing::InSequence; 27 28 class QuickTap : public TestFixture {}; 29 30 TEST_F(QuickTap, tap_regular_key_while_layer_tap_key_is_held) { 31 TestDriver driver; 32 InSequence s; 33 auto layer_tap_key = KeymapKey(0, 1, 0, LT(1, KC_P)); 34 auto regular_key = KeymapKey(0, 2, 0, KC_A); 35 auto layer_key = KeymapKey(1, 2, 0, KC_B); 36 37 set_keymap({layer_tap_key, regular_key, layer_key}); 38 39 /* Press layer-tap key */ 40 EXPECT_NO_REPORT(driver); 41 layer_tap_key.press(); 42 run_one_scan_loop(); 43 VERIFY_AND_CLEAR(driver); 44 45 /* Press regular key */ 46 EXPECT_NO_REPORT(driver); 47 regular_key.press(); 48 run_one_scan_loop(); 49 VERIFY_AND_CLEAR(driver); 50 51 /* Release regular key */ 52 EXPECT_NO_REPORT(driver); 53 regular_key.release(); 54 run_one_scan_loop(); 55 VERIFY_AND_CLEAR(driver); 56 57 /* Release layer-tap key */ 58 EXPECT_REPORT(driver, (KC_P)); 59 EXPECT_REPORT(driver, (KC_A, KC_P)); 60 EXPECT_REPORT(driver, (KC_P)); 61 EXPECT_EMPTY_REPORT(driver); 62 layer_tap_key.release(); 63 run_one_scan_loop(); 64 VERIFY_AND_CLEAR(driver); 65 } 66 67 TEST_F(QuickTap, tap_key_and_tap_again_before_quick_tap_term) { 68 TestDriver driver; 69 InSequence s; 70 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); 71 72 set_keymap({mod_tap_key}); 73 74 /* Press mod-tap key. */ 75 EXPECT_NO_REPORT(driver); 76 mod_tap_key.press(); 77 run_one_scan_loop(); 78 VERIFY_AND_CLEAR(driver); 79 80 /* Release mod-tap key. */ 81 EXPECT_REPORT(driver, (KC_P)); 82 EXPECT_EMPTY_REPORT(driver); 83 mod_tap_key.release(); 84 idle_for(QUICK_TAP_TERM - 10); 85 run_one_scan_loop(); 86 VERIFY_AND_CLEAR(driver); 87 88 /* Press and tap mod-tap key again. */ 89 EXPECT_REPORT(driver, (KC_P)); 90 mod_tap_key.press(); 91 run_one_scan_loop(); 92 VERIFY_AND_CLEAR(driver); 93 94 /* Release mod-tap key. */ 95 EXPECT_EMPTY_REPORT(driver); 96 mod_tap_key.release(); 97 run_one_scan_loop(); 98 VERIFY_AND_CLEAR(driver); 99 } 100 101 TEST_F(QuickTap, tap_key_and_hold_again_before_quick_tap_term) { 102 TestDriver driver; 103 InSequence s; 104 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); 105 106 set_keymap({mod_tap_key}); 107 108 /* Press mod-tap key. */ 109 EXPECT_NO_REPORT(driver); 110 mod_tap_key.press(); 111 run_one_scan_loop(); 112 VERIFY_AND_CLEAR(driver); 113 114 /* Release mod-tap key. */ 115 EXPECT_REPORT(driver, (KC_P)); 116 EXPECT_EMPTY_REPORT(driver); 117 mod_tap_key.release(); 118 idle_for(QUICK_TAP_TERM - 10); 119 VERIFY_AND_CLEAR(driver); 120 121 /* Press and hold mod-tap key again. */ 122 EXPECT_REPORT(driver, (KC_P)); 123 mod_tap_key.press(); 124 run_one_scan_loop(); 125 VERIFY_AND_CLEAR(driver); 126 127 /* Wait until tapping term expired */ 128 EXPECT_NO_REPORT(driver); 129 idle_for(TAPPING_TERM); 130 VERIFY_AND_CLEAR(driver); 131 132 /* Release mod-tap key. */ 133 EXPECT_EMPTY_REPORT(driver); 134 mod_tap_key.release(); 135 run_one_scan_loop(); 136 VERIFY_AND_CLEAR(driver); 137 } 138 139 TEST_F(QuickTap, tap_key_and_tap_again_after_quick_tap_term) { 140 TestDriver driver; 141 InSequence s; 142 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); 143 144 set_keymap({mod_tap_key}); 145 146 /* Press mod-tap key. */ 147 EXPECT_NO_REPORT(driver); 148 mod_tap_key.press(); 149 run_one_scan_loop(); 150 VERIFY_AND_CLEAR(driver); 151 152 /* Release mod-tap key. */ 153 EXPECT_REPORT(driver, (KC_P)); 154 EXPECT_EMPTY_REPORT(driver); 155 mod_tap_key.release(); 156 idle_for(QUICK_TAP_TERM + 10); 157 run_one_scan_loop(); 158 VERIFY_AND_CLEAR(driver); 159 160 /* Press mod-tap key again. */ 161 EXPECT_NO_REPORT(driver); 162 mod_tap_key.press(); 163 run_one_scan_loop(); 164 VERIFY_AND_CLEAR(driver); 165 166 /* Release mod-tap key. */ 167 EXPECT_REPORT(driver, (KC_P)); 168 EXPECT_EMPTY_REPORT(driver); 169 mod_tap_key.release(); 170 run_one_scan_loop(); 171 VERIFY_AND_CLEAR(driver); 172 } 173 174 TEST_F(QuickTap, tap_key_and_hold_again_after_quick_tap_term) { 175 TestDriver driver; 176 InSequence s; 177 auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); 178 179 set_keymap({mod_tap_key}); 180 181 /* Press mod-tap key. */ 182 EXPECT_NO_REPORT(driver); 183 mod_tap_key.press(); 184 run_one_scan_loop(); 185 VERIFY_AND_CLEAR(driver); 186 187 /* Release mod-tap key. */ 188 EXPECT_REPORT(driver, (KC_P)); 189 EXPECT_EMPTY_REPORT(driver); 190 mod_tap_key.release(); 191 idle_for(QUICK_TAP_TERM + 10); 192 VERIFY_AND_CLEAR(driver); 193 194 /* Press and hold mod-tap key again. */ 195 EXPECT_NO_REPORT(driver); 196 mod_tap_key.press(); 197 run_one_scan_loop(); 198 VERIFY_AND_CLEAR(driver); 199 200 /* Wait until tapping term expired */ 201 EXPECT_REPORT(driver, (KC_LSFT)); 202 idle_for(TAPPING_TERM); 203 VERIFY_AND_CLEAR(driver); 204 205 /* Release mod-tap key. */ 206 EXPECT_EMPTY_REPORT(driver); 207 mod_tap_key.release(); 208 run_one_scan_loop(); 209 VERIFY_AND_CLEAR(driver); 210 }