aboutsummaryrefslogtreecommitdiff
path: root/tests/basic/test_action_layer.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/basic/test_action_layer.cpp')
-rw-r--r--tests/basic/test_action_layer.cpp427
1 files changed, 53 insertions, 374 deletions
diff --git a/tests/basic/test_action_layer.cpp b/tests/basic/test_action_layer.cpp
index 1b12d1364..d00a0859b 100644
--- a/tests/basic/test_action_layer.cpp
+++ b/tests/basic/test_action_layer.cpp
@@ -14,54 +14,39 @@
14 * along with this program. If not, see <http://www.gnu.org/licenses/>. 14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15 */ 15 */
16 16
17#include "gtest/gtest.h"
18#include "keyboard_report_util.hpp"
19#include "test_common.hpp" 17#include "test_common.hpp"
20 18
21using testing::_; 19using testing::_;
22using testing::InSequence; 20using testing::Return;
23 21
24class ActionLayer : public TestFixture {}; 22class ActionLayer : public TestFixture {};
25 23
26TEST_F(ActionLayer, LayerStateDBG) { 24// TEST_F(ActionLayer, LayerStateDBG) {
27 TestDriver driver; 25// layer_state_set(0);
28 26// }
29 layer_state_set(0); 27
30 28// TEST_F(ActionLayer, LayerStateSet) {
31 testing::Mock::VerifyAndClearExpectations(&driver); 29// layer_state_set(0);
32} 30// EXPECT_EQ(layer_state, 0);
33 31// layer_state_set(0b001100);
34TEST_F(ActionLayer, LayerStateSet) { 32// EXPECT_EQ(layer_state, 0b001100);
35 TestDriver driver; 33// }
36 34
37 layer_state_set(0); 35// TEST_F(ActionLayer, LayerStateIs) {
38 EXPECT_EQ(layer_state, 0); 36// layer_state_set(0);
39 layer_state_set(0b001100); 37// EXPECT_EQ(layer_state_is(0), true);
40 EXPECT_EQ(layer_state, 0b001100); 38// EXPECT_EQ(layer_state_is(1), true);
41 39// layer_state_set(1);
42 testing::Mock::VerifyAndClearExpectations(&driver); 40// EXPECT_EQ(layer_state_is(0), true);
43} 41// EXPECT_EQ(layer_state_is(1), true);
44 42// layer_state_set(2);
45TEST_F(ActionLayer, LayerStateIs) { 43// EXPECT_EQ(layer_state_is(0), false);
46 TestDriver driver; 44// EXPECT_EQ(layer_state_is(1), false);
47 45// EXPECT_EQ(layer_state_is(2), true);
48 layer_state_set(0); 46// }
49 EXPECT_EQ(layer_state_is(0), true);
50 EXPECT_EQ(layer_state_is(1), false);
51 layer_state_set(1);
52 EXPECT_EQ(layer_state_is(0), true);
53 EXPECT_EQ(layer_state_is(1), false);
54 layer_state_set(2);
55 EXPECT_EQ(layer_state_is(0), false);
56 EXPECT_EQ(layer_state_is(1), true);
57 EXPECT_EQ(layer_state_is(2), false);
58
59 testing::Mock::VerifyAndClearExpectations(&driver);
60}
61 47
62TEST_F(ActionLayer, LayerStateCmp) { 48TEST_F(ActionLayer, LayerStateCmp) {
63 TestDriver driver; 49 uint32_t prev_layer;
64 uint32_t prev_layer;
65 50
66 prev_layer = 0; 51 prev_layer = 0;
67 EXPECT_EQ(layer_state_cmp(prev_layer, 0), true); 52 EXPECT_EQ(layer_state_cmp(prev_layer, 0), true);
@@ -75,339 +60,33 @@ TEST_F(ActionLayer, LayerStateCmp) {
75 EXPECT_EQ(layer_state_cmp(prev_layer, 0), false); 60 EXPECT_EQ(layer_state_cmp(prev_layer, 0), false);
76 EXPECT_EQ(layer_state_cmp(prev_layer, 1), true); 61 EXPECT_EQ(layer_state_cmp(prev_layer, 1), true);
77 EXPECT_EQ(layer_state_cmp(prev_layer, 2), false); 62 EXPECT_EQ(layer_state_cmp(prev_layer, 2), false);
78
79 testing::Mock::VerifyAndClearExpectations(&driver);
80}
81
82TEST_F(ActionLayer, LayerClear) {
83 TestDriver driver;
84
85 layer_clear();
86 EXPECT_EQ(layer_state, 0);
87
88 testing::Mock::VerifyAndClearExpectations(&driver);
89}
90
91TEST_F(ActionLayer, LayerMove) {
92 TestDriver driver;
93
94 layer_move(0);
95 EXPECT_EQ(layer_state, 1);
96 layer_move(3);
97 EXPECT_EQ(layer_state, 0b1000);
98
99 testing::Mock::VerifyAndClearExpectations(&driver);
100}
101
102TEST_F(ActionLayer, LayerOn) {
103 TestDriver driver;
104
105 layer_clear();
106 layer_on(1);
107 layer_on(3);
108 layer_on(3);
109 EXPECT_EQ(layer_state, 0b1010);
110
111 testing::Mock::VerifyAndClearExpectations(&driver);
112}
113
114TEST_F(ActionLayer, LayerOff) {
115 TestDriver driver;
116
117 layer_clear();
118 layer_on(1);
119 layer_on(3);
120 layer_off(3);
121 layer_off(2);
122 EXPECT_EQ(layer_state, 0b0010);
123
124 testing::Mock::VerifyAndClearExpectations(&driver);
125}
126
127TEST_F(ActionLayer, MomentaryLayerDoesNothing) {
128 TestDriver driver;
129 KeymapKey layer_key = KeymapKey{0, 0, 0, MO(1)};
130
131 set_keymap({layer_key});
132
133 /* Press and release MO, nothing should happen. */
134 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
135 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
136 layer_key.press();
137 run_one_scan_loop();
138 testing::Mock::VerifyAndClearExpectations(&driver);
139
140 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
141 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
142 layer_key.release();
143 run_one_scan_loop();
144 testing::Mock::VerifyAndClearExpectations(&driver);
145}
146
147TEST_F(ActionLayer, MomentaryLayerWithKeypress) {
148 TestDriver driver;
149 KeymapKey layer_key = KeymapKey{0, 0, 0, MO(1)};
150
151 /* These keys must have the same position in the matrix, only the layer is different. */
152 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
153 set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
154
155 /* Press MO. */
156 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
157 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
158 layer_key.press();
159 run_one_scan_loop();
160 EXPECT_TRUE(layer_state_is(1));
161 testing::Mock::VerifyAndClearExpectations(&driver);
162
163 /* Press key on layer 1 */
164 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_B))).Times(1);
165 regular_key.press();
166 run_one_scan_loop();
167 EXPECT_TRUE(layer_state_is(1));
168 testing::Mock::VerifyAndClearExpectations(&driver);
169
170 /* Release key on layer 1 */
171 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
172 regular_key.release();
173 run_one_scan_loop();
174 EXPECT_TRUE(layer_state_is(1));
175 testing::Mock::VerifyAndClearExpectations(&driver);
176
177 /* Release MO */
178 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
179 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
180 layer_key.release();
181 run_one_scan_loop();
182 EXPECT_TRUE(layer_state_is(0));
183 testing::Mock::VerifyAndClearExpectations(&driver);
184}
185
186TEST_F(ActionLayer, ToggleLayerDoesNothing) {
187 GTEST_SKIP() << "TODO: Toggle layer does not activate the expected layer on key press but on release.";
188
189 TestDriver driver;
190 KeymapKey layer_key = KeymapKey{0, 0, 0, TG(1)};
191
192 set_keymap({layer_key});
193
194 /* Press TG. Layer state should not change as it's applied on release. */
195 EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
196 layer_key.press();
197 run_one_scan_loop();
198 EXPECT_TRUE(layer_state_is(1));
199 testing::Mock::VerifyAndClearExpectations(&driver);
200
201 /* Release TG. */
202 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
203 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
204 layer_key.release();
205 run_one_scan_loop();
206 EXPECT_TRUE(layer_state_is(1));
207 testing::Mock::VerifyAndClearExpectations(&driver);
208}
209
210TEST_F(ActionLayer, ToggleLayerUpAndDown) {
211 GTEST_SKIP() << "TODO: Toggle layer does not activate the expected layer on key press but on release.";
212
213 TestDriver driver;
214 KeymapKey toggle_layer_1_on_layer_0 = KeymapKey{0, 0, 0, TG(1)};
215 KeymapKey toggle_layer_0_on_layer_1 = KeymapKey{1, 1, 0, TG(0)};
216
217 set_keymap({toggle_layer_1_on_layer_0, toggle_layer_0_on_layer_1});
218
219 /* Toggle Layer 1. */
220 EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
221 toggle_layer_1_on_layer_0.press();
222 run_one_scan_loop();
223 EXPECT_TRUE(layer_state_is(1));
224 testing::Mock::VerifyAndClearExpectations(&driver);
225
226 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
227 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
228 toggle_layer_1_on_layer_0.release();
229 run_one_scan_loop();
230 EXPECT_TRUE(layer_state_is(1));
231 testing::Mock::VerifyAndClearExpectations(&driver);
232
233 /* Toggle Layer 0. */
234 EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
235 toggle_layer_0_on_layer_1.press();
236 run_one_scan_loop();
237 EXPECT_TRUE(layer_state_is(0));
238 testing::Mock::VerifyAndClearExpectations(&driver);
239
240 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
241 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
242 toggle_layer_0_on_layer_1.release();
243 run_one_scan_loop();
244 EXPECT_TRUE(layer_state_is(0));
245 testing::Mock::VerifyAndClearExpectations(&driver);
246}
247
248TEST_F(ActionLayer, LayerTapToggleDoesNothing) {
249 GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
250
251 TestDriver driver;
252 KeymapKey layer_key = KeymapKey{0, 0, 0, TT(1)};
253
254 set_keymap({layer_key});
255
256 /* Press and release TT. */
257 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
258 layer_key.press();
259 run_one_scan_loop();
260 EXPECT_TRUE(layer_state_is(1));
261 testing::Mock::VerifyAndClearExpectations(&driver);
262
263 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
264 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(2);
265 layer_key.release();
266 run_one_scan_loop();
267 EXPECT_TRUE(layer_state_is(0));
268 testing::Mock::VerifyAndClearExpectations(&driver);
269}
270
271TEST_F(ActionLayer, LayerTapToggleWithKeypress) {
272 GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
273
274 TestDriver driver;
275 KeymapKey layer_key = KeymapKey{0, 0, 0, TT(1)};
276
277 /* These keys must have the same position in the matrix, only the layer is different. */
278 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
279 set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
280
281 /* Press TT. */
282 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
283 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
284 layer_key.press();
285 run_one_scan_loop();
286 EXPECT_TRUE(layer_state_is(1));
287 testing::Mock::VerifyAndClearExpectations(&driver);
288
289 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_B))).Times(1);
290 regular_key.press();
291 run_one_scan_loop();
292 EXPECT_TRUE(layer_state_is(1));
293 testing::Mock::VerifyAndClearExpectations(&driver);
294
295 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
296 regular_key.release();
297 run_one_scan_loop();
298 EXPECT_TRUE(layer_state_is(1));
299 testing::Mock::VerifyAndClearExpectations(&driver);
300
301 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
302 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
303 layer_key.release();
304 run_one_scan_loop();
305 EXPECT_TRUE(layer_state_is(0));
306 testing::Mock::VerifyAndClearExpectations(&driver);
307}
308
309TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) {
310 GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
311
312 TestDriver driver;
313 KeymapKey layer_key = KeymapKey{0, 0, 0, TT(1)};
314
315 /* These keys must have the same position in the matrix, only the layer is different. */
316 KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
317 set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
318
319 /* Tap TT five times . */
320 /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
321 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(9);
322
323 layer_key.press();
324 run_one_scan_loop();
325 EXPECT_TRUE(layer_state_is(1));
326 layer_key.release();
327 run_one_scan_loop();
328 EXPECT_TRUE(layer_state_is(0));
329
330 layer_key.press();
331 run_one_scan_loop();
332 EXPECT_TRUE(layer_state_is(1));
333 layer_key.release();
334 run_one_scan_loop();
335 EXPECT_TRUE(layer_state_is(0));
336
337 layer_key.press();
338 run_one_scan_loop();
339 EXPECT_TRUE(layer_state_is(1));
340 layer_key.release();
341 run_one_scan_loop();
342 EXPECT_TRUE(layer_state_is(0));
343
344 layer_key.press();
345 run_one_scan_loop();
346 EXPECT_TRUE(layer_state_is(1));
347 layer_key.release();
348 run_one_scan_loop();
349 EXPECT_TRUE(layer_state_is(0));
350
351 layer_key.press();
352 run_one_scan_loop();
353 EXPECT_TRUE(layer_state_is(1));
354 layer_key.release();
355 run_one_scan_loop();
356 EXPECT_TRUE(layer_state_is(1));
357
358 testing::Mock::VerifyAndClearExpectations(&driver);
359
360 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_B))).Times(1);
361 regular_key.press();
362 run_one_scan_loop();
363 EXPECT_TRUE(layer_state_is(1));
364 testing::Mock::VerifyAndClearExpectations(&driver);
365
366 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
367 regular_key.release();
368 run_one_scan_loop();
369 EXPECT_TRUE(layer_state_is(1));
370 testing::Mock::VerifyAndClearExpectations(&driver);
371} 63}
372 64
373TEST_F(ActionLayer, LayerTapReleasedBeforeKeypressReleaseWithModifiers) { 65// TEST_F(ActionLayer, LayerClear) {
374 GTEST_SKIP() << "TODO: Modifiers are erroneously discarded on layer changes, although a key that introduced the modifier is still held."; 66// layer_clear();
375 TestDriver driver; 67// EXPECT_EQ(layer_state, 0);
376 InSequence s; 68// }
377 69
378 KeymapKey layer_0_key_0 = KeymapKey{0, 0, 0, LT(1, KC_T)}; 70// TEST_F(ActionLayer, LayerMove) {
379 KeymapKey layer_1_key_1 = KeymapKey{1, 1, 0, RALT(KC_9)}; 71// layer_move(0);
380 72// EXPECT_EQ(layer_state, 1);
381 set_keymap({layer_0_key_0, layer_1_key_1}); 73// layer_move(3);
382 74// EXPECT_EQ(layer_state, 0b1000);
383 /* Press layer tap and wait for tapping term to switch to layer 1 */ 75// }
384 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0); 76
385 layer_0_key_0.press(); 77// TEST_F(ActionLayer, LayerOn) {
386 idle_for(TAPPING_TERM); 78// layer_clear();
387 EXPECT_TRUE(layer_state_is(0)); 79// layer_on(1);
388 testing::Mock::VerifyAndClearExpectations(&driver); 80// layer_on(3);
389 81// layer_on(3);
390 /* Press key with layer 1 mapping, result basically expected 82// EXPECT_EQ(layer_state, 0b1010);
391 * altough more reports are send then necessary. */ 83// }
392 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_RALT))).Times(1); 84
393 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_RALT, KC_9))).Times(1); 85// TEST_F(ActionLayer, LayerOff) {
394 layer_1_key_1.press(); 86// layer_clear();
395 run_one_scan_loop(); 87// layer_on(1);
396 EXPECT_TRUE(layer_state_is(1)); 88// layer_on(3);
397 testing::Mock::VerifyAndClearExpectations(&driver); 89// layer_off(3);
398 90// layer_off(2);
399 /* Release layer tap key, no report is send because key is still held. */ 91// EXPECT_EQ(layer_state, 0b1000);
400 EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0); 92// }
401 layer_0_key_0.release();
402 run_one_scan_loop();
403 EXPECT_TRUE(layer_state_is(0));
404 testing::Mock::VerifyAndClearExpectations(&driver);
405
406 /* Unregister keycode and modifier. */
407 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_RALT))).Times(1);
408 EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
409 layer_1_key_1.release();
410 run_one_scan_loop();
411 EXPECT_TRUE(layer_state_is(0));
412 testing::Mock::VerifyAndClearExpectations(&driver);
413}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-04 03:15:43 +0000