test_secure.cpp
7812 bytes
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 "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 Secure : public TestFixture {
26 public:
27 void SetUp() override {
28 secure_lock();
29 }
30};
31
32TEST_F(Secure, test_lock) {
33 TestDriver driver;
34
35 // Don't allow empty reports.
36 EXPECT_NO_REPORT(driver);
37
38 EXPECT_FALSE(secure_is_unlocked());
39 secure_unlock();
40 EXPECT_TRUE(secure_is_unlocked());
41 run_one_scan_loop();
42 EXPECT_TRUE(secure_is_unlocked());
43 secure_lock();
44 EXPECT_FALSE(secure_is_unlocked());
45
46 VERIFY_AND_CLEAR(driver);
47}
48
49TEST_F(Secure, test_unlock_timeout) {
50 TestDriver driver;
51
52 // Don't allow empty reports.
53 EXPECT_NO_REPORT(driver);
54
55 EXPECT_FALSE(secure_is_unlocked());
56 secure_unlock();
57 EXPECT_TRUE(secure_is_unlocked());
58 idle_for(SECURE_IDLE_TIMEOUT + 1);
59 EXPECT_FALSE(secure_is_unlocked());
60
61 VERIFY_AND_CLEAR(driver);
62}
63
64TEST_F(Secure, test_unlock_request) {
65 TestDriver driver;
66 auto key_mo = KeymapKey(0, 0, 0, MO(1));
67 auto key_a = KeymapKey(0, 1, 0, KC_A);
68 auto key_b = KeymapKey(0, 2, 0, KC_B);
69 auto key_c = KeymapKey(0, 3, 0, KC_C);
70 auto key_d = KeymapKey(0, 4, 0, KC_D);
71
72 set_keymap({key_mo, key_a, key_b, key_c, key_d});
73
74 // Don't allow empty reports.
75 EXPECT_NO_REPORT(driver);
76
77 EXPECT_TRUE(secure_is_locked());
78 secure_request_unlock();
79 EXPECT_TRUE(secure_is_unlocking());
80 tap_keys(key_a, key_b, key_c, key_d);
81 EXPECT_TRUE(secure_is_unlocked());
82
83 VERIFY_AND_CLEAR(driver);
84}
85
86TEST_F(Secure, test_unlock_request_fail) {
87 TestDriver driver;
88 auto key_e = KeymapKey(0, 0, 0, KC_E);
89 auto key_a = KeymapKey(0, 1, 0, KC_A);
90 auto key_b = KeymapKey(0, 2, 0, KC_B);
91 auto key_c = KeymapKey(0, 3, 0, KC_C);
92 auto key_d = KeymapKey(0, 4, 0, KC_D);
93
94 set_keymap({key_e, key_a, key_b, key_c, key_d});
95
96 // Allow any number of empty reports.
97 EXPECT_EMPTY_REPORT(driver).Times(AnyNumber());
98 { // Expect the following reports in this order.
99 InSequence s;
100 EXPECT_REPORT(driver, (KC_A));
101 EXPECT_REPORT(driver, (KC_B));
102 EXPECT_REPORT(driver, (KC_C));
103 EXPECT_REPORT(driver, (KC_D));
104 }
105 EXPECT_TRUE(secure_is_locked());
106 secure_request_unlock();
107 EXPECT_TRUE(secure_is_unlocking());
108 tap_keys(key_e, key_a, key_b, key_c, key_d);
109 EXPECT_FALSE(secure_is_unlocked());
110
111 VERIFY_AND_CLEAR(driver);
112}
113
114TEST_F(Secure, test_unlock_request_timeout) {
115 TestDriver driver;
116
117 // Don't allow empty reports.
118 EXPECT_NO_REPORT(driver);
119
120 EXPECT_FALSE(secure_is_unlocked());
121 secure_request_unlock();
122 EXPECT_TRUE(secure_is_unlocking());
123 idle_for(SECURE_UNLOCK_TIMEOUT + 1);
124 EXPECT_FALSE(secure_is_unlocking());
125 EXPECT_FALSE(secure_is_unlocked());
126
127 VERIFY_AND_CLEAR(driver);
128}
129
130TEST_F(Secure, test_unlock_request_fail_mid) {
131 TestDriver driver;
132 auto key_e = KeymapKey(0, 0, 0, KC_E);
133 auto key_a = KeymapKey(0, 1, 0, KC_A);
134 auto key_b = KeymapKey(0, 2, 0, KC_B);
135 auto key_c = KeymapKey(0, 3, 0, KC_C);
136 auto key_d = KeymapKey(0, 4, 0, KC_D);
137
138 set_keymap({key_e, key_a, key_b, key_c, key_d});
139
140 // Allow any number of empty reports.
141 EXPECT_EMPTY_REPORT(driver).Times(AnyNumber());
142 { // Expect the following reports in this order.
143 InSequence s;
144 EXPECT_REPORT(driver, (KC_C));
145 EXPECT_REPORT(driver, (KC_D));
146 }
147 EXPECT_FALSE(secure_is_unlocked());
148 secure_request_unlock();
149 EXPECT_TRUE(secure_is_unlocking());
150 tap_keys(key_a, key_b, key_e, key_c, key_d);
151 EXPECT_FALSE(secure_is_unlocking());
152 EXPECT_FALSE(secure_is_unlocked());
153
154 VERIFY_AND_CLEAR(driver);
155}
156
157TEST_F(Secure, test_unlock_request_fail_out_of_order) {
158 TestDriver driver;
159 auto key_e = KeymapKey(0, 0, 0, KC_E);
160 auto key_a = KeymapKey(0, 1, 0, KC_A);
161 auto key_b = KeymapKey(0, 2, 0, KC_B);
162 auto key_c = KeymapKey(0, 3, 0, KC_C);
163 auto key_d = KeymapKey(0, 4, 0, KC_D);
164
165 set_keymap({key_e, key_a, key_b, key_c, key_d});
166
167 // Allow any number of empty reports.
168 EXPECT_EMPTY_REPORT(driver).Times(AnyNumber());
169 { // Expect the following reports in this order.
170 InSequence s;
171 EXPECT_REPORT(driver, (KC_B));
172 EXPECT_REPORT(driver, (KC_C));
173 }
174 EXPECT_FALSE(secure_is_unlocked());
175 secure_request_unlock();
176 EXPECT_TRUE(secure_is_unlocking());
177 tap_keys(key_a, key_d, key_b, key_c);
178 EXPECT_TRUE(secure_is_locked());
179 EXPECT_FALSE(secure_is_unlocking());
180 EXPECT_FALSE(secure_is_unlocked());
181
182 VERIFY_AND_CLEAR(driver);
183}
184
185TEST_F(Secure, test_unlock_request_on_layer) {
186 TestDriver driver;
187 auto key_mo = KeymapKey(0, 0, 0, MO(1));
188 auto key_a = KeymapKey(0, 1, 0, KC_A);
189 auto key_b = KeymapKey(0, 2, 0, KC_B);
190 auto key_c = KeymapKey(0, 3, 0, KC_C);
191 auto key_d = KeymapKey(0, 4, 0, KC_D);
192
193 set_keymap({key_mo, key_a, key_b, key_c, key_d});
194
195 // Don't allow empty reports.
196 EXPECT_NO_REPORT(driver);
197
198 EXPECT_TRUE(secure_is_locked());
199 key_mo.press();
200 run_one_scan_loop();
201 secure_request_unlock();
202 key_mo.release();
203 run_one_scan_loop();
204 EXPECT_TRUE(secure_is_unlocking());
205 tap_keys(key_a, key_b, key_c, key_d);
206 EXPECT_TRUE(secure_is_unlocked());
207 EXPECT_FALSE(layer_state_is(1));
208
209 VERIFY_AND_CLEAR(driver);
210}
211
212TEST_F(Secure, test_unlock_request_mid_stroke) {
213 TestDriver driver;
214 auto key_e = KeymapKey(0, 0, 0, KC_E);
215 auto key_a = KeymapKey(0, 1, 0, KC_A);
216 auto key_b = KeymapKey(0, 2, 0, KC_B);
217 auto key_c = KeymapKey(0, 3, 0, KC_C);
218 auto key_d = KeymapKey(0, 4, 0, KC_D);
219
220 set_keymap({key_e, key_a, key_b, key_c, key_d});
221
222 EXPECT_REPORT(driver, (KC_E));
223 EXPECT_EMPTY_REPORT(driver);
224 EXPECT_TRUE(secure_is_locked());
225 key_e.press();
226 run_one_scan_loop();
227 secure_request_unlock();
228 key_e.release();
229 run_one_scan_loop();
230 EXPECT_TRUE(secure_is_unlocking());
231 tap_keys(key_a, key_b, key_c, key_d);
232 EXPECT_TRUE(secure_is_unlocked());
233
234 VERIFY_AND_CLEAR(driver);
235}
236
237TEST_F(Secure, test_unlock_request_mods) {
238 TestDriver driver;
239 auto key_lsft = KeymapKey(0, 0, 0, KC_LSFT);
240 auto key_a = KeymapKey(0, 1, 0, KC_A);
241 auto key_b = KeymapKey(0, 2, 0, KC_B);
242 auto key_c = KeymapKey(0, 3, 0, KC_C);
243 auto key_d = KeymapKey(0, 4, 0, KC_D);
244
245 set_keymap({key_lsft, key_a, key_b, key_c, key_d});
246
247 EXPECT_REPORT(driver, (key_lsft.report_code));
248 EXPECT_EMPTY_REPORT(driver);
249 EXPECT_TRUE(secure_is_locked());
250 key_lsft.press();
251 run_one_scan_loop();
252 secure_request_unlock();
253 key_lsft.release();
254 run_one_scan_loop();
255 EXPECT_TRUE(secure_is_unlocking());
256 tap_keys(key_a, key_b, key_c, key_d);
257 EXPECT_TRUE(secure_is_unlocked());
258
259 VERIFY_AND_CLEAR(driver);
260}