logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

test_layer_lock.cpp (8529B)

    

  1. // Copyright 2021 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
  2. // SPDX-License-Identifier: GPL-2.0-or-later
  4. #include "keycodes.h"
  5. #include "test_common.hpp"
  7. using testing::_;
  9. class LayerLock : public TestFixture {};
  11. TEST_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);
  18.     set_keymap({key_a, key_b, key_c, key_d});
  20.     EXPECT_FALSE(is_layer_locked(1));
  21.     EXPECT_FALSE(is_layer_locked(2));
  22.     EXPECT_FALSE(is_layer_locked(3));
  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
  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));
  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
  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));
  47.     layer_lock_invert(1); // Layer 1: unlocked -> locked
  48.     layer_lock_off(2);    // Layer 2: locked -> unlocked
  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));
  57.     layer_lock_all_off(); // Layers 1 and 3: locked -> unlocked
  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. }
  67. TEST_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);
  74.     set_keymap({key_layer, key_a, key_trns, key_ll});
  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);
  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);
  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);
  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. }
  105. TEST_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);
  112.     set_keymap({key_layer, key_a, key_trns, key_ll});
  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);
  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);
  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. }
  136. TEST_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);
  143.     set_keymap({key_layer, key_a, key_trns, key_ll});
  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);
  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);
  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. }
  167. TEST_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);
  174.     set_keymap({key_layer, key_a, key_trns, key_ll});
  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);
  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);
  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);
  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. }
  205. TEST_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);
  212.     set_keymap({key_layer, key_a, key_trns, key_ll});
  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);
  220.     EXPECT_NO_REPORT(driver);
  221.     tap_key(key_ll);
  222.     EXPECT_TRUE(layer_state_is(1));
  223.     VERIFY_AND_CLEAR(driver);
  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);
  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. }
  240. TEST_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);
  246.     set_keymap({key_layer, key_to0, key_ll});
  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);
  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. }
  262. TEST_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);
  268.     set_keymap({key_layer, key_a, key_ll});
  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);
  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. }