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