test_action_layer.cpp (12809B)
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 21 using testing::_; 22 using testing::AnyNumber; 23 using testing::InSequence; 24 25 class ActionLayer : public TestFixture {}; 26 27 TEST_F(ActionLayer, LayerStateDBG) { 28 TestDriver driver; 29 30 layer_state_set(0); 31 32 VERIFY_AND_CLEAR(driver); 33 } 34 35 TEST_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 46 TEST_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 63 TEST_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 83 TEST_F(ActionLayer, LayerClear) { 84 TestDriver driver; 85 86 layer_clear(); 87 EXPECT_EQ(layer_state, 0); 88 89 VERIFY_AND_CLEAR(driver); 90 } 91 92 TEST_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 103 TEST_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 115 TEST_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 128 TEST_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 146 TEST_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 183 TEST_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 206 TEST_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 242 TEST_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 264 TEST_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 300 TEST_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 363 TEST_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 405 TEST_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 435 TEST_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 }