auri.ee
keyboard stuff
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 "action_util.h"
18#include "keyboard_report_util.hpp"
19#include "test_common.hpp"
20
21using testing::_;
22using testing::InSequence;
23
24class OneShot : public TestFixture {};
25class OneShotParametrizedTestFixture : public ::testing::WithParamInterface<std::pair<KeymapKey, KeymapKey>>, public OneShot {};
26
27TEST_F(OneShot, OSMWithoutAdditionalKeypressDoesNothing) {
28 TestDriver driver;
29 auto osm_key = KeymapKey(0, 0, 0, OSM(MOD_LSFT), KC_LSFT);
30
31 set_keymap({osm_key});
32
33 /* Press and release OSM key*/
34 EXPECT_NO_REPORT(driver);
35 tap_key(osm_key);
36 VERIFY_AND_CLEAR(driver);
37
38 /* OSM are added when an actual report is send */
39 EXPECT_REPORT(driver, (osm_key.report_code));
40 send_keyboard_report();
41 VERIFY_AND_CLEAR(driver);
42
43 /* Make unit-test pass */
44 clear_oneshot_mods();
45}
46
47#if defined(ONESHOT_TIMEOUT)
48
49TEST_P(OneShotParametrizedTestFixture, OSMExpiredDoesNothing) {
50 TestDriver driver;
51 KeymapKey osm_key = GetParam().first;
52 KeymapKey regular_key = GetParam().second;
53
54 set_keymap({osm_key, regular_key});
55
56 /* Press and release OSM */
57 EXPECT_NO_REPORT(driver);
58 osm_key.press();
59 run_one_scan_loop();
60 osm_key.release();
61 idle_for(ONESHOT_TIMEOUT);
62 VERIFY_AND_CLEAR(driver);
63
64 /* Press regular key */
65 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
66 regular_key.press();
67 run_one_scan_loop();
68 VERIFY_AND_CLEAR(driver);
69
70 /* Release regular key */
71 EXPECT_EMPTY_REPORT(driver);
72 regular_key.release();
73 run_one_scan_loop();
74 VERIFY_AND_CLEAR(driver);
75}
76
77#endif
78
79TEST_P(OneShotParametrizedTestFixture, OSMWithAdditionalKeypress) {
80 TestDriver driver;
81 KeymapKey osm_key = GetParam().first;
82 KeymapKey regular_key = GetParam().second;
83
84 set_keymap({osm_key, regular_key});
85
86 /* Press and release OSM */
87 EXPECT_NO_REPORT(driver);
88 tap_key(osm_key);
89 VERIFY_AND_CLEAR(driver);
90
91 /* Press regular key */
92 EXPECT_REPORT(driver, (osm_key.report_code, regular_key.report_code)).Times(1);
93 regular_key.press();
94 run_one_scan_loop();
95 VERIFY_AND_CLEAR(driver);
96
97 /* Release regular key */
98 EXPECT_EMPTY_REPORT(driver);
99 regular_key.release();
100 run_one_scan_loop();
101 VERIFY_AND_CLEAR(driver);
102}
103
104TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypress) {
105 TestDriver driver;
106 testing::InSequence s;
107
108 KeymapKey osm_key = GetParam().first;
109 KeymapKey regular_key = GetParam().second;
110
111 set_keymap({osm_key, regular_key});
112
113 /* Press OSM */
114 EXPECT_NO_REPORT(driver);
115 osm_key.press();
116 run_one_scan_loop();
117 VERIFY_AND_CLEAR(driver);
118
119 /* Press regular key */
120 EXPECT_NO_REPORT(driver);
121 regular_key.press();
122 run_one_scan_loop();
123 VERIFY_AND_CLEAR(driver);
124
125 /* Release regular key */
126 EXPECT_NO_REPORT(driver);
127 regular_key.release();
128 run_one_scan_loop();
129 VERIFY_AND_CLEAR(driver);
130
131 /* Release OSM */
132 EXPECT_REPORT(driver, (regular_key.report_code, osm_key.report_code)).Times(1);
133 EXPECT_EMPTY_REPORT(driver);
134 osm_key.release();
135 run_one_scan_loop();
136 VERIFY_AND_CLEAR(driver);
137}
138
139// clang-format off
140
141INSTANTIATE_TEST_CASE_P(
142 OneShotModifierTests,
143 OneShotParametrizedTestFixture,
144 ::testing::Values(
145 /* first is osm key, second is regular key. */
146 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_LSFT), KC_LSFT}, KeymapKey{0, 1, 1, KC_A}),
147 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_LCTL), KC_LCTL}, KeymapKey{0, 1, 1, KC_A}),
148 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_LALT), KC_LALT}, KeymapKey{0, 1, 1, KC_A}),
149 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_LGUI), KC_LGUI}, KeymapKey{0, 1, 1, KC_A}),
150 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_RCTL), KC_RCTL}, KeymapKey{0, 1, 1, KC_A}),
151 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_RSFT), KC_RSFT}, KeymapKey{0, 1, 1, KC_A}),
152 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_RALT), KC_RALT}, KeymapKey{0, 1, 1, KC_A}),
153 std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_RGUI), KC_RGUI}, KeymapKey{0, 1, 1, KC_A})
154 ));
155// clang-format on
156
157TEST_F(OneShot, OSMChainingTwoOSMs) {
158 TestDriver driver;
159 InSequence s;
160 KeymapKey osm_key1 = KeymapKey{0, 0, 0, OSM(MOD_LSFT), KC_LSFT};
161 KeymapKey osm_key2 = KeymapKey{0, 0, 1, OSM(MOD_LCTL), KC_LCTL};
162 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
163
164 set_keymap({osm_key1, osm_key2, regular_key});
165
166 /* Press and release OSM1 */
167 EXPECT_NO_REPORT(driver);
168 tap_key(osm_key1);
169 VERIFY_AND_CLEAR(driver);
170
171 /* Press and release OSM2 */
172 EXPECT_NO_REPORT(driver);
173 tap_key(osm_key2);
174 VERIFY_AND_CLEAR(driver);
175
176 /* Press regular key */
177 EXPECT_REPORT(driver, (osm_key1.report_code, osm_key2.report_code, regular_key.report_code)).Times(1);
178 regular_key.press();
179 run_one_scan_loop();
180 VERIFY_AND_CLEAR(driver);
181
182 /* Release regular key */
183 EXPECT_EMPTY_REPORT(driver);
184 regular_key.release();
185 run_one_scan_loop();
186 VERIFY_AND_CLEAR(driver);
187}
188
189TEST_F(OneShot, OSMDoubleTapNotLockingOSMs) {
190 TestDriver driver;
191 InSequence s;
192 KeymapKey osm_key1 = KeymapKey{0, 0, 0, OSM(MOD_LSFT), KC_LSFT};
193 KeymapKey osm_key2 = KeymapKey{0, 0, 1, OSM(MOD_LCTL), KC_LCTL};
194 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
195
196 set_keymap({osm_key1, osm_key2, regular_key});
197
198 /* Press and release OSM1 */
199 EXPECT_NO_REPORT(driver);
200 tap_key(osm_key1);
201 VERIFY_AND_CLEAR(driver);
202
203 /* Press and release OSM2 twice */
204 EXPECT_NO_REPORT(driver);
205 tap_key(osm_key2);
206 tap_key(osm_key2);
207 VERIFY_AND_CLEAR(driver);
208
209 /* Press regular key */
210 EXPECT_REPORT(driver, (osm_key1.report_code, osm_key2.report_code, regular_key.report_code)).Times(1);
211 regular_key.press();
212 run_one_scan_loop();
213 VERIFY_AND_CLEAR(driver);
214
215 /* Release regular key */
216 EXPECT_EMPTY_REPORT(driver);
217 regular_key.release();
218 run_one_scan_loop();
219 VERIFY_AND_CLEAR(driver);
220
221 /* Press regular key */
222 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
223 regular_key.press();
224 run_one_scan_loop();
225 VERIFY_AND_CLEAR(driver);
226
227 /* Release regular key */
228 EXPECT_EMPTY_REPORT(driver);
229 regular_key.release();
230 run_one_scan_loop();
231 VERIFY_AND_CLEAR(driver);
232}
233
234TEST_F(OneShot, OSMHoldNotLockingOSMs) {
235 TestDriver driver;
236 InSequence s;
237 KeymapKey osm_key1 = KeymapKey{0, 0, 0, OSM(MOD_LSFT), KC_LSFT};
238 KeymapKey osm_key2 = KeymapKey{0, 0, 1, OSM(MOD_LCTL), KC_LCTL};
239 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
240
241 set_keymap({osm_key1, osm_key2, regular_key});
242
243 /* Press and release OSM1 */
244 EXPECT_NO_REPORT(driver);
245 tap_key(osm_key1);
246 VERIFY_AND_CLEAR(driver);
247
248 /* Press and hold OSM2 */
249 EXPECT_REPORT(driver, (osm_key1.report_code, osm_key2.report_code)).Times(1);
250 osm_key2.press();
251 run_one_scan_loop();
252 idle_for(TAPPING_TERM);
253 VERIFY_AND_CLEAR(driver);
254
255 /* Press and release regular key */
256 EXPECT_REPORT(driver, (osm_key1.report_code, osm_key2.report_code, regular_key.report_code)).Times(1);
257 EXPECT_REPORT(driver, (osm_key2.report_code)).Times(1);
258 tap_key(regular_key);
259 VERIFY_AND_CLEAR(driver);
260
261 /* Release OSM2 */
262 EXPECT_EMPTY_REPORT(driver);
263 osm_key2.release();
264 run_one_scan_loop();
265 VERIFY_AND_CLEAR(driver);
266
267 /* Press regular key */
268 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
269 regular_key.press();
270 run_one_scan_loop();
271 VERIFY_AND_CLEAR(driver);
272
273 /* Release regular key */
274 EXPECT_EMPTY_REPORT(driver);
275 regular_key.release();
276 run_one_scan_loop();
277 VERIFY_AND_CLEAR(driver);
278}
279
280TEST_F(OneShot, OSLWithAdditionalKeypress) {
281 TestDriver driver;
282 InSequence s;
283 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)};
284 KeymapKey regular_key = KeymapKey{1, 1, 0, KC_A};
285
286 set_keymap({osl_key, regular_key});
287
288 /* Press OSL key */
289 EXPECT_NO_REPORT(driver);
290 osl_key.press();
291 run_one_scan_loop();
292 VERIFY_AND_CLEAR(driver);
293
294 /* Release OSL key */
295 EXPECT_NO_REPORT(driver);
296 osl_key.release();
297 run_one_scan_loop();
298 VERIFY_AND_CLEAR(driver);
299
300 /* Press regular key */
301 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
302 EXPECT_EMPTY_REPORT(driver);
303 regular_key.press();
304 run_one_scan_loop();
305 VERIFY_AND_CLEAR(driver);
306
307 /* Release regular key */
308 EXPECT_NO_REPORT(driver);
309 regular_key.release();
310 run_one_scan_loop();
311 VERIFY_AND_CLEAR(driver);
312}
313
314TEST_F(OneShot, OSLWithOsmAndAdditionalKeypress) {
315 TestDriver driver;
316 InSequence s;
317 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)};
318 KeymapKey osm_key = KeymapKey{1, 1, 0, OSM(MOD_LSFT), KC_LSFT};
319 KeymapKey regular_key = KeymapKey{1, 1, 1, KC_A};
320
321 set_keymap({osl_key, osm_key, regular_key});
322
323 /* Press OSL key */
324 EXPECT_NO_REPORT(driver);
325 osl_key.press();
326 run_one_scan_loop();
327 VERIFY_AND_CLEAR(driver);
328
329 /* Release OSL key */
330 EXPECT_NO_REPORT(driver);
331 osl_key.release();
332 run_one_scan_loop();
333 EXPECT_TRUE(layer_state_is(1));
334 VERIFY_AND_CLEAR(driver);
335
336 /* Press and release OSM */
337 EXPECT_NO_REPORT(driver);
338 tap_key(osm_key);
339 EXPECT_TRUE(layer_state_is(1));
340 VERIFY_AND_CLEAR(driver);
341
342 /* Press regular key */
343 EXPECT_REPORT(driver, (osm_key.report_code, regular_key.report_code)).Times(1);
344 EXPECT_EMPTY_REPORT(driver);
345 regular_key.press();
346 run_one_scan_loop();
347 EXPECT_FALSE(layer_state_is(1));
348 VERIFY_AND_CLEAR(driver);
349
350 /* Release regular key */
351 EXPECT_NO_REPORT(driver);
352 regular_key.release();
353 run_one_scan_loop();
354 VERIFY_AND_CLEAR(driver);
355}
356
357TEST_F(OneShot, OSLWithMoAndAdditionalKeypress) {
358 TestDriver driver;
359 InSequence s;
360 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)};
361 KeymapKey mo_key = KeymapKey{1, 1, 0, MO(2)};
362 KeymapKey regular_key = KeymapKey{2, 1, 1, KC_A};
363
364 set_keymap({osl_key, mo_key, regular_key});
365
366 /* Press OSL key */
367 EXPECT_NO_REPORT(driver);
368 osl_key.press();
369 run_one_scan_loop();
370 VERIFY_AND_CLEAR(driver);
371
372 /* Release OSL key */
373 EXPECT_NO_REPORT(driver);
374 osl_key.release();
375 run_one_scan_loop();
376 EXPECT_TRUE(layer_state_is(1));
377 VERIFY_AND_CLEAR(driver);
378
379 /* Press MO */
380 EXPECT_NO_REPORT(driver);
381 mo_key.press();
382 run_one_scan_loop();
383 EXPECT_TRUE(layer_state_is(2));
384 VERIFY_AND_CLEAR(driver);
385
386 /* Press regular key */
387 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
388 regular_key.press();
389 run_one_scan_loop();
390 EXPECT_TRUE(layer_state_is(2));
391 VERIFY_AND_CLEAR(driver);
392
393 /* Release regular key */
394 EXPECT_EMPTY_REPORT(driver);
395 regular_key.release();
396 run_one_scan_loop();
397 VERIFY_AND_CLEAR(driver);
398
399 /* Release MO */
400 EXPECT_NO_REPORT(driver);
401 mo_key.release();
402 run_one_scan_loop();
403 EXPECT_TRUE(layer_state_is(0));
404 VERIFY_AND_CLEAR(driver);
405}
406
407class OneShotLayerParametrizedTestFixture : public ::testing::WithParamInterface<uint16_t>, public OneShot {};
408
409TEST_P(OneShotLayerParametrizedTestFixture, OSLWithActionAndAdditionalKeypress) {
410 TestDriver driver;
411 InSequence s;
412 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)};
413 KeymapKey action_key = KeymapKey{1, 1, 0, GetParam()};
414 KeymapKey regular_key = KeymapKey{2, 1, 1, KC_A};
415
416 set_keymap({osl_key, action_key, regular_key});
417
418 /* Tap OSL key */
419 EXPECT_NO_REPORT(driver);
420 tap_key(osl_key);
421 run_one_scan_loop();
422 VERIFY_AND_CLEAR(driver);
423
424 /* Tag Action key */
425 EXPECT_NO_REPORT(driver);
426 tap_key(action_key);
427 run_one_scan_loop();
428 EXPECT_TRUE(layer_state_is(2));
429 VERIFY_AND_CLEAR(driver);
430
431 /* Press regular key */
432 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
433 regular_key.press();
434 run_one_scan_loop();
435 EXPECT_TRUE(layer_state_is(2));
436 VERIFY_AND_CLEAR(driver);
437
438 /* Release regular key */
439 EXPECT_EMPTY_REPORT(driver);
440 regular_key.release();
441 run_one_scan_loop();
442 VERIFY_AND_CLEAR(driver);
443}
444
445INSTANTIATE_TEST_CASE_P(OneShotLayerTests, OneShotLayerParametrizedTestFixture, ::testing::Values(TG(2), TO(2)));
446
447TEST_F(OneShot, OSLWithDFAndAdditionalKeypress) {
448 TestDriver driver;
449 InSequence s;
450 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)};
451 KeymapKey df_key = KeymapKey{1, 1, 0, DF(2)};
452 KeymapKey regular_key = KeymapKey{2, 1, 1, KC_A};
453
454 set_keymap({osl_key, df_key, regular_key});
455
456 layer_state_t default_layer_state_bak = default_layer_state;
457
458 /* Tap OSL key */
459 EXPECT_NO_REPORT(driver);
460 tap_key(osl_key);
461 run_one_scan_loop();
462 EXPECT_TRUE(layer_state_is(1));
463 VERIFY_AND_CLEAR(driver);
464
465 /* Press DF key */
466 EXPECT_NO_REPORT(driver);
467 df_key.press();
468 run_one_scan_loop();
469 EXPECT_EQ(default_layer_state, 0b001);
470
471 VERIFY_AND_CLEAR(driver);
472
473 /* Release DF key */
474 EXPECT_NO_REPORT(driver);
475 df_key.release();
476 run_one_scan_loop();
477 EXPECT_EQ(default_layer_state, 0b100);
478 VERIFY_AND_CLEAR(driver);
479
480 /* Press regular key */
481 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
482 regular_key.press();
483 run_one_scan_loop();
484 VERIFY_AND_CLEAR(driver);
485
486 /* Release regular key */
487 EXPECT_EMPTY_REPORT(driver);
488 regular_key.release();
489 run_one_scan_loop();
490 VERIFY_AND_CLEAR(driver);
491
492 default_layer_state = default_layer_state_bak;
493}
494
495TEST_F(OneShot, OSLChainingTwoOSLsAndAdditionalKeypress) {
496 TestDriver driver;
497 InSequence s;
498 KeymapKey osl1_key = KeymapKey{0, 0, 0, OSL(1)};
499 KeymapKey osl2_key = KeymapKey{1, 1, 0, OSL(2)};
500 KeymapKey regular_key = KeymapKey{2, 1, 1, KC_A};
501
502 set_keymap({osl1_key, osl2_key, regular_key});
503
504 /* Press and release first OSL key */
505 EXPECT_NO_REPORT(driver);
506 osl1_key.press();
507 run_one_scan_loop();
508 osl1_key.release();
509 run_one_scan_loop();
510 EXPECT_TRUE(layer_state_is(1));
511 VERIFY_AND_CLEAR(driver);
512
513 /* Press and release second OSL */
514 EXPECT_NO_REPORT(driver);
515 osl2_key.press();
516 run_one_scan_loop();
517 osl2_key.release();
518 run_one_scan_loop();
519 EXPECT_TRUE(layer_state_is(2));
520 VERIFY_AND_CLEAR(driver);
521
522 /* Press regular key */
523 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
524 EXPECT_EMPTY_REPORT(driver);
525 regular_key.press();
526 run_one_scan_loop();
527 VERIFY_AND_CLEAR(driver);
528
529 /* Release regular key */
530 EXPECT_NO_REPORT(driver);
531 regular_key.release();
532 run_one_scan_loop();
533 EXPECT_TRUE(layer_state_is(0));
534 VERIFY_AND_CLEAR(driver);
535}
536
537TEST_F(OneShot, OSLWithShortLT) {
538 TestDriver driver;
539 InSequence s;
540 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)};
541 KeymapKey lt_key = KeymapKey(1, 1, 0, LT(2, KC_A));
542
543 set_keymap({osl_key, lt_key});
544
545 /* Tap OSL key */
546 EXPECT_NO_REPORT(driver);
547 tap_key(osl_key);
548 run_one_scan_loop();
549 EXPECT_TRUE(layer_state_is(1));
550 VERIFY_AND_CLEAR(driver);
551
552 /* Tap LT key. */
553 EXPECT_REPORT(driver, (lt_key.report_code)).Times(1);
554 EXPECT_EMPTY_REPORT(driver);
555 tap_key(lt_key);
556 run_one_scan_loop();
557 EXPECT_TRUE(layer_state_is(0));
558 VERIFY_AND_CLEAR(driver);
559}
560
561TEST_F(OneShot, OSLWithLongLTAndRegularKey) {
562 TestDriver driver;
563 InSequence s;
564 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)};
565 KeymapKey lt_key = KeymapKey(1, 1, 0, LT(2, KC_A));
566 KeymapKey regular_key = KeymapKey(2, 1, 1, KC_B);
567
568 set_keymap({osl_key, lt_key, regular_key});
569
570 /* Tap OSL key */
571 EXPECT_NO_REPORT(driver);
572 tap_key(osl_key);
573 run_one_scan_loop();
574 EXPECT_TRUE(layer_state_is(1));
575 VERIFY_AND_CLEAR(driver);
576
577 /* Press LT key. */
578 EXPECT_NO_REPORT(driver);
579 lt_key.press();
580 run_one_scan_loop();
581 VERIFY_AND_CLEAR(driver);
582
583 /* Idle for tapping term of mod tap hold key. */
584 EXPECT_NO_REPORT(driver);
585 idle_for(TAPPING_TERM + 1);
586 VERIFY_AND_CLEAR(driver);
587 EXPECT_TRUE(layer_state_is(2));
588
589 /* Press regular key. */
590 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
591 regular_key.press();
592 run_one_scan_loop();
593 VERIFY_AND_CLEAR(driver);
594
595 /* Release regular key. */
596 EXPECT_EMPTY_REPORT(driver);
597 regular_key.release();
598 run_one_scan_loop();
599 VERIFY_AND_CLEAR(driver);
600}
601
602TEST_F(OneShot, OSLWithShortModTapKeyAndRegularKey) {
603 TestDriver driver;
604 InSequence s;
605 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)};
606 KeymapKey mod_tap_hold_key = KeymapKey(1, 1, 0, SFT_T(KC_P));
607 KeymapKey regular_key = KeymapKey(0, 2, 0, KC_A);
608
609 set_keymap({osl_key, mod_tap_hold_key, regular_key});
610
611 /* Tap OSL key */
612 EXPECT_NO_REPORT(driver);
613 tap_key(osl_key);
614 run_one_scan_loop();
615 EXPECT_TRUE(layer_state_is(1));
616 VERIFY_AND_CLEAR(driver);
617
618 /* Press mod-tap-hold key. */
619 EXPECT_NO_REPORT(driver);
620 mod_tap_hold_key.press();
621 run_one_scan_loop();
622 VERIFY_AND_CLEAR(driver);
623
624 /* Release mod-tap-hold key. */
625 EXPECT_REPORT(driver, (KC_P));
626 EXPECT_EMPTY_REPORT(driver);
627 mod_tap_hold_key.release();
628 run_one_scan_loop();
629 VERIFY_AND_CLEAR(driver);
630
631 /* Press regular key. */
632 EXPECT_REPORT(driver, (regular_key.report_code));
633 regular_key.press();
634 run_one_scan_loop();
635 VERIFY_AND_CLEAR(driver);
636
637 /* Release regular key. */
638 EXPECT_EMPTY_REPORT(driver);
639 regular_key.release();
640 run_one_scan_loop();
641 VERIFY_AND_CLEAR(driver);
642}
643
644TEST_F(OneShot, OSLWithLongModTapKeyAndRegularKey) {
645 TestDriver driver;
646 InSequence s;
647 KeymapKey osl_key = KeymapKey{0, 0, 0, OSL(1)};
648 KeymapKey mod_tap_hold_key = KeymapKey(1, 1, 0, SFT_T(KC_P));
649 KeymapKey regular_key = KeymapKey(1, 2, 0, KC_A);
650
651 set_keymap({osl_key, mod_tap_hold_key, regular_key});
652
653 /* Tap OSL key */
654 EXPECT_NO_REPORT(driver);
655 tap_key(osl_key);
656 run_one_scan_loop();
657 EXPECT_TRUE(layer_state_is(1));
658 VERIFY_AND_CLEAR(driver);
659
660 /* Press mod-tap-hold key. */
661 EXPECT_NO_REPORT(driver);
662 mod_tap_hold_key.press();
663 run_one_scan_loop();
664 VERIFY_AND_CLEAR(driver);
665
666 /* Idle for tapping term of mod tap hold key. */
667 EXPECT_REPORT(driver, (KC_LSFT));
668 idle_for(TAPPING_TERM + 1);
669 VERIFY_AND_CLEAR(driver);
670
671 /* Release mod-tap-hold key. */
672 EXPECT_EMPTY_REPORT(driver);
673 mod_tap_hold_key.release();
674 run_one_scan_loop();
675 VERIFY_AND_CLEAR(driver);
676
677 /* Press regular key. */
678 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
679 EXPECT_EMPTY_REPORT(driver);
680 regular_key.press();
681 run_one_scan_loop();
682 VERIFY_AND_CLEAR(driver);
683
684 /* Release regular key. */
685 EXPECT_NO_REPORT(driver);
686 regular_key.release();
687 run_one_scan_loop();
688 VERIFY_AND_CLEAR(driver);
689}