test_secure.cpp (7812B)
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 21 using testing::_; 22 using testing::AnyNumber; 23 using testing::InSequence; 24 25 class Secure : public TestFixture { 26 public: 27 void SetUp() override { 28 secure_lock(); 29 } 30 }; 31 32 TEST_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 49 TEST_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 64 TEST_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 86 TEST_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 114 TEST_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 130 TEST_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 157 TEST_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 185 TEST_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 212 TEST_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 237 TEST_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 }