logo

qmk_firmware

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

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.  */
  17. #include "gtest/gtest.h"
  18. #include "keyboard_report_util.hpp"
  19. #include "test_common.hpp"
  21. using testing::_;
  22. using testing::AnyNumber;
  23. using testing::InSequence;
  25. class ActionLayer : public TestFixture {};
  27. TEST_F(ActionLayer, LayerStateDBG) {
  28.     TestDriver driver;
  30.     layer_state_set(0);
  32.     VERIFY_AND_CLEAR(driver);
  33. }
  35. TEST_F(ActionLayer, LayerStateSet) {
  36.     TestDriver driver;
  38.     layer_state_set(0);
  39.     EXPECT_EQ(layer_state, 0);
  40.     layer_state_set(0b001100);
  41.     EXPECT_EQ(layer_state, 0b001100);
  43.     VERIFY_AND_CLEAR(driver);
  44. }
  46. TEST_F(ActionLayer, LayerStateIs) {
  47.     TestDriver driver;
  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);
  60.     VERIFY_AND_CLEAR(driver);
  61. }
  63. TEST_F(ActionLayer, LayerStateCmp) {
  64.     TestDriver driver;
  65.     uint32_t   prev_layer;
  67.     prev_layer = 0;
  68.     EXPECT_EQ(layer_state_cmp(prev_layer, 0), true);
  69.     EXPECT_EQ(layer_state_cmp(prev_layer, 1), false);
  71.     prev_layer = 1;
  72.     EXPECT_EQ(layer_state_cmp(prev_layer, 0), true);
  73.     EXPECT_EQ(layer_state_cmp(prev_layer, 1), false);
  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);
  80.     VERIFY_AND_CLEAR(driver);
  81. }
  83. TEST_F(ActionLayer, LayerClear) {
  84.     TestDriver driver;
  86.     layer_clear();
  87.     EXPECT_EQ(layer_state, 0);
  89.     VERIFY_AND_CLEAR(driver);
  90. }
  92. TEST_F(ActionLayer, LayerMove) {
  93.     TestDriver driver;
  95.     layer_move(0);
  96.     EXPECT_EQ(layer_state, 1);
  97.     layer_move(3);
  98.     EXPECT_EQ(layer_state, 0b1000);
  100.     VERIFY_AND_CLEAR(driver);
  101. }
  103. TEST_F(ActionLayer, LayerOn) {
  104.     TestDriver driver;
  106.     layer_clear();
  107.     layer_on(1);
  108.     layer_on(3);
  109.     layer_on(3);
  110.     EXPECT_EQ(layer_state, 0b1010);
  112.     VERIFY_AND_CLEAR(driver);
  113. }
  115. TEST_F(ActionLayer, LayerOff) {
  116.     TestDriver driver;
  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);
  125.     VERIFY_AND_CLEAR(driver);
  126. }
  128. TEST_F(ActionLayer, MomentaryLayerDoesNothing) {
  129.     TestDriver driver;
  130.     KeymapKey  layer_key = KeymapKey{0, 0, 0, MO(1)};
  132.     set_keymap({layer_key});
  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);
  140.     EXPECT_NO_REPORT(driver);
  141.     layer_key.release();
  142.     run_one_scan_loop();
  143.     VERIFY_AND_CLEAR(driver);
  144. }
  146. TEST_F(ActionLayer, MomentaryLayerWithKeypress) {
  147.     TestDriver driver;
  148.     KeymapKey  layer_key = KeymapKey{0, 0, 0, MO(1)};
  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}});
  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);
  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);
  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);
  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. }
  183. TEST_F(ActionLayer, ToggleLayerDoesNothing) {
  184.     GTEST_SKIP() << "TODO: Toggle layer does not activate the expected layer on key press but on release.";
  186.     TestDriver driver;
  187.     KeymapKey  layer_key = KeymapKey{0, 0, 0, TG(1)};
  189.     set_keymap({layer_key});
  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);
  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. }
  206. TEST_F(ActionLayer, ToggleLayerUpAndDown) {
  207.     GTEST_SKIP() << "TODO: Toggle layer does not activate the expected layer on key press but on release.";
  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)};
  213.     set_keymap({toggle_layer_1_on_layer_0, toggle_layer_0_on_layer_1});
  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);
  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);
  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);
  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. }
  242. TEST_F(ActionLayer, LayerTapToggleDoesNothing) {
  243.     GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
  245.     TestDriver driver;
  246.     KeymapKey  layer_key = KeymapKey{0, 0, 0, TT(1)};
  248.     set_keymap({layer_key});
  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);
  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. }
  264. TEST_F(ActionLayer, LayerTapToggleWithKeypress) {
  265.     GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
  267.     TestDriver driver;
  268.     KeymapKey  layer_key = KeymapKey{0, 0, 0, TT(1)};
  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}});
  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);
  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);
  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);
  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. }
  300. TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) {
  301.     GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
  303.     TestDriver driver;
  304.     KeymapKey  layer_key = KeymapKey{0, 0, 0, TT(1)};
  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}});
  310.     /* Tap TT five times . */
  311.     EXPECT_NO_REPORT(driver);
  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));
  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));
  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));
  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));
  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));
  348.     VERIFY_AND_CLEAR(driver);
  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);
  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. }
  363. TEST_F(ActionLayer, LayerTapReleasedBeforeKeypressReleaseWithModifiers) {
  364.     TestDriver driver;
  365.     InSequence s;
  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)};
  371.     set_keymap({layer_0_key_0, layer_0_key_1, layer_1_key_1});
  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);
  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);
  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);
  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. }
  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}});
  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);
  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));
  425.     tap_key(regular_key);
  427.     layer_key.release();
  428.     run_one_scan_loop();
  429.     EXPECT_TRUE(layer_state_is(0));
  430.     EXPECT_EQ(get_mods(), 0);
  432.     VERIFY_AND_CLEAR(driver);
  433. }
  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}});
  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);
  450.     keymap_config.swap_ralt_rgui = true;
  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));
  457.     tap_key(regular_key);
  459.     layer_key.release();
  460.     run_one_scan_loop();
  461.     EXPECT_TRUE(layer_state_is(0));
  462.     EXPECT_EQ(get_mods(), 0);
  464.     VERIFY_AND_CLEAR(driver);
  465. }