logo

qmk_firmware

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

test_leader.cpp (5370B)

    

  1. // Copyright 2023 QMK
  2. // SPDX-License-Identifier: GPL-2.0-or-later
  4. #include "keyboard_report_util.hpp"
  5. #include "keycode.h"
  6. #include "test_common.hpp"
  7. #include "test_keymap_key.hpp"
  9. using testing::_;
  11. class Leader : public TestFixture {};
  13. TEST_F(Leader, triggers_one_key_sequence) {
  14.     TestDriver driver;
  16.     auto key_leader = KeymapKey(0, 0, 0, QK_LEADER);
  17.     auto key_a      = KeymapKey(0, 1, 0, KC_A);
  19.     set_keymap({key_leader, key_a});
  21.     EXPECT_EQ(leader_sequence_active(), false);
  23.     EXPECT_NO_REPORT(driver);
  24.     tap_key(key_leader);
  26.     EXPECT_EQ(leader_sequence_active(), true);
  28.     EXPECT_REPORT(driver, (KC_1));
  29.     EXPECT_EMPTY_REPORT(driver);
  30.     tap_key(key_a);
  32.     EXPECT_EQ(leader_sequence_timed_out(), false);
  34.     idle_for(300);
  36.     EXPECT_EQ(leader_sequence_active(), false);
  37.     EXPECT_EQ(leader_sequence_timed_out(), true);
  39.     EXPECT_REPORT(driver, (KC_A));
  40.     EXPECT_EMPTY_REPORT(driver);
  41.     tap_key(key_a);
  42. }
  44. TEST_F(Leader, triggers_two_key_sequence) {
  45.     TestDriver driver;
  47.     auto key_leader = KeymapKey(0, 0, 0, QK_LEADER);
  48.     auto key_a      = KeymapKey(0, 1, 0, KC_A);
  49.     auto key_b      = KeymapKey(0, 2, 0, KC_B);
  51.     set_keymap({key_leader, key_a, key_b});
  53.     EXPECT_EQ(leader_sequence_active(), false);
  55.     EXPECT_NO_REPORT(driver);
  56.     tap_key(key_leader);
  58.     EXPECT_EQ(leader_sequence_active(), true);
  60.     EXPECT_REPORT(driver, (KC_2));
  61.     EXPECT_EMPTY_REPORT(driver);
  62.     tap_key(key_a);
  63.     tap_key(key_b);
  65.     EXPECT_EQ(leader_sequence_timed_out(), false);
  67.     idle_for(300);
  69.     EXPECT_EQ(leader_sequence_active(), false);
  70.     EXPECT_EQ(leader_sequence_timed_out(), true);
  72.     EXPECT_REPORT(driver, (KC_A));
  73.     EXPECT_EMPTY_REPORT(driver);
  74.     tap_key(key_a);
  75. }
  77. TEST_F(Leader, triggers_three_key_sequence) {
  78.     TestDriver driver;
  80.     auto key_leader = KeymapKey(0, 0, 0, QK_LEADER);
  81.     auto key_a      = KeymapKey(0, 1, 0, KC_A);
  82.     auto key_b      = KeymapKey(0, 2, 0, KC_B);
  83.     auto key_c      = KeymapKey(0, 3, 0, KC_C);
  85.     set_keymap({key_leader, key_a, key_b, key_c});
  87.     EXPECT_EQ(leader_sequence_active(), false);
  89.     EXPECT_NO_REPORT(driver);
  90.     tap_key(key_leader);
  92.     EXPECT_EQ(leader_sequence_active(), true);
  94.     EXPECT_REPORT(driver, (KC_3));
  95.     EXPECT_EMPTY_REPORT(driver);
  96.     tap_key(key_a);
  97.     tap_key(key_b);
  98.     tap_key(key_c);
  100.     EXPECT_EQ(leader_sequence_timed_out(), false);
  102.     idle_for(300);
  104.     EXPECT_EQ(leader_sequence_active(), false);
  105.     EXPECT_EQ(leader_sequence_timed_out(), true);
  107.     EXPECT_REPORT(driver, (KC_A));
  108.     EXPECT_EMPTY_REPORT(driver);
  109.     tap_key(key_a);
  110. }
  112. TEST_F(Leader, triggers_four_key_sequence) {
  113.     TestDriver driver;
  115.     auto key_leader = KeymapKey(0, 0, 0, QK_LEADER);
  116.     auto key_a      = KeymapKey(0, 1, 0, KC_A);
  117.     auto key_b      = KeymapKey(0, 2, 0, KC_B);
  118.     auto key_c      = KeymapKey(0, 3, 0, KC_C);
  119.     auto key_d      = KeymapKey(0, 4, 0, KC_D);
  121.     set_keymap({key_leader, key_a, key_b, key_c, key_d});
  123.     EXPECT_EQ(leader_sequence_active(), false);
  125.     EXPECT_NO_REPORT(driver);
  126.     tap_key(key_leader);
  128.     EXPECT_EQ(leader_sequence_active(), true);
  130.     EXPECT_REPORT(driver, (KC_4));
  131.     EXPECT_EMPTY_REPORT(driver);
  132.     tap_key(key_a);
  133.     tap_key(key_b);
  134.     tap_key(key_c);
  135.     tap_key(key_d);
  137.     EXPECT_EQ(leader_sequence_timed_out(), false);
  139.     idle_for(300);
  141.     EXPECT_EQ(leader_sequence_active(), false);
  142.     EXPECT_EQ(leader_sequence_timed_out(), true);
  144.     EXPECT_REPORT(driver, (KC_A));
  145.     EXPECT_EMPTY_REPORT(driver);
  146.     tap_key(key_a);
  147. }
  149. TEST_F(Leader, triggers_five_key_sequence) {
  150.     TestDriver driver;
  152.     auto key_leader = KeymapKey(0, 0, 0, QK_LEADER);
  153.     auto key_a      = KeymapKey(0, 1, 0, KC_A);
  154.     auto key_b      = KeymapKey(0, 2, 0, KC_B);
  155.     auto key_c      = KeymapKey(0, 3, 0, KC_C);
  156.     auto key_d      = KeymapKey(0, 4, 0, KC_D);
  157.     auto key_e      = KeymapKey(0, 5, 0, KC_E);
  159.     set_keymap({key_leader, key_a, key_b, key_c, key_d, key_e});
  161.     EXPECT_EQ(leader_sequence_active(), false);
  163.     EXPECT_NO_REPORT(driver);
  164.     tap_key(key_leader);
  166.     EXPECT_EQ(leader_sequence_active(), true);
  168.     EXPECT_REPORT(driver, (KC_5));
  169.     EXPECT_EMPTY_REPORT(driver);
  170.     tap_key(key_a);
  171.     tap_key(key_b);
  172.     tap_key(key_c);
  173.     tap_key(key_d);
  174.     tap_key(key_e);
  176.     EXPECT_EQ(leader_sequence_timed_out(), false);
  178.     idle_for(300);
  180.     EXPECT_EQ(leader_sequence_active(), false);
  181.     EXPECT_EQ(leader_sequence_timed_out(), true);
  183.     EXPECT_REPORT(driver, (KC_A));
  184.     EXPECT_EMPTY_REPORT(driver);
  185.     tap_key(key_a);
  186. }
  188. TEST_F(Leader, extracts_mod_tap_keycode) {
  189.     TestDriver driver;
  191.     auto key_leader = KeymapKey(0, 0, 0, QK_LEADER);
  192.     auto key_mt     = KeymapKey(0, 1, 0, LSFT_T(KC_A));
  194.     set_keymap({key_leader, key_mt});
  196.     tap_key(key_leader);
  198.     EXPECT_REPORT(driver, (KC_1));
  199.     EXPECT_EMPTY_REPORT(driver);
  200.     tap_key(key_mt);
  202.     EXPECT_EQ(leader_sequence_one_key(KC_A), true);
  204.     idle_for(300);
  205. }
  207. TEST_F(Leader, extracts_layer_tap_keycode) {
  208.     TestDriver driver;
  210.     auto key_leader = KeymapKey(0, 0, 0, QK_LEADER);
  211.     auto key_lt     = KeymapKey(0, 1, 0, LT(1, KC_A));
  213.     set_keymap({key_leader, key_lt});
  215.     tap_key(key_leader);
  217.     EXPECT_REPORT(driver, (KC_1));
  218.     EXPECT_EMPTY_REPORT(driver);
  219.     tap_key(key_lt);
  221.     EXPECT_EQ(leader_sequence_one_key(KC_A), true);
  223.     idle_for(300);
  224. }