summaryrefslogtreecommitdiff
path: root/tests/layer_lock/test_layer_lock.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/layer_lock/test_layer_lock.cpp')
-rw-r--r--tests/layer_lock/test_layer_lock.cpp284
1 files changed, 284 insertions, 0 deletions
diff --git a/tests/layer_lock/test_layer_lock.cpp b/tests/layer_lock/test_layer_lock.cpp
new file mode 100644
index 0000000000..00742c3b43
--- /dev/null
+++ b/tests/layer_lock/test_layer_lock.cpp
@@ -0,0 +1,284 @@
1// Copyright 2021 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.com>
2// SPDX-License-Identifier: GPL-2.0-or-later
3
4#include "keycodes.h"
5#include "test_common.hpp"
6
7using testing::_;
8
9class LayerLock : public TestFixture {};
10
11TEST_F(LayerLock, LayerLockState) {
12 TestDriver driver;
13 KeymapKey key_a = KeymapKey(0, 0, 0, KC_A);
14 KeymapKey key_b = KeymapKey(1, 0, 0, KC_B);
15 KeymapKey key_c = KeymapKey(2, 0, 0, KC_C);
16 KeymapKey key_d = KeymapKey(3, 0, 0, KC_C);
17
18 set_keymap({key_a, key_b, key_c, key_d});
19
20 EXPECT_FALSE(is_layer_locked(1));
21 EXPECT_FALSE(is_layer_locked(2));
22 EXPECT_FALSE(is_layer_locked(3));
23
24 layer_lock_invert(1); // Layer 1: unlocked -> locked
25 layer_lock_on(2); // Layer 2: unlocked -> locked
26 layer_lock_off(3); // Layer 3: stays unlocked
27
28 // Layers 1 and 2 are now on.
29 EXPECT_TRUE(layer_state_is(1));
30 EXPECT_TRUE(layer_state_is(2));
31 // Layers 1 and 2 are now locked.
32 EXPECT_TRUE(is_layer_locked(1));
33 EXPECT_TRUE(is_layer_locked(2));
34 EXPECT_FALSE(is_layer_locked(3));
35
36 layer_lock_invert(1); // Layer 1: locked -> unlocked
37 layer_lock_on(2); // Layer 2: stays locked
38 layer_lock_on(3); // Layer 3: unlocked -> locked
39
40 EXPECT_FALSE(layer_state_is(1));
41 EXPECT_TRUE(layer_state_is(2));
42 EXPECT_TRUE(layer_state_is(3));
43 EXPECT_FALSE(is_layer_locked(1));
44 EXPECT_TRUE(is_layer_locked(2));
45 EXPECT_TRUE(is_layer_locked(3));
46
47 layer_lock_invert(1); // Layer 1: unlocked -> locked
48 layer_lock_off(2); // Layer 2: locked -> unlocked
49
50 EXPECT_TRUE(layer_state_is(1));
51 EXPECT_FALSE(layer_state_is(2));
52 EXPECT_TRUE(layer_state_is(3));
53 EXPECT_TRUE(is_layer_locked(1));
54 EXPECT_FALSE(is_layer_locked(2));
55 EXPECT_TRUE(is_layer_locked(3));
56
57 layer_lock_all_off(); // Layers 1 and 3: locked -> unlocked
58
59 EXPECT_FALSE(layer_state_is(1));
60 EXPECT_FALSE(layer_state_is(2));
61 EXPECT_FALSE(layer_state_is(3));
62 EXPECT_FALSE(is_layer_locked(1));
63 EXPECT_FALSE(is_layer_locked(2));
64 EXPECT_FALSE(is_layer_locked(3));
65}
66
67TEST_F(LayerLock, LayerLockMomentaryTest) {
68 TestDriver driver;
69 KeymapKey key_layer = KeymapKey(0, 0, 0, MO(1));
70 KeymapKey key_a = KeymapKey(0, 1, 0, KC_A);
71 KeymapKey key_trns = KeymapKey(1, 0, 0, KC_TRNS);
72 KeymapKey key_ll = KeymapKey(1, 1, 0, QK_LAYER_LOCK);
73
74 set_keymap({key_layer, key_a, key_trns, key_ll});
75
76 EXPECT_NO_REPORT(driver);
77 key_layer.press();
78 run_one_scan_loop();
79 EXPECT_TRUE(layer_state_is(1));
80 EXPECT_FALSE(is_layer_locked(1));
81 VERIFY_AND_CLEAR(driver);
82
83 EXPECT_NO_REPORT(driver);
84 tap_key(key_ll);
85 EXPECT_TRUE(layer_state_is(1));
86 EXPECT_TRUE(is_layer_locked(1));
87 VERIFY_AND_CLEAR(driver);
88
89 EXPECT_NO_REPORT(driver);
90 key_layer.release();
91 run_one_scan_loop();
92 EXPECT_TRUE(layer_state_is(1));
93 EXPECT_TRUE(is_layer_locked(1));
94 VERIFY_AND_CLEAR(driver);
95
96 // Pressing Layer Lock again unlocks the lock.
97 EXPECT_NO_REPORT(driver);
98 key_ll.press();
99 run_one_scan_loop();
100 EXPECT_FALSE(layer_state_is(1));
101 EXPECT_FALSE(is_layer_locked(1));
102 VERIFY_AND_CLEAR(driver);
103}
104
105TEST_F(LayerLock, LayerLockLayerTapTest) {
106 TestDriver driver;
107 KeymapKey key_layer = KeymapKey(0, 0, 0, LT(1, KC_B));
108 KeymapKey key_a = KeymapKey(0, 1, 0, KC_A);
109 KeymapKey key_trns = KeymapKey(1, 0, 0, KC_TRNS);
110 KeymapKey key_ll = KeymapKey(1, 1, 0, QK_LAYER_LOCK);
111
112 set_keymap({key_layer, key_a, key_trns, key_ll});
113
114 EXPECT_NO_REPORT(driver);
115 key_layer.press();
116 idle_for(TAPPING_TERM);
117 run_one_scan_loop();
118 EXPECT_TRUE(layer_state_is(1));
119 VERIFY_AND_CLEAR(driver);
120
121 EXPECT_NO_REPORT(driver);
122 tap_key(key_ll);
123 EXPECT_TRUE(layer_state_is(1));
124 EXPECT_TRUE(is_layer_locked(1));
125 VERIFY_AND_CLEAR(driver);
126
127 // Pressing Layer Lock again unlocks the lock.
128 EXPECT_NO_REPORT(driver);
129 key_ll.press();
130 run_one_scan_loop();
131 EXPECT_FALSE(layer_state_is(1));
132 EXPECT_FALSE(is_layer_locked(1));
133 VERIFY_AND_CLEAR(driver);
134}
135
136TEST_F(LayerLock, LayerLockOneshotTapTest) {
137 TestDriver driver;
138 KeymapKey key_layer = KeymapKey(0, 0, 0, OSL(1));
139 KeymapKey key_a = KeymapKey(0, 1, 0, KC_A);
140 KeymapKey key_trns = KeymapKey(1, 0, 0, KC_TRNS);
141 KeymapKey key_ll = KeymapKey(1, 1, 0, QK_LAYER_LOCK);
142
143 set_keymap({key_layer, key_a, key_trns, key_ll});
144
145 EXPECT_NO_REPORT(driver);
146 tap_key(key_layer);
147 run_one_scan_loop();
148 EXPECT_TRUE(layer_state_is(1));
149 VERIFY_AND_CLEAR(driver);
150
151 EXPECT_NO_REPORT(driver);
152 tap_key(key_ll);
153 run_one_scan_loop();
154 EXPECT_TRUE(layer_state_is(1));
155 EXPECT_TRUE(is_layer_locked(1));
156 VERIFY_AND_CLEAR(driver);
157
158 // Pressing Layer Lock again unlocks the lock.
159 EXPECT_NO_REPORT(driver);
160 key_ll.press();
161 run_one_scan_loop();
162 EXPECT_FALSE(layer_state_is(1));
163 EXPECT_FALSE(is_layer_locked(1));
164 VERIFY_AND_CLEAR(driver);
165}
166
167TEST_F(LayerLock, LayerLockOneshotHoldTest) {
168 TestDriver driver;
169 KeymapKey key_layer = KeymapKey(0, 0, 0, OSL(1));
170 KeymapKey key_a = KeymapKey(0, 1, 0, KC_A);
171 KeymapKey key_trns = KeymapKey(1, 0, 0, KC_TRNS);
172 KeymapKey key_ll = KeymapKey(1, 1, 0, QK_LAYER_LOCK);
173
174 set_keymap({key_layer, key_a, key_trns, key_ll});
175
176 EXPECT_NO_REPORT(driver);
177 key_layer.press();
178 idle_for(TAPPING_TERM);
179 run_one_scan_loop();
180 EXPECT_TRUE(layer_state_is(1));
181 VERIFY_AND_CLEAR(driver);
182
183 EXPECT_NO_REPORT(driver);
184 tap_key(key_ll);
185 run_one_scan_loop();
186 EXPECT_TRUE(layer_state_is(1));
187 VERIFY_AND_CLEAR(driver);
188
189 EXPECT_NO_REPORT(driver);
190 key_layer.release();
191 run_one_scan_loop();
192 EXPECT_TRUE(layer_state_is(1));
193 EXPECT_TRUE(is_layer_locked(1));
194 VERIFY_AND_CLEAR(driver);
195
196 // Pressing Layer Lock again unlocks the lock.
197 EXPECT_NO_REPORT(driver);
198 key_ll.press();
199 run_one_scan_loop();
200 EXPECT_FALSE(layer_state_is(1));
201 EXPECT_FALSE(is_layer_locked(1));
202 VERIFY_AND_CLEAR(driver);
203}
204
205TEST_F(LayerLock, LayerLockTimeoutTest) {
206 TestDriver driver;
207 KeymapKey key_layer = KeymapKey(0, 0, 0, MO(1));
208 KeymapKey key_a = KeymapKey(0, 1, 0, KC_A);
209 KeymapKey key_trns = KeymapKey(1, 0, 0, KC_TRNS);
210 KeymapKey key_ll = KeymapKey(1, 1, 0, QK_LAYER_LOCK);
211
212 set_keymap({key_layer, key_a, key_trns, key_ll});
213
214 EXPECT_NO_REPORT(driver);
215 key_layer.press();
216 run_one_scan_loop();
217 EXPECT_TRUE(layer_state_is(1));
218 VERIFY_AND_CLEAR(driver);
219
220 EXPECT_NO_REPORT(driver);
221 tap_key(key_ll);
222 EXPECT_TRUE(layer_state_is(1));
223 VERIFY_AND_CLEAR(driver);
224
225 EXPECT_NO_REPORT(driver);
226 key_layer.release();
227 run_one_scan_loop();
228 EXPECT_TRUE(layer_state_is(1));
229 EXPECT_TRUE(is_layer_locked(1));
230 VERIFY_AND_CLEAR(driver);
231
232 EXPECT_NO_REPORT(driver);
233 idle_for(LAYER_LOCK_IDLE_TIMEOUT);
234 run_one_scan_loop();
235 EXPECT_FALSE(layer_state_is(1));
236 EXPECT_FALSE(is_layer_locked(1));
237 VERIFY_AND_CLEAR(driver);
238}
239
240TEST_F(LayerLock, ToKeyOverridesLayerLock) {
241 TestDriver driver;
242 KeymapKey key_layer = KeymapKey(0, 0, 0, MO(1));
243 KeymapKey key_to0 = KeymapKey(1, 0, 0, TO(0));
244 KeymapKey key_ll = KeymapKey(1, 1, 0, QK_LAYER_LOCK);
245
246 set_keymap({key_layer, key_to0, key_ll});
247
248 EXPECT_NO_REPORT(driver);
249 layer_lock_on(1);
250 run_one_scan_loop();
251 EXPECT_TRUE(layer_state_is(1));
252 EXPECT_TRUE(is_layer_locked(1));
253 VERIFY_AND_CLEAR(driver);
254
255 EXPECT_NO_REPORT(driver);
256 tap_key(key_to0); // TO(0) overrides Layer Lock and unlocks layer 1.
257 EXPECT_FALSE(layer_state_is(1));
258 EXPECT_FALSE(is_layer_locked(1));
259 VERIFY_AND_CLEAR(driver);
260}
261
262TEST_F(LayerLock, LayerClearOverridesLayerLock) {
263 TestDriver driver;
264 KeymapKey key_layer = KeymapKey(0, 0, 0, MO(1));
265 KeymapKey key_a = KeymapKey(0, 1, 0, KC_A);
266 KeymapKey key_ll = KeymapKey(1, 1, 0, QK_LAYER_LOCK);
267
268 set_keymap({key_layer, key_a, key_ll});
269
270 EXPECT_NO_REPORT(driver);
271 layer_lock_on(1);
272 run_one_scan_loop();
273 EXPECT_TRUE(layer_state_is(1));
274 EXPECT_TRUE(is_layer_locked(1));
275 VERIFY_AND_CLEAR(driver);
276
277 EXPECT_REPORT(driver, (KC_A));
278 layer_clear(); // layer_clear() overrides Layer Lock and unlocks layer 1.
279 key_a.press();
280 run_one_scan_loop();
281 EXPECT_FALSE(layer_state_is(1));
282 EXPECT_FALSE(is_layer_locked(1));
283 VERIFY_AND_CLEAR(driver);
284}
generated by cgit v1.2.3 (git 2.25.1) at 2026-09-03 09:01:16 +0000