test_action_layer.cpp
12809 bytes
1/* Copyright 2017 Colin T.A. Gray
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 "gtest/gtest.h"
18#include "keyboard_report_util.hpp"
19#include "test_common.hpp"
20
21using testing::_;
22using testing::AnyNumber;
23using testing::InSequence;
24
25class ActionLayer : public TestFixture {};
26
27TEST_F(ActionLayer, LayerStateDBG) {
28 TestDriver driver;
29
30 layer_state_set(0);
31
32 VERIFY_AND_CLEAR(driver);
33}
34
35TEST_F(ActionLayer, LayerStateSet) {
36 TestDriver driver;
37
38 layer_state_set(0);
39 EXPECT_EQ(layer_state, 0);
40 layer_state_set(0b001100);
41 EXPECT_EQ(layer_state, 0b001100);
42
43 VERIFY_AND_CLEAR(driver);
44}
45
46TEST_F(ActionLayer, LayerStateIs) {
47 TestDriver driver;
48
49 layer_state_set(0);
50 EXPECT_EQ(layer_state_is(0), true);
51 EXPECT_EQ(layer_state_is(1), false);
52 layer_state_set(1);
53 EXPECT_EQ(layer_state_is(0), true);
54 EXPECT_EQ(layer_state_is(1), false);
55 layer_state_set(2);
56 EXPECT_EQ(layer_state_is(0), false);
57 EXPECT_EQ(layer_state_is(1), true);
58 EXPECT_EQ(layer_state_is(2), false);
59
60 VERIFY_AND_CLEAR(driver);
61}
62
63TEST_F(ActionLayer, LayerStateCmp) {
64 TestDriver driver;
65 uint32_t prev_layer;
66
67 prev_layer = 0;
68 EXPECT_EQ(layer_state_cmp(prev_layer, 0), true);
69 EXPECT_EQ(layer_state_cmp(prev_layer, 1), false);
70
71 prev_layer = 1;
72 EXPECT_EQ(layer_state_cmp(prev_layer, 0), true);
73 EXPECT_EQ(layer_state_cmp(prev_layer, 1), false);
74
75 prev_layer = 2;
76 EXPECT_EQ(layer_state_cmp(prev_layer, 0), false);
77 EXPECT_EQ(layer_state_cmp(prev_layer, 1), true);
78 EXPECT_EQ(layer_state_cmp(prev_layer, 2), false);
79
80 VERIFY_AND_CLEAR(driver);
81}
82
83TEST_F(ActionLayer, LayerClear) {
84 TestDriver driver;
85
86 layer_clear();
87 EXPECT_EQ(layer_state, 0);
88
89 VERIFY_AND_CLEAR(driver);
90}
91
92TEST_F(ActionLayer, LayerMove) {
93 TestDriver driver;
94
95 layer_move(0);
96 EXPECT_EQ(layer_state, 1);
97 layer_move(3);
98 EXPECT_EQ(layer_state, 0b1000);
99
100 VERIFY_AND_CLEAR(driver);
101}
102
103TEST_F(ActionLayer, LayerOn) {
104 TestDriver driver;
105
106 layer_clear();
107 layer_on(1);
108 layer_on(3);
109 layer_on(3);
110 EXPECT_EQ(layer_state, 0b1010);
111
112 VERIFY_AND_CLEAR(driver);
113}
114
115TEST_F(ActionLayer, LayerOff) {
116 TestDriver driver;
117
118 layer_clear();
119 layer_on(1);
120 layer_on(3);
121 layer_off(3);
122 layer_off(2);
123 EXPECT_EQ(layer_state, 0b0010);
124
125 VERIFY_AND_CLEAR(driver);
126}
127
128TEST_F(ActionLayer, MomentaryLayerDoesNothing) {
129 TestDriver driver;
130 KeymapKey layer_key = KeymapKey{0, 0, 0, MO(1)};
131
132 set_keymap({layer_key});
133
134 /* Press and release MO, nothing should happen. */
135 EXPECT_NO_REPORT(driver);
136 layer_key.press();
137 run_one_scan_loop();
138 VERIFY_AND_CLEAR(driver);
139
140 EXPECT_NO_REPORT(driver);
141 layer_key.release();
142 run_one_scan_loop();
143 VERIFY_AND_CLEAR(driver);
144}
145
146TEST_F(ActionLayer, MomentaryLayerWithKeypress) {
147 TestDriver driver;
148 KeymapKey layer_key = KeymapKey{0, 0, 0, MO(1)};
149
150 /* These keys must have the same position in the matrix, only the layer is different. */
151 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
152 set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
153
154 /* Press MO. */
155 EXPECT_NO_REPORT(driver);
156 layer_key.press();
157 run_one_scan_loop();
158 EXPECT_TRUE(layer_state_is(1));
159 VERIFY_AND_CLEAR(driver);
160
161 /* Press key on layer 1 */
162 EXPECT_REPORT(driver, (KC_B)).Times(1);
163 regular_key.press();
164 run_one_scan_loop();
165 EXPECT_TRUE(layer_state_is(1));
166 VERIFY_AND_CLEAR(driver);
167
168 /* Release key on layer 1 */
169 EXPECT_EMPTY_REPORT(driver);
170 regular_key.release();
171 run_one_scan_loop();
172 EXPECT_TRUE(layer_state_is(1));
173 VERIFY_AND_CLEAR(driver);
174
175 /* Release MO */
176 EXPECT_NO_REPORT(driver);
177 layer_key.release();
178 run_one_scan_loop();
179 EXPECT_TRUE(layer_state_is(0));
180 VERIFY_AND_CLEAR(driver);
181}
182
183TEST_F(ActionLayer, ToggleLayerDoesNothing) {
184 GTEST_SKIP() << "TODO: Toggle layer does not activate the expected layer on key press but on release.";
185
186 TestDriver driver;
187 KeymapKey layer_key = KeymapKey{0, 0, 0, TG(1)};
188
189 set_keymap({layer_key});
190
191 /* Press TG. Layer state should not change as it's applied on release. */
192 EXPECT_NO_REPORT(driver);
193 layer_key.press();
194 run_one_scan_loop();
195 EXPECT_TRUE(layer_state_is(1));
196 VERIFY_AND_CLEAR(driver);
197
198 /* Release TG. */
199 EXPECT_NO_REPORT(driver);
200 layer_key.release();
201 run_one_scan_loop();
202 EXPECT_TRUE(layer_state_is(1));
203 VERIFY_AND_CLEAR(driver);
204}
205
206TEST_F(ActionLayer, ToggleLayerUpAndDown) {
207 GTEST_SKIP() << "TODO: Toggle layer does not activate the expected layer on key press but on release.";
208
209 TestDriver driver;
210 KeymapKey toggle_layer_1_on_layer_0 = KeymapKey{0, 0, 0, TG(1)};
211 KeymapKey toggle_layer_0_on_layer_1 = KeymapKey{1, 1, 0, TG(0)};
212
213 set_keymap({toggle_layer_1_on_layer_0, toggle_layer_0_on_layer_1});
214
215 /* Toggle Layer 1. */
216 EXPECT_NO_REPORT(driver);
217 toggle_layer_1_on_layer_0.press();
218 run_one_scan_loop();
219 EXPECT_TRUE(layer_state_is(1));
220 VERIFY_AND_CLEAR(driver);
221
222 EXPECT_NO_REPORT(driver);
223 toggle_layer_1_on_layer_0.release();
224 run_one_scan_loop();
225 EXPECT_TRUE(layer_state_is(1));
226 VERIFY_AND_CLEAR(driver);
227
228 /* Toggle Layer 0. */
229 EXPECT_NO_REPORT(driver);
230 toggle_layer_0_on_layer_1.press();
231 run_one_scan_loop();
232 EXPECT_TRUE(layer_state_is(0));
233 VERIFY_AND_CLEAR(driver);
234
235 EXPECT_NO_REPORT(driver);
236 toggle_layer_0_on_layer_1.release();
237 run_one_scan_loop();
238 EXPECT_TRUE(layer_state_is(0));
239 VERIFY_AND_CLEAR(driver);
240}
241
242TEST_F(ActionLayer, LayerTapToggleDoesNothing) {
243 GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
244
245 TestDriver driver;
246 KeymapKey layer_key = KeymapKey{0, 0, 0, TT(1)};
247
248 set_keymap({layer_key});
249
250 /* Press and release TT. */
251 EXPECT_NO_REPORT(driver);
252 layer_key.press();
253 run_one_scan_loop();
254 EXPECT_TRUE(layer_state_is(1));
255 VERIFY_AND_CLEAR(driver);
256
257 EXPECT_NO_REPORT(driver);
258 layer_key.release();
259 run_one_scan_loop();
260 EXPECT_TRUE(layer_state_is(0));
261 VERIFY_AND_CLEAR(driver);
262}
263
264TEST_F(ActionLayer, LayerTapToggleWithKeypress) {
265 GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
266
267 TestDriver driver;
268 KeymapKey layer_key = KeymapKey{0, 0, 0, TT(1)};
269
270 /* These keys must have the same position in the matrix, only the layer is different. */
271 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
272 set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
273
274 /* Press TT. */
275 EXPECT_NO_REPORT(driver);
276 layer_key.press();
277 run_one_scan_loop();
278 EXPECT_TRUE(layer_state_is(1));
279 VERIFY_AND_CLEAR(driver);
280
281 EXPECT_REPORT(driver, (KC_B)).Times(1);
282 regular_key.press();
283 run_one_scan_loop();
284 EXPECT_TRUE(layer_state_is(1));
285 VERIFY_AND_CLEAR(driver);
286
287 EXPECT_EMPTY_REPORT(driver);
288 regular_key.release();
289 run_one_scan_loop();
290 EXPECT_TRUE(layer_state_is(1));
291 VERIFY_AND_CLEAR(driver);
292
293 EXPECT_NO_REPORT(driver);
294 layer_key.release();
295 run_one_scan_loop();
296 EXPECT_TRUE(layer_state_is(0));
297 VERIFY_AND_CLEAR(driver);
298}
299
300TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) {
301 GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
302
303 TestDriver driver;
304 KeymapKey layer_key = KeymapKey{0, 0, 0, TT(1)};
305
306 /* These keys must have the same position in the matrix, only the layer is different. */
307 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
308 set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
309
310 /* Tap TT five times . */
311 EXPECT_NO_REPORT(driver);
312
313 layer_key.press();
314 run_one_scan_loop();
315 EXPECT_TRUE(layer_state_is(1));
316 layer_key.release();
317 run_one_scan_loop();
318 EXPECT_TRUE(layer_state_is(0));
319
320 layer_key.press();
321 run_one_scan_loop();
322 EXPECT_TRUE(layer_state_is(1));
323 layer_key.release();
324 run_one_scan_loop();
325 EXPECT_TRUE(layer_state_is(0));
326
327 layer_key.press();
328 run_one_scan_loop();
329 EXPECT_TRUE(layer_state_is(1));
330 layer_key.release();
331 run_one_scan_loop();
332 EXPECT_TRUE(layer_state_is(0));
333
334 layer_key.press();
335 run_one_scan_loop();
336 EXPECT_TRUE(layer_state_is(1));
337 layer_key.release();
338 run_one_scan_loop();
339 EXPECT_TRUE(layer_state_is(0));
340
341 layer_key.press();
342 run_one_scan_loop();
343 EXPECT_TRUE(layer_state_is(1));
344 layer_key.release();
345 run_one_scan_loop();
346 EXPECT_TRUE(layer_state_is(1));
347
348 VERIFY_AND_CLEAR(driver);
349
350 EXPECT_REPORT(driver, (KC_B)).Times(1);
351 regular_key.press();
352 run_one_scan_loop();
353 EXPECT_TRUE(layer_state_is(1));
354 VERIFY_AND_CLEAR(driver);
355
356 EXPECT_EMPTY_REPORT(driver);
357 regular_key.release();
358 run_one_scan_loop();
359 EXPECT_TRUE(layer_state_is(1));
360 VERIFY_AND_CLEAR(driver);
361}
362
363TEST_F(ActionLayer, LayerTapReleasedBeforeKeypressReleaseWithModifiers) {
364 TestDriver driver;
365 InSequence s;
366
367 KeymapKey layer_0_key_0 = KeymapKey{0, 0, 0, LT(1, KC_T)};
368 KeymapKey layer_0_key_1 = KeymapKey{0, 1, 0, KC_X};
369 KeymapKey layer_1_key_1 = KeymapKey{1, 1, 0, RALT(KC_9)};
370
371 set_keymap({layer_0_key_0, layer_0_key_1, layer_1_key_1});
372
373 /* Press layer tap and wait for tapping term to switch to layer 1 */
374 EXPECT_NO_REPORT(driver);
375 layer_0_key_0.press();
376 idle_for(TAPPING_TERM);
377 EXPECT_TRUE(layer_state_is(0));
378 VERIFY_AND_CLEAR(driver);
379
380 /* Press key with layer 1 mapping, result basically expected
381 * altough more reports are send then necessary. */
382 EXPECT_REPORT(driver, (KC_RALT)).Times(1);
383 EXPECT_REPORT(driver, (KC_RALT, KC_9)).Times(1);
384 layer_1_key_1.press();
385 run_one_scan_loop();
386 EXPECT_TRUE(layer_state_is(1));
387 VERIFY_AND_CLEAR(driver);
388
389 /* Release layer tap key, no report is send because key is still held. */
390 EXPECT_NO_REPORT(driver);
391 layer_0_key_0.release();
392 run_one_scan_loop();
393 EXPECT_TRUE(layer_state_is(0));
394 VERIFY_AND_CLEAR(driver);
395
396 /* Unregister keycode and modifier. */
397 EXPECT_REPORT(driver, (KC_RALT)).Times(1);
398 EXPECT_EMPTY_REPORT(driver);
399 layer_1_key_1.release();
400 run_one_scan_loop();
401 EXPECT_TRUE(layer_state_is(0));
402 VERIFY_AND_CLEAR(driver);
403}
404
405TEST_F(ActionLayer, LayerModWithKeypress) {
406 TestDriver driver;
407 KeymapKey layer_key = KeymapKey{0, 0, 0, LM(1, MOD_RALT)};
408 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
409 set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
410
411 // Allow any number of reports with no keys or only KC_RALT.
412 // clang-format off
413 EXPECT_CALL(driver, send_keyboard_mock(AnyOf(
414 KeyboardReport(),
415 KeyboardReport(KC_RALT))))
416 .Times(AnyNumber());
417 // clang-format on
418 EXPECT_REPORT(driver, (KC_RALT, KC_B)).Times(1);
419
420 layer_key.press();
421 run_one_scan_loop();
422 EXPECT_TRUE(layer_state_is(1));
423 EXPECT_EQ(get_mods(), MOD_BIT(KC_RALT));
424
425 tap_key(regular_key);
426
427 layer_key.release();
428 run_one_scan_loop();
429 EXPECT_TRUE(layer_state_is(0));
430 EXPECT_EQ(get_mods(), 0);
431
432 VERIFY_AND_CLEAR(driver);
433}
434
435TEST_F(ActionLayer, LayerModHonorsModConfig) {
436 TestDriver driver;
437 KeymapKey layer_key = KeymapKey{0, 0, 0, LM(1, MOD_RALT)};
438 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
439 set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
440
441 // Allow any number of reports with no keys or only KC_RALT.
442 // clang-format off
443 EXPECT_CALL(driver, send_keyboard_mock(AnyOf(
444 KeyboardReport(),
445 KeyboardReport(KC_RGUI))))
446 .Times(AnyNumber());
447 // clang-format on
448 EXPECT_REPORT(driver, (KC_RGUI, KC_B)).Times(1);
449
450 keymap_config.swap_ralt_rgui = true;
451
452 layer_key.press();
453 run_one_scan_loop();
454 EXPECT_TRUE(layer_state_is(1));
455 EXPECT_EQ(get_mods(), MOD_BIT(KC_RGUI));
456
457 tap_key(regular_key);
458
459 layer_key.release();
460 run_one_scan_loop();
461 EXPECT_TRUE(layer_state_is(0));
462 EXPECT_EQ(get_mods(), 0);
463
464 VERIFY_AND_CLEAR(driver);
465}