summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
authorJohn <Johnlrigoni@gmail.com>2025-02-16 03:50:42 -0600
committerGitHub <noreply@github.com>2025-02-16 20:50:42 +1100
commitb69bf4b885cd8d597c29f0af64a3faf2aafa54ce (patch)
tree311b18a488548551fe1003a9296972a4d0f1dafb /tests
parent3ab2b3b6e2ac85c8bc00b81911d73f060e616228 (diff)
Retro Tapping Re-Write; Key Roll Fix (#23641)
Diffstat (limited to 'tests')
-rw-r--r--tests/tap_hold_configurations/retro_tapping/test_key_roll.cpp408
1 files changed, 408 insertions, 0 deletions
diff --git a/tests/tap_hold_configurations/retro_tapping/test_key_roll.cpp b/tests/tap_hold_configurations/retro_tapping/test_key_roll.cpp
new file mode 100644
index 0000000000..afcbde9937
--- /dev/null
+++ b/tests/tap_hold_configurations/retro_tapping/test_key_roll.cpp
@@ -0,0 +1,408 @@
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 */
16
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"
23
24using testing::_;
25using testing::InSequence;
26
27class RetroTapKeyRoll : public TestFixture {};
28
29TEST_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);
34
35 set_keymap({mod_tap_hold_key, regular_key});
36
37 EXPECT_REPORT(driver, (KC_B));
38 regular_key.press();
39 run_one_scan_loop();
40 VERIFY_AND_CLEAR(driver);
41
42 EXPECT_NO_REPORT(driver);
43 mod_tap_hold_key.press();
44 idle_for(TAPPING_TERM);
45 VERIFY_AND_CLEAR(driver);
46
47 EXPECT_REPORT(driver, (KC_B, KC_LEFT_GUI));
48 run_one_scan_loop();
49 VERIFY_AND_CLEAR(driver);
50
51 EXPECT_REPORT(driver, (KC_LEFT_GUI));
52 regular_key.release();
53 run_one_scan_loop();
54 VERIFY_AND_CLEAR(driver);
55
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}
65
66TEST_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);
71
72 set_keymap({mod_tap_hold_key, regular_key});
73
74 EXPECT_REPORT(driver, (KC_B));
75 regular_key.press();
76 run_one_scan_loop();
77 VERIFY_AND_CLEAR(driver);
78
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);
84
85 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
86 regular_key.release();
87 run_one_scan_loop();
88 VERIFY_AND_CLEAR(driver);
89
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}
97
98TEST_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);
103
104 set_keymap({mod_tap_hold_key, regular_key});
105
106 EXPECT_REPORT(driver, (KC_B));
107 regular_key.press();
108 run_one_scan_loop();
109 VERIFY_AND_CLEAR(driver);
110
111 EXPECT_NO_REPORT(driver);
112 mod_tap_hold_key.press();
113 run_one_scan_loop();
114 VERIFY_AND_CLEAR(driver);
115
116 EXPECT_EMPTY_REPORT(driver);
117 regular_key.release();
118 run_one_scan_loop();
119 VERIFY_AND_CLEAR(driver);
120
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}
127
128TEST_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);
133
134 set_keymap({mod_tap_hold_key, regular_key});
135
136 EXPECT_NO_REPORT(driver);
137 mod_tap_hold_key.press();
138 run_one_scan_loop();
139 VERIFY_AND_CLEAR(driver);
140
141 EXPECT_NO_REPORT(driver);
142 regular_key.press();
143 run_one_scan_loop();
144 VERIFY_AND_CLEAR(driver);
145
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);
152
153 EXPECT_EMPTY_REPORT(driver);
154 regular_key.release();
155 run_one_scan_loop();
156 VERIFY_AND_CLEAR(driver);
157}
158
159TEST_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);
164
165 set_keymap({mod_tap_hold_key, regular_key});
166
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);
172
173 EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_B));
174 regular_key.press();
175 run_one_scan_loop();
176 VERIFY_AND_CLEAR(driver);
177
178 EXPECT_REPORT(driver, (KC_B));
179 mod_tap_hold_key.release();
180 run_one_scan_loop();
181 VERIFY_AND_CLEAR(driver);
182
183 EXPECT_EMPTY_REPORT(driver);
184 regular_key.release();
185 run_one_scan_loop();
186 VERIFY_AND_CLEAR(driver);
187}
188
189TEST_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));
194
195 set_keymap({mod_tap_hold_gui, mod_tap_hold_lshft});
196
197 EXPECT_NO_REPORT(driver);
198 mod_tap_hold_lshft.press();
199 run_one_scan_loop();
200 VERIFY_AND_CLEAR(driver);
201
202 EXPECT_NO_REPORT(driver);
203 mod_tap_hold_gui.press();
204 run_one_scan_loop();
205 VERIFY_AND_CLEAR(driver);
206
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);
212
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}
219
220TEST_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));
225
226 set_keymap({mod_tap_hold_gui, mod_tap_hold_lshft});
227
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);
233
234 EXPECT_NO_REPORT(driver);
235 mod_tap_hold_gui.press();
236 run_one_scan_loop();
237 VERIFY_AND_CLEAR(driver);
238
239 EXPECT_NO_REPORT(driver);
240 mod_tap_hold_lshft.release();
241 run_one_scan_loop();
242 VERIFY_AND_CLEAR(driver);
243
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}
251
252TEST_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));
257
258 set_keymap({mod_tap_hold_gui, mod_tap_hold_lshft});
259
260 EXPECT_NO_REPORT(driver);
261 mod_tap_hold_lshft.press();
262 run_one_scan_loop();
263 VERIFY_AND_CLEAR(driver);
264
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);
271
272 EXPECT_REPORT(driver, (KC_LEFT_GUI));
273 mod_tap_hold_lshft.release();
274 run_one_scan_loop();
275 VERIFY_AND_CLEAR(driver);
276
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}
288
289TEST_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));
294
295 set_keymap({mod_tap_hold_gui, mod_tap_hold_lshft});
296
297 EXPECT_NO_REPORT(driver);
298 mod_tap_hold_lshft.press();
299 run_one_scan_loop();
300 VERIFY_AND_CLEAR(driver);
301
302 EXPECT_NO_REPORT(driver);
303 mod_tap_hold_gui.press();
304 run_one_scan_loop();
305 VERIFY_AND_CLEAR(driver);
306
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);
312
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}
324
325TEST_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));
330
331 set_keymap({mod_tap_hold_gui, mod_tap_hold_lshft});
332
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);
338
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);
344
345 EXPECT_REPORT(driver, (KC_LEFT_GUI));
346 mod_tap_hold_lshft.release();
347 run_one_scan_loop();
348 VERIFY_AND_CLEAR(driver);
349
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}
361
362TEST_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));
368
369 set_keymap({mod_tap_hold_lalt, mod_tap_hold_lshft, mod_tap_hold_lctrl});
370
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);
376
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);
382
383 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
384 mod_tap_hold_lalt.release();
385 run_one_scan_loop();
386 VERIFY_AND_CLEAR(driver);
387
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);
394
395 EXPECT_REPORT(driver, (KC_LEFT_CTRL));
396 mod_tap_hold_lshft.release();
397 run_one_scan_loop();
398 VERIFY_AND_CLEAR(driver);
399
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}
generated by cgit v1.2.3 (git 2.25.1) at 2026-09-03 07:54:41 +0000