hailey
/
qmk_firmware
mirror of https://github.com/hailey/qmk_firmware.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into develop

Browse Source
develop
QMK Bot 3 years ago
parent 08c556b78b 95d20e6d8b
commit d6402fe9fb
28 changed files with 683 additions and 298 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 1
      quantum/process_keycode/process_unicode_common.c
  2. 6
      quantum/quantum.c
  3. 16
      tests/auto_shift/test_auto_shift.cpp
  4. 54
      tests/basic/test_action_layer.cpp
  5. 96
      tests/basic/test_keypress.cpp
  6. 36
      tests/basic/test_one_shot_keys.cpp
  7. 34
      tests/basic/test_tapping.cpp
  8. 22
      tests/caps_word/caps_word_autoshift/config.h
  9. 18
      tests/caps_word/caps_word_autoshift/test.mk
  10. 101
      tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp
  11. 20
      tests/caps_word/caps_word_unicodemap/config.h
  12. 18
      tests/caps_word/caps_word_unicodemap/test.mk
  13. 121
      tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp
  14. 68
      tests/caps_word/test_caps_word.cpp
  15. 81
      tests/secure/test_secure.cpp
  16. 66
      tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp
  17. 18
      tests/tap_hold_configurations/ignore_mod_tap_interrupt/test_tap_hold.cpp
  18. 6
      tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp
  19. 16
      tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp
  20. 16
      tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test_tap_hold.cpp
  21. 4
      tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp
  22. 10
      tests/tap_hold_configurations/retro_tapping/test_tapping.cpp
  23. 4
      tests/tap_hold_configurations/tapping_force_hold/test_action_layer.cpp
  24. 26
      tests/tap_hold_configurations/tapping_force_hold/test_tap_hold.cpp
  25. 35
      tests/test_common/test_driver.cpp
  26. 62
      tests/test_common/test_driver.hpp
  27. 9
      tests/test_common/test_fixture.cpp
  28. 17
      tests/test_common/test_fixture.hpp

1
quantum/process_keycode/process_unicode_common.c
Unescape View File

@ -95,6 +95,7 @@ __attribute__((weak)) void unicode_input_start(void) {
unicode_saved_mods = get_mods(); // Save current mods
clear_mods(); // Unregister mods to start from a clean state
clear_weak_mods();
switch (unicode_config.input_mode) {
case UC_MAC:

6
quantum/quantum.c
Unescape View File

@ -289,6 +289,9 @@ bool process_record_quantum(keyrecord_t *record) {
#ifdef TAP_DANCE_ENABLE
process_tap_dance(keycode, record) &&
#endif
#ifdef CAPS_WORD_ENABLE
process_caps_word(keycode, record) &&
#endif
#if defined(UNICODE_COMMON_ENABLE)
process_unicode_common(keycode, record) &&
#endif
@ -304,9 +307,6 @@ bool process_record_quantum(keyrecord_t *record) {
#ifdef DYNAMIC_TAPPING_TERM_ENABLE
process_dynamic_tapping_term(keycode, record) &&
#endif
#ifdef CAPS_WORD_ENABLE
process_caps_word(keycode, record) &&
#endif
#ifdef SPACE_CADET_ENABLE
process_space_cadet(keycode, record) &&
#endif

16
tests/auto_shift/test_auto_shift.cpp
Unescape View File

@ -34,14 +34,14 @@ TEST_F(AutoShift, key_release_before_timeout) {
set_keymap({regular_key});
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_A)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (KC_A));
EXPECT_EMPTY_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -55,16 +55,16 @@ TEST_F(AutoShift, key_release_after_timeout) {
set_keymap({regular_key});
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
idle_for(AUTO_SHIFT_TIMEOUT);
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT, KC_A)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (KC_LSFT, KC_A));
EXPECT_REPORT(driver, (KC_LSFT));
EXPECT_EMPTY_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
}
}

54
tests/basic/test_action_layer.cpp
Unescape View File

@ -131,12 +131,12 @@ TEST_F(ActionLayer, MomentaryLayerDoesNothing) {
set_keymap({layer_key});
/* Press and release MO, nothing should happen. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -151,28 +151,28 @@ TEST_F(ActionLayer, MomentaryLayerWithKeypress) {
set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
/* Press MO. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.press();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press key on layer 1 */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_B))).Times(1);
EXPECT_REPORT(driver, (KC_B)).Times(1);
regular_key.press();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release key on layer 1 */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
EXPECT_EMPTY_REPORT(driver);
regular_key.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release MO */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(0));
@ -188,14 +188,14 @@ TEST_F(ActionLayer, ToggleLayerDoesNothing) {
set_keymap({layer_key});
/* Press TG. Layer state should not change as it's applied on release. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.press();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release TG. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
@ -212,26 +212,26 @@ TEST_F(ActionLayer, ToggleLayerUpAndDown) {
set_keymap({toggle_layer_1_on_layer_0, toggle_layer_0_on_layer_1});
/* Toggle Layer 1. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
toggle_layer_1_on_layer_0.press();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
toggle_layer_1_on_layer_0.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
/* Toggle Layer 0. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
toggle_layer_0_on_layer_1.press();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(0));
testing::Mock::VerifyAndClearExpectations(&driver);
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
toggle_layer_0_on_layer_1.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(0));
@ -247,13 +247,13 @@ TEST_F(ActionLayer, LayerTapToggleDoesNothing) {
set_keymap({layer_key});
/* Press and release TT. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.press();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(0));
@ -271,25 +271,25 @@ TEST_F(ActionLayer, LayerTapToggleWithKeypress) {
set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
/* Press TT. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.press();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_B))).Times(1);
EXPECT_REPORT(driver, (KC_B)).Times(1);
regular_key.press();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
EXPECT_EMPTY_REPORT(driver);
regular_key.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(0));
@ -307,7 +307,7 @@ TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) {
set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
/* Tap TT five times . */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.press();
run_one_scan_loop();
@ -346,13 +346,13 @@ TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) {
testing::Mock::VerifyAndClearExpectations(&driver);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_B))).Times(1);
EXPECT_REPORT(driver, (KC_B)).Times(1);
regular_key.press();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
EXPECT_EMPTY_REPORT(driver);
regular_key.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
@ -370,7 +370,7 @@ TEST_F(ActionLayer, LayerTapReleasedBeforeKeypressReleaseWithModifiers) {
set_keymap({layer_0_key_0, layer_1_key_1});
/* Press layer tap and wait for tapping term to switch to layer 1 */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
EXPECT_NO_REPORT(driver);
layer_0_key_0.press();
idle_for(TAPPING_TERM);
EXPECT_TRUE(layer_state_is(0));
@ -378,23 +378,23 @@ TEST_F(ActionLayer, LayerTapReleasedBeforeKeypressReleaseWithModifiers) {
/* Press key with layer 1 mapping, result basically expected
* altough more reports are send then necessary. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_RALT))).Times(1);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_RALT, KC_9))).Times(1);
EXPECT_REPORT(driver, (KC_RALT)).Times(1);
EXPECT_REPORT(driver, (KC_RALT, KC_9)).Times(1);
layer_1_key_1.press();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(1));
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release layer tap key, no report is send because key is still held. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_0_key_0.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(0));
testing::Mock::VerifyAndClearExpectations(&driver);
/* Unregister keycode and modifier. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_RALT))).Times(1);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
EXPECT_REPORT(driver, (KC_RALT)).Times(1);
EXPECT_EMPTY_REPORT(driver);
layer_1_key_1.release();
run_one_scan_loop();
EXPECT_TRUE(layer_state_is(0));

96
tests/basic/test_keypress.cpp
Unescape View File

@ -24,7 +24,7 @@ class KeyPress : public TestFixture {};
TEST_F(KeyPress, SendKeyboardIsNotCalledWhenNoKeyIsPressed) {
TestDriver driver;
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
keyboard_task();
}
@ -35,11 +35,11 @@ TEST_F(KeyPress, CorrectKeyIsReportedWhenPressed) {
set_keymap({key});
key.press();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key.report_code)));
EXPECT_REPORT(driver, (key.report_code));
keyboard_task();
key.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
keyboard_task();
}
@ -50,7 +50,7 @@ TEST_F(KeyPress, ANonMappedKeyDoesNothing) {
set_keymap({key});
key.press();
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
keyboard_task();
keyboard_task();
}
@ -66,19 +66,19 @@ TEST_F(KeyPress, CorrectKeysAreReportedWhenTwoKeysArePressed) {
key_c.press();
// Note that QMK only processes one key at a time
// See issue #1476 for more information
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_b.report_code)));
EXPECT_REPORT(driver, (key_b.report_code));
keyboard_task();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_b.report_code, key_c.report_code)));
EXPECT_REPORT(driver, (key_b.report_code, key_c.report_code));
keyboard_task();
key_b.release();
key_c.release();
// Note that the first key released is the first one in the matrix order
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_c.report_code)));
EXPECT_REPORT(driver, (key_c.report_code));
keyboard_task();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
keyboard_task();
}
@ -94,17 +94,17 @@ TEST_F(KeyPress, LeftShiftIsReportedCorrectly) {
// Unfortunately modifiers are also processed in the wrong order
// See issue #1476 for more information
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_a.report_code)));
EXPECT_REPORT(driver, (key_a.report_code));
keyboard_task();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_a.report_code, key_lsft.report_code)));
EXPECT_REPORT(driver, (key_a.report_code, key_lsft.report_code));
keyboard_task();
key_a.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_lsft.report_code)));
EXPECT_REPORT(driver, (key_lsft.report_code));
keyboard_task();
key_lsft.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
keyboard_task();
}
@ -120,19 +120,19 @@ TEST_F(KeyPress, PressLeftShiftAndControl) {
// Unfortunately modifiers are also processed in the wrong order
// See issue #1476 for more information
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_lsft.report_code)));
EXPECT_REPORT(driver, (key_lsft.report_code));
keyboard_task();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_lsft.report_code, key_lctrl.report_code)));
EXPECT_REPORT(driver, (key_lsft.report_code, key_lctrl.report_code));
keyboard_task();
key_lsft.release();
key_lctrl.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_lctrl.report_code)));
EXPECT_REPORT(driver, (key_lctrl.report_code));
keyboard_task();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
keyboard_task();
}
@ -147,19 +147,19 @@ TEST_F(KeyPress, LeftAndRightShiftCanBePressedAtTheSameTime) {
key_rsft.press();
// Unfortunately modifiers are also processed in the wrong order
// See issue #1476 for more information
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_lsft.report_code)));
EXPECT_REPORT(driver, (key_lsft.report_code));
keyboard_task();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_lsft.report_code, key_rsft.report_code)));
EXPECT_REPORT(driver, (key_lsft.report_code, key_rsft.report_code));
keyboard_task();
key_lsft.release();
key_rsft.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_rsft.report_code)));
EXPECT_REPORT(driver, (key_rsft.report_code));
keyboard_task();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
keyboard_task();
}
@ -175,13 +175,13 @@ TEST_F(KeyPress, RightShiftLeftControlAndCharWithTheSameKey) {
// The underlying cause is that we use only one bit to represent the right hand
// modifiers.
combo_key.press();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_RIGHT_SHIFT, KC_RIGHT_CTRL)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_RIGHT_SHIFT, KC_RIGHT_CTRL, KC_O)));
EXPECT_REPORT(driver, (KC_RIGHT_SHIFT, KC_RIGHT_CTRL));
EXPECT_REPORT(driver, (KC_RIGHT_SHIFT, KC_RIGHT_CTRL, KC_O));
keyboard_task();
combo_key.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_RIGHT_SHIFT, KC_RIGHT_CTRL)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (KC_RIGHT_SHIFT, KC_RIGHT_CTRL));
EXPECT_EMPTY_REPORT(driver);
keyboard_task();
}
@ -194,24 +194,24 @@ TEST_F(KeyPress, PressPlusEqualReleaseBeforePress) {
set_keymap({key_plus, key_eql});
key_plus.press();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT, KC_EQUAL)));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL));
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_plus.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
EXPECT_EMPTY_REPORT(driver);
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_eql.press();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_eql.report_code)));
EXPECT_REPORT(driver, (key_eql.report_code));
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_eql.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
}
@ -225,25 +225,25 @@ TEST_F(KeyPress, PressPlusEqualDontReleaseBeforePress) {
set_keymap({key_plus, key_eql});
key_plus.press();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT, KC_EQUAL)));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL));
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_eql.press();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_EQUAL)));
EXPECT_EMPTY_REPORT(driver);
EXPECT_REPORT(driver, (KC_EQUAL));
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_plus.release();
// BUG: Should really still return KC_EQUAL, but this is fine too
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
EXPECT_EMPTY_REPORT(driver);
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_eql.release();
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
}
@ -257,24 +257,24 @@ TEST_F(KeyPress, PressEqualPlusReleaseBeforePress) {
set_keymap({key_plus, key_eql});
key_eql.press();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_EQUAL)));
EXPECT_REPORT(driver, (KC_EQUAL));
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_eql.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_plus.press();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT, KC_EQUAL)));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL));
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_plus.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
EXPECT_EMPTY_REPORT(driver);
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
}
@ -288,27 +288,27 @@ TEST_F(KeyPress, PressEqualPlusDontReleaseBeforePress) {
set_keymap({key_plus, key_eql});
key_eql.press();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_EQUAL)));
EXPECT_REPORT(driver, (KC_EQUAL));
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_plus.press();
// BUG: The sequence is a bit strange, but it works, the end result is that
// KC_PLUS is sent
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT, KC_EQUAL)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT, KC_EQUAL)));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL));
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_eql.release();
// I guess it's fine to still report shift here
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT)));
EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
key_plus.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
}

36
tests/basic/test_one_shot_keys.cpp
Unescape View File

@ -31,7 +31,7 @@ TEST_F(OneShot, OSMWithoutAdditionalKeypressDoesNothing) {
set_keymap({osm_key});
/* Press and release OSM key*/
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
osm_key.press();
run_one_scan_loop();
osm_key.release();
@ -39,7 +39,7 @@ TEST_F(OneShot, OSMWithoutAdditionalKeypressDoesNothing) {
testing::Mock::VerifyAndClearExpectations(&driver);
/* OSM are added when an actual report is send */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(osm_key.report_code)));
EXPECT_REPORT(driver, (osm_key.report_code));
send_keyboard_report();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -57,7 +57,7 @@ TEST_P(OneShotParametrizedTestFixture, OSMExpiredDoesNothing) {
set_keymap({osm_key, regular_key});
/* Press and release OSM */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
osm_key.press();
run_one_scan_loop();
osm_key.release();
@ -65,13 +65,13 @@ TEST_P(OneShotParametrizedTestFixture, OSMExpiredDoesNothing) {
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(regular_key.report_code))).Times(1);
EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -87,7 +87,7 @@ TEST_P(OneShotParametrizedTestFixture, OSMWithAdditionalKeypress) {
set_keymap({osm_key, regular_key});
/* Press and release OSM */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
osm_key.press();
run_one_scan_loop();
osm_key.release();
@ -95,13 +95,13 @@ TEST_P(OneShotParametrizedTestFixture, OSMWithAdditionalKeypress) {
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(osm_key.report_code, regular_key.report_code))).Times(1);
EXPECT_REPORT(driver, (osm_key.report_code, regular_key.report_code)).Times(1);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -117,26 +117,26 @@ TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypres
set_keymap({osm_key, regular_key});
/* Press OSM */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
osm_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release OSM */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(regular_key.report_code, osm_key.report_code))).Times(1);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
EXPECT_REPORT(driver, (regular_key.report_code, osm_key.report_code)).Times(1);
EXPECT_EMPTY_REPORT(driver);
osm_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -169,26 +169,26 @@ TEST_F(OneShot, OSLWithAdditionalKeypress) {
set_keymap({osl_key, regular_key});
/* Press OSL key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
osl_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release OSL key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
osl_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(regular_key.report_code))).Times(1);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
EXPECT_EMPTY_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);

34
tests/basic/test_tapping.cpp
Unescape View File

@ -34,15 +34,15 @@ TEST_F(Tapping, TapA_SHFT_T_KeyReportsKey) {
// Tapping keys does nothing on press
key_shift_hold_p_tap.press();
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
run_one_scan_loop();
// First we get the key press
key_shift_hold_p_tap.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_REPORT(driver, (KC_P));
// Then the release
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
run_one_scan_loop();
}
@ -56,13 +56,13 @@ TEST_F(Tapping, HoldA_SHFT_T_KeyReportsShift) {
mod_tap_hold_key.press();
// Tapping keys does nothing on press
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
idle_for(TAPPING_TERM);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT)));
EXPECT_REPORT(driver, (KC_LSFT));
run_one_scan_loop();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
mod_tap_hold_key.release();
run_one_scan_loop();
}
@ -77,36 +77,36 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) {
// Tapping keys does nothing on press
key_shift_hold_p_tap.press();
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
run_one_scan_loop();
key_shift_hold_p_tap.release();
// First we get the key press
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_REPORT(driver, (KC_P));
// Then the release
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
run_one_scan_loop();
// This sends KC_P, even if it should do nothing
key_shift_hold_p_tap.press();
// This test should not succed if everything works correctly
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_REPORT(driver, (KC_P));
run_one_scan_loop();
key_shift_hold_p_tap.release();
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
idle_for(TAPPING_TERM + 1);
// On the other hand, nothing is sent if we are outside the tapping term
key_shift_hold_p_tap.press();
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
run_one_scan_loop();
key_shift_hold_p_tap.release();
// First we get the key press
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_REPORT(driver, (KC_P));
// Then the release
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
idle_for(TAPPING_TERM + 1);
// Now we are geting into strange territory, as the hold registers too early here
@ -114,10 +114,10 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) {
// If TAPPING_TERM + 1 above is changed to TAPPING_TERM or TAPPING_TERM + 2 it doesn't
key_shift_hold_p_tap.press();
// Shouldn't be called here really
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LEFT_SHIFT))).Times(1);
EXPECT_REPORT(driver, (KC_LEFT_SHIFT)).Times(1);
idle_for(TAPPING_TERM);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
key_shift_hold_p_tap.release();
run_one_scan_loop();
}
}

22
tests/caps_word/caps_word_autoshift/config.h
Unescape View File

@ -0,0 +1,22 @@
// Copyright 2022 Google LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "test_common.h"
#define TAPPING_TERM 200
#define AUTO_SHIFT_TIMEOUT 150
#define RETRO_SHIFT 500

18
tests/caps_word/caps_word_autoshift/test.mk
Unescape View File

@ -0,0 +1,18 @@
# Copyright 2022 Google LLC
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
CAPS_WORD_ENABLE = yes
AUTO_SHIFT_ENABLE = yes

101
tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp
Unescape View File

@ -0,0 +1,101 @@
// Copyright 2022 Google LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "keyboard_report_util.hpp"
#include "keycode.h"
#include "test_common.hpp"
#include "test_fixture.hpp"
#include "test_keymap_key.hpp"
using ::testing::_;
using ::testing::AnyNumber;
using ::testing::AnyOf;
using ::testing::InSequence;
class CapsWord : public TestFixture {
public:
void SetUp() override {
caps_word_off();
}
};
// Tests that with Auto Shift, letter keys are shifted by Caps Word
// regardless of whether they are released before AUTO_SHIFT_TIMEOUT.
TEST_F(CapsWord, AutoShiftKeys) {
TestDriver driver;
KeymapKey key_a(0, 0, 0, KC_A);
KeymapKey key_spc(0, 1, 0, KC_SPC);
set_keymap({key_a, key_spc});
// Allow any number of reports with no keys or only KC_LSFT.
// clang-format off
EXPECT_CALL(driver, send_keyboard_mock(AnyOf(
KeyboardReport(),
KeyboardReport(KC_LSFT))))
.Times(AnyNumber());
// clang-format on
{ // Expect: "A, A, space, a".
InSequence s;
EXPECT_REPORT(driver, (KC_LSFT, KC_A));
EXPECT_REPORT(driver, (KC_LSFT, KC_A));
EXPECT_REPORT(driver, (KC_SPC));
EXPECT_REPORT(driver, (KC_A));
}
// Turn on Caps Word and type "A (quick tap), A (long press), space, A".
caps_word_on();
tap_key(key_a); // Tap A quickly.
tap_key(key_a, AUTO_SHIFT_TIMEOUT + 1); // Long press A.
tap_key(key_spc);
tap_key(key_a);
testing::Mock::VerifyAndClearExpectations(&driver);
}
// Tests that with tap-hold keys with Retro Shift, letter keys are shifted by
// Caps Word regardless of whether they are retroshifted.
TEST_F(CapsWord, RetroShiftKeys) {
TestDriver driver;
KeymapKey key_modtap_a(0, 0, 0, LCTL_T(KC_A));
KeymapKey key_layertap_b(0, 1, 0, LT(1, KC_B));
set_keymap({key_modtap_a, key_layertap_b});
// Allow any number of reports with no keys or only KC_LSFT.
// clang-format off
EXPECT_CALL(driver, send_keyboard_mock(AnyOf(
KeyboardReport(),
KeyboardReport(KC_LSFT))))
.Times(AnyNumber());
// clang-format on
{ // Expect: "B, A, B, A".
InSequence s;
EXPECT_REPORT(driver, (KC_LSFT, KC_B));
EXPECT_REPORT(driver, (KC_LSFT, KC_A));
EXPECT_REPORT(driver, (KC_LSFT, KC_B));
EXPECT_REPORT(driver, (KC_LSFT, KC_A));
}
// Turn on Caps Word and type "B, A (long press), B (long press), A".
caps_word_on();
tap_key(key_layertap_b); // Tap B quickly.
tap_key(key_modtap_a, TAPPING_TERM + 1); // Long press A.
tap_key(key_layertap_b, TAPPING_TERM + 1); // Long press B.
tap_key(key_modtap_a); // Tap A quickly.
EXPECT_EQ(is_caps_word_on(), true);
testing::Mock::VerifyAndClearExpectations(&driver);
}

20
tests/caps_word/caps_word_unicodemap/config.h
Unescape View File

@ -0,0 +1,20 @@
// Copyright 2022 Google LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "test_common.h"
#define UNICODE_SELECTED_MODES UC_LNX

18
tests/caps_word/caps_word_unicodemap/test.mk
Unescape View File

@ -0,0 +1,18 @@
# Copyright 2022 Google LLC
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
CAPS_WORD_ENABLE = yes
UNICODEMAP_ENABLE = yes

121
tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp
Unescape View File

@ -0,0 +1,121 @@
// Copyright 2022 Google LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "keyboard_report_util.hpp"
#include "keycode.h"
#include "test_common.hpp"
#include "test_fixture.hpp"
#include "test_keymap_key.hpp"
using ::testing::_;
using ::testing::AnyNumber;
using ::testing::AnyOf;
using ::testing::InSequence;
extern "C" {
enum unicode_names {
ENDASH,
EMDASH,
DELTA_LOWERCASE,
DELTA_UPPERCASE,
};
const uint32_t unicode_map[] PROGMEM = {
[ENDASH] = 0x2013,
[EMDASH] = 0x2014,
[DELTA_LOWERCASE] = 0x03b4,
[DELTA_UPPERCASE] = 0x0394,
};
#define U_DASH XP(ENDASH, EMDASH)
#define U_DELTA XP(DELTA_LOWERCASE, DELTA_UPPERCASE)
bool caps_word_press_user(uint16_t keycode) {
switch (keycode) {
// Keycodes that continue Caps Word, with shift applied.
case U_DELTA:
add_weak_mods(MOD_BIT(KC_LSFT)); // Apply shift to next key.
return true;
// Keycodes that continue Caps Word, without shifting.
case U_DASH:
return true;
default:
return false; // Deactivate Caps Word.
}
}
} // extern "C"
class CapsWord : public TestFixture {
public:
void SetUp() override {
caps_word_off();
}
};
// Tests that typing U_DELTA while Caps Word is on sends the uppercase Delta.
TEST_F(CapsWord, ShiftedUnicodeMapKey) {
TestDriver driver;
KeymapKey key_delta(0, 0, 0, U_DELTA);
KeymapKey key_spc(0, 1, 0, KC_SPC);
set_keymap({key_delta, key_spc});
// Allow any number of reports with no keys or only KC_LSFT and KC_LCTL.
// clang-format off
EXPECT_CALL(driver, send_keyboard_mock(AnyOf(
KeyboardReport(),
KeyboardReport(KC_LSFT),
KeyboardReport(KC_LCTL, KC_LSFT))))
.Times(AnyNumber());
// clang-format on
{ // Expect: "Uppercase Delta, space, lowercase delta".
InSequence s;
EXPECT_UNICODE(driver, unicode_map[DELTA_UPPERCASE]);
EXPECT_REPORT(driver, (KC_SPC));
EXPECT_UNICODE(driver, unicode_map[DELTA_LOWERCASE]);
}
// Turn on Caps Word and tap "delta, space, delta".
caps_word_on();
tap_keys(key_delta, key_spc, key_delta);
EXPECT_EQ(is_caps_word_on(), false);
testing::Mock::VerifyAndClearExpectations(&driver);
}
// Tests typing U_ENDASH while Caps Word is on.
TEST_F(CapsWord, UnshiftedUnicodeMapKey) {
TestDriver driver;
KeymapKey key_dash(0, 0, 0, U_DASH);
set_keymap({key_dash});
// Allow any number of reports with no keys or only KC_LSFT and KC_LCTL.
// clang-format off
EXPECT_CALL(driver, send_keyboard_mock(AnyOf(
KeyboardReport(),
KeyboardReport(KC_LSFT),
KeyboardReport(KC_LCTL, KC_LSFT))))
.Times(AnyNumber());
// clang-format on
EXPECT_UNICODE(driver, unicode_map[ENDASH]);
// Turn on Caps Word and tap U_DASH key.
caps_word_on();
tap_key(key_dash);
EXPECT_EQ(is_caps_word_on(), true);
testing::Mock::VerifyAndClearExpectations(&driver);
}

68
tests/caps_word/test_caps_word.cpp
Unescape View File

@ -30,22 +30,6 @@ class CapsWord : public TestFixture {
void SetUp() override {
caps_word_off();
}
// Convenience function to tap `key`.
void TapKey(KeymapKey key) {
key.press();
run_one_scan_loop();
key.release();
run_one_scan_loop();
}
// Taps in order each key in `keys`.
template <typename... Ts>
void TapKeys(Ts... keys) {
for (KeymapKey key : {keys...}) {
TapKey(key);
}
}
};
// Tests caps_word_on(), _off(), and _toggle() functions.
@ -104,12 +88,12 @@ TEST_F(CapsWord, CapswrdKey) {
set_keymap({key_capswrd});
// No keyboard reports should be sent.
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
TapKey(key_capswrd); // Tap the CAPSWRD key.
tap_key(key_capswrd); // Tap the CAPSWRD key.
EXPECT_EQ(is_caps_word_on(), true);
TapKey(key_capswrd); // Tap the CAPSWRD key again.
tap_key(key_capswrd); // Tap the CAPSWRD key again.
EXPECT_EQ(is_caps_word_on(), false);
testing::Mock::VerifyAndClearExpectations(&driver);
@ -130,11 +114,11 @@ TEST_F(CapsWord, IdleTimeout) {
// clang-format on
// Expect "Shift+A".
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT, KC_A)));
EXPECT_REPORT(driver, (KC_LSFT, KC_A));
// Turn on Caps Word and tap "A".
caps_word_on();
TapKey(key_a);
tap_key(key_a);
testing::Mock::VerifyAndClearExpectations(&driver);
@ -145,10 +129,10 @@ TEST_F(CapsWord, IdleTimeout) {
EXPECT_EQ(is_caps_word_on(), false);
EXPECT_EQ(get_mods() | get_weak_mods(), 0);
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(AnyNumber());
EXPECT_EMPTY_REPORT(driver).Times(AnyNumber());
// Expect unshifted "A".
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_A)));
TapKey(key_a);
EXPECT_REPORT(driver, (KC_A));
tap_key(key_a);
testing::Mock::VerifyAndClearExpectations(&driver);
}
@ -170,15 +154,15 @@ TEST_F(CapsWord, ShiftsLettersButNotDigits) {
{ // Expect: "Shift+A, 4, Shift+A, 4".
InSequence s;
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT, KC_A)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_4)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT, KC_A)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_4)));
EXPECT_REPORT(driver, (KC_LSFT, KC_A));
EXPECT_REPORT(driver, (KC_4));
EXPECT_REPORT(driver, (KC_LSFT, KC_A));
EXPECT_REPORT(driver, (KC_4));
}
// Turn on Caps Word and tap "A, 4, A, 4".
caps_word_on();
TapKeys(key_a, key_4, key_a, key_4);
tap_keys(key_a, key_4, key_a, key_4);
testing::Mock::VerifyAndClearExpectations(&driver);
}
@ -200,14 +184,14 @@ TEST_F(CapsWord, SpaceTurnsOffCapsWord) {
{ // Expect: "Shift+A, Space, A".
InSequence seq;
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT, KC_A)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_SPC)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_A)));
EXPECT_REPORT(driver, (KC_LSFT, KC_A));
EXPECT_REPORT(driver, (KC_SPC));
EXPECT_REPORT(driver, (KC_A));
}
// Turn on Caps Word and tap "A, Space, A".
caps_word_on();
TapKeys(key_a, key_spc, key_a);
tap_keys(key_a, key_spc, key_a);
testing::Mock::VerifyAndClearExpectations(&driver);
}
@ -226,8 +210,8 @@ TEST_F(CapsWord, ShiftsAltGrSymbols) {
KeyboardReport(KC_RALT),
KeyboardReport(KC_LSFT, KC_RALT))))
.Times(AnyNumber());
// Expect "Shift + AltGr + A, Space".
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT, KC_RALT, KC_A)));
// Expect "Shift + AltGr + A".
EXPECT_REPORT(driver, (KC_LSFT, KC_RALT, KC_A));
// clang-format on
// Turn on Caps Word and type "AltGr + A".
@ -235,7 +219,7 @@ TEST_F(CapsWord, ShiftsAltGrSymbols) {
key_altgr.press();
run_one_scan_loop();
TapKeys(key_a);
tap_key(key_a);
run_one_scan_loop();
key_altgr.release();
@ -376,9 +360,9 @@ TEST_P(CapsWordDoubleTapShift, Activation) {
EXPECT_EQ(is_caps_word_on(), false);
// Tapping shift twice within the tapping term turns on Caps Word.
TapKey(left_shift);
tap_key(left_shift);
idle_for(TAPPING_TERM - 10);
TapKey(left_shift);
tap_key(left_shift);
EXPECT_EQ(is_caps_word_on(), true);
@ -403,13 +387,13 @@ TEST_P(CapsWordDoubleTapShift, Interrupted) {
left_shift.press();
run_one_scan_loop();
TapKey(key_a); // 'A' key interrupts the double tap.
tap_key(key_a); // 'A' key interrupts the double tap.
left_shift.release();
run_one_scan_loop();
idle_for(TAPPING_TERM - 10);
TapKey(left_shift);
tap_key(left_shift);
EXPECT_EQ(is_caps_word_on(), false); // Caps Word is still off.
clear_oneshot_mods();
@ -430,9 +414,9 @@ TEST_P(CapsWordDoubleTapShift, SlowTaps) {
.Times(AnyNumber());
// clang-format on
TapKey(left_shift);
tap_key(left_shift);
idle_for(TAPPING_TERM + 1);
TapKey(left_shift);
tap_key(left_shift);
EXPECT_EQ(is_caps_word_on(), false); // Caps Word is still off.
clear_oneshot_mods();

81
tests/secure/test_secure.cpp
Unescape View File

@ -27,28 +27,13 @@ class Secure : public TestFixture {
void SetUp() override {
secure_lock();
}
// Convenience function to tap `key`.
void TapKey(KeymapKey key) {
key.press();
run_one_scan_loop();
key.release();
run_one_scan_loop();
}
// Taps in order each key in `keys`.
template <typename... Ts>
void TapKeys(Ts... keys) {
for (KeymapKey key : {keys...}) {
TapKey(key);
}
}
};
TEST_F(Secure, test_lock) {
TestDriver driver;
// Allow any number of empty reports.
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
// Don't allow empty reports.
EXPECT_NO_REPORT(driver);
EXPECT_FALSE(secure_is_unlocked());
secure_unlock();
@ -64,8 +49,8 @@ TEST_F(Secure, test_lock) {
TEST_F(Secure, test_unlock_timeout) {
TestDriver driver;
// Allow any number of empty reports.
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
// Don't allow empty reports.
EXPECT_NO_REPORT(driver);
EXPECT_FALSE(secure_is_unlocked());
secure_unlock();
@ -86,13 +71,13 @@ TEST_F(Secure, test_unlock_request) {
set_keymap({key_mo, key_a, key_b, key_c, key_d});
// Allow any number of empty reports.
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
// Don't allow empty reports.
EXPECT_NO_REPORT(driver);
EXPECT_TRUE(secure_is_locked());
secure_request_unlock();
EXPECT_TRUE(secure_is_unlocking());
TapKeys(key_a, key_b, key_c, key_d);
tap_keys(key_a, key_b, key_c, key_d);
EXPECT_TRUE(secure_is_unlocked());
testing::Mock::VerifyAndClearExpectations(&driver);
@ -109,18 +94,18 @@ TEST_F(Secure, test_unlock_request_fail) {
set_keymap({key_e, key_a, key_b, key_c, key_d});
// Allow any number of empty reports.
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(AnyNumber());
EXPECT_EMPTY_REPORT(driver).Times(AnyNumber());
{ // Expect the following reports in this order.
InSequence s;
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_A)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_B)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_C)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_D)));
EXPECT_REPORT(driver, (KC_A));
EXPECT_REPORT(driver, (KC_B));
EXPECT_REPORT(driver, (KC_C));
EXPECT_REPORT(driver, (KC_D));
}
EXPECT_TRUE(secure_is_locked());
secure_request_unlock();
EXPECT_TRUE(secure_is_unlocking());
TapKeys(key_e, key_a, key_b, key_c, key_d);
tap_keys(key_e, key_a, key_b, key_c, key_d);
EXPECT_FALSE(secure_is_unlocked());
testing::Mock::VerifyAndClearExpectations(&driver);
@ -129,8 +114,8 @@ TEST_F(Secure, test_unlock_request_fail) {
TEST_F(Secure, test_unlock_request_timeout) {
TestDriver driver;
// Allow any number of empty reports.
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
// Don't allow empty reports.
EXPECT_NO_REPORT(driver);
EXPECT_FALSE(secure_is_unlocked());
secure_request_unlock();
@ -153,16 +138,16 @@ TEST_F(Secure, test_unlock_request_fail_mid) {
set_keymap({key_e, key_a, key_b, key_c, key_d});
// Allow any number of empty reports.
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(AnyNumber());
EXPECT_EMPTY_REPORT(driver).Times(AnyNumber());
{ // Expect the following reports in this order.
InSequence s;
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_C)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_D)));
EXPECT_REPORT(driver, (KC_C));
EXPECT_REPORT(driver, (KC_D));
}
EXPECT_FALSE(secure_is_unlocked());
secure_request_unlock();
EXPECT_TRUE(secure_is_unlocking());
TapKeys(key_a, key_b, key_e, key_c, key_d);
tap_keys(key_a, key_b, key_e, key_c, key_d);
EXPECT_FALSE(secure_is_unlocking());
EXPECT_FALSE(secure_is_unlocked());
@ -180,16 +165,16 @@ TEST_F(Secure, test_unlock_request_fail_out_of_order) {
set_keymap({key_e, key_a, key_b, key_c, key_d});
// Allow any number of empty reports.
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(AnyNumber());
EXPECT_EMPTY_REPORT(driver).Times(AnyNumber());
{ // Expect the following reports in this order.
InSequence s;
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_B)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_C)));
EXPECT_REPORT(driver, (KC_B));
EXPECT_REPORT(driver, (KC_C));
}
EXPECT_FALSE(secure_is_unlocked());
secure_request_unlock();
EXPECT_TRUE(secure_is_unlocking());
TapKeys(key_a, key_d, key_b, key_c);
tap_keys(key_a, key_d, key_b, key_c);
EXPECT_TRUE(secure_is_locked());
EXPECT_FALSE(secure_is_unlocking());
EXPECT_FALSE(secure_is_unlocked());
@ -207,8 +192,8 @@ TEST_F(Secure, test_unlock_request_on_layer) {
set_keymap({key_mo, key_a, key_b, key_c, key_d});
// Allow any number of empty reports.
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
// Don't allow empty reports.
EXPECT_NO_REPORT(driver);
EXPECT_TRUE(secure_is_locked());
key_mo.press();
@ -217,7 +202,7 @@ TEST_F(Secure, test_unlock_request_on_layer) {
key_mo.release();
run_one_scan_loop();
EXPECT_TRUE(secure_is_unlocking());
TapKeys(key_a, key_b, key_c, key_d);
tap_keys(key_a, key_b, key_c, key_d);
EXPECT_TRUE(secure_is_unlocked());
EXPECT_FALSE(layer_state_is(1));
@ -234,9 +219,8 @@ TEST_F(Secure, test_unlock_request_mid_stroke) {
set_keymap({key_e, key_a, key_b, key_c, key_d});
// Allow any number of empty reports.
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_E)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (KC_E));
EXPECT_EMPTY_REPORT(driver);
EXPECT_TRUE(secure_is_locked());
key_e.press();
run_one_scan_loop();
@ -244,7 +228,7 @@ TEST_F(Secure, test_unlock_request_mid_stroke) {
key_e.release();
run_one_scan_loop();
EXPECT_TRUE(secure_is_unlocking());
TapKeys(key_a, key_b, key_c, key_d);
tap_keys(key_a, key_b, key_c, key_d);
EXPECT_TRUE(secure_is_unlocked());
testing::Mock::VerifyAndClearExpectations(&driver);
@ -260,9 +244,8 @@ TEST_F(Secure, test_unlock_request_mods) {
set_keymap({key_lsft, key_a, key_b, key_c, key_d});
// Allow any number of empty reports.
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(key_lsft.report_code)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (key_lsft.report_code));
EXPECT_EMPTY_REPORT(driver);
EXPECT_TRUE(secure_is_locked());
key_lsft.press();
run_one_scan_loop();
@ -270,7 +253,7 @@ TEST_F(Secure, test_unlock_request_mods) {
key_lsft.release();
run_one_scan_loop();
EXPECT_TRUE(secure_is_unlocking());
TapKeys(key_a, key_b, key_c, key_d);
tap_keys(key_a, key_b, key_c, key_d);
EXPECT_TRUE(secure_is_unlocked());
testing::Mock::VerifyAndClearExpectations(&driver);

66
tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp
Unescape View File

@ -35,28 +35,28 @@ TEST_F(DefaultTapHold, tap_regular_key_while_mod_tap_key_is_held) {
set_keymap({mod_tap_hold_key, regular_key});
/* Press mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P, KC_A)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (KC_P));
EXPECT_REPORT(driver, (KC_P, KC_A));
EXPECT_REPORT(driver, (KC_P));
EXPECT_EMPTY_REPORT(driver);
mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -75,28 +75,28 @@ TEST_F(DefaultTapHold, tap_mod_tap_key_while_mod_tap_key_is_held) {
set_keymap({first_mod_tap_hold_key, second_mod_tap_hold_key});
/* Press first mod-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
first_mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press second tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
second_mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release second tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
second_mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release first mod-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P, KC_A)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (KC_P));
EXPECT_REPORT(driver, (KC_P, KC_A));
EXPECT_REPORT(driver, (KC_P));
EXPECT_EMPTY_REPORT(driver);
first_mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -112,27 +112,27 @@ TEST_F(DefaultTapHold, tap_regular_key_while_layer_tap_key_is_held) {
set_keymap({layer_tap_hold_key, regular_key, layer_key});
/* Press layer-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release layer-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_A, KC_P)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_REPORT(driver, (KC_P));
EXPECT_REPORT(driver, (KC_P, KC_A));
EXPECT_REPORT(driver, (KC_P));
EXPECT_CALL(driver, send_keyboard_mock(_));
layer_tap_hold_key.release();
run_one_scan_loop();
@ -149,26 +149,26 @@ TEST_F(DefaultTapHold, tap_mod_tap_hold_key_two_times) {
set_keymap({mod_tap_hold_key});
/* Press mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (KC_P));
EXPECT_EMPTY_REPORT(driver);
mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press mod-tap-hold key again. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_REPORT(driver, (KC_P));
mod_tap_hold_key.press();
idle_for(TAPPING_TERM);
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -184,26 +184,26 @@ TEST_F(DefaultTapHold, tap_mod_tap_hold_key_twice_and_hold_on_second_time) {
set_keymap({mod_tap_hold_key});
/* Press mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_REPORT(driver, (KC_P));
EXPECT_EMPTY_REPORT(driver);
mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press mod-tap-hold key again. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_P)));
EXPECT_REPORT(driver, (KC_P));
mod_tap_hold_key.press();
idle_for(TAPPING_TERM);
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -217,14 +217,14 @@ TEST_F(DefaultTapHold, tap_and_hold_mod_tap_hold_key) {
set_keymap({mod_tap_hold_key});
/* Press mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSHIFT)));
EXPECT_REPORT(driver, (KC_LSHIFT));
mod_tap_hold_key.press();
idle_for(TAPPING_TERM + 1);
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
EXPECT_EMPTY_REPORT(driver);
mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
}
}

18
tests/tap_hold_configurations/ignore_mod_tap_interrupt/test_tap_hold.cpp
Unescape View File

@ -35,19 +35,19 @@ TEST_F(IgnoreModTapInterrupt, tap_regular_key_while_mod_tap_key_is_held) {
set_keymap({mod_tap_hold_key, regular_key});
/* Press mod-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -71,19 +71,19 @@ TEST_F(IgnoreModTapInterrupt, tap_mod_tap_key_while_mod_tap_key_is_held) {
set_keymap({first_mod_tap_hold_key, second_mod_tap_hold_key});
/* Press first mod-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
first_mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press second tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
second_mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release second tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
second_mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -108,19 +108,19 @@ TEST_F(IgnoreModTapInterrupt, tap_regular_key_while_layer_tap_key_is_held) {
set_keymap({layer_tap_hold_key, regular_key, layer_key});
/* Press layer-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);

6
tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp
Unescape View File

@ -32,13 +32,13 @@ TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypres
set_keymap({osm_key, regular_key});
/* Press OSM */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
osm_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -73,4 +73,4 @@ INSTANTIATE_TEST_CASE_P(
std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_RALT), KC_RALT}, KeymapKey{0, 1, 1, KC_A}),
std::make_pair(KeymapKey{0, 0, 0, OSM(MOD_RGUI), KC_RGUI}, KeymapKey{0, 1, 1, KC_A})
));
// clang-format on
// clang-format on

16
tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp
Unescape View File

@ -34,13 +34,13 @@ TEST_F(PermissiveHold, tap_regular_key_while_mod_tap_key_is_held) {
set_keymap({mod_tap_hold_key, regular_key});
/* Press mod-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -69,13 +69,13 @@ TEST_F(PermissiveHold, tap_mod_tap_key_while_mod_tap_key_is_held) {
set_keymap({first_mod_tap_hold_key, second_mod_tap_hold_key});
/* Press first mod-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
first_mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press second mod-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
second_mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -105,13 +105,13 @@ TEST_F(PermissiveHold, tap_regular_key_while_layer_tap_key_is_held) {
set_keymap({layer_tap_hold_key, regular_key, layer_key});
/* Press layer-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -124,8 +124,8 @@ TEST_F(PermissiveHold, tap_regular_key_while_layer_tap_key_is_held) {
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release layer-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
}
}

16
tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test_tap_hold.cpp
Unescape View File

@ -36,13 +36,13 @@ TEST_F(PermissiveHold_IgnoreModTapInterrupt, tap_regular_key_while_mod_tap_key_i
set_keymap({mod_tap_hold_key, regular_key});
/* Press mod-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -71,13 +71,13 @@ TEST_F(PermissiveHold_IgnoreModTapInterrupt, tap_mod_tap_key_while_mod_tap_key_i
set_keymap({first_mod_tap_hold_key, second_mod_tap_hold_key});
/* Press first mod-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
first_mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press second tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
second_mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -107,13 +107,13 @@ TEST_F(PermissiveHold_IgnoreModTapInterrupt, tap_regular_key_while_layer_tap_key
set_keymap({layer_tap_hold_key, regular_key, layer_key});
/* Press layer-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -126,8 +126,8 @@ TEST_F(PermissiveHold_IgnoreModTapInterrupt, tap_regular_key_while_layer_tap_key
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release layer-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
}
}

4
tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp
Unescape View File

@ -35,7 +35,7 @@ TEST_F(RetroTapping, tap_and_hold_mod_tap_hold_key) {
set_keymap({mod_tap_hold_key});
/* Press mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
idle_for(TAPPING_TERM);
testing::Mock::VerifyAndClearExpectations(&driver);
@ -49,4 +49,4 @@ TEST_F(RetroTapping, tap_and_hold_mod_tap_hold_key) {
mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
}
}

10
tests/tap_hold_configurations/retro_tapping/test_tapping.cpp
Unescape View File

@ -32,7 +32,7 @@ TEST_F(Tapping, HoldA_SHFT_T_KeyReportsShift) {
set_keymap({mod_tap_hold_key});
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
idle_for(TAPPING_TERM);
testing::Mock::VerifyAndClearExpectations(&driver);
@ -57,7 +57,7 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) {
set_keymap({key_shift_hold_p_tap});
/* Press mod_tap_hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
key_shift_hold_p_tap.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -82,7 +82,7 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) {
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press mod_tap_hold key again */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
key_shift_hold_p_tap.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -95,7 +95,7 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) {
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press mod_tap_hold key again */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
key_shift_hold_p_tap.press();
idle_for(TAPPING_TERM);
testing::Mock::VerifyAndClearExpectations(&driver);
@ -109,4 +109,4 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) {
key_shift_hold_p_tap.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
}
}

4
tests/tap_hold_configurations/tapping_force_hold/test_action_layer.cpp
Unescape View File

@ -32,7 +32,7 @@ TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) {
/* Tap TT five times . */
/* TODO: Tapping Force Hold breaks TT */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_key.press();
run_one_scan_loop();
@ -77,4 +77,4 @@ TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) {
run_one_scan_loop();
expect_layer_state(0);
testing::Mock::VerifyAndClearExpectations(&driver);
}
}

26
tests/tap_hold_configurations/tapping_force_hold/test_tap_hold.cpp
Unescape View File

@ -36,19 +36,19 @@ TEST_F(TappingForceHold, tap_regular_key_while_mod_tap_key_is_held) {
set_keymap({mod_tap_hold_key, regular_key});
/* Press mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -76,19 +76,19 @@ TEST_F(TappingForceHold, tap_mod_tap_key_while_mod_tap_key_is_held) {
set_keymap({first_mod_tap_hold_key, second_mod_tap_hold_key});
/* Press first mod-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
first_mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press second tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
second_mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release second tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
second_mod_tap_hold_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -117,19 +117,19 @@ TEST_F(TappingForceHold, tap_regular_key_while_layer_tap_key_is_held) {
set_keymap({layer_tap_hold_key, regular_key, layer_key});
/* Press layer-tap-hold key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
layer_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
/* Release regular key */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
regular_key.release();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -152,7 +152,7 @@ TEST_F(TappingForceHold, tap_mod_tap_hold_key_two_times) {
set_keymap({mod_tap_hold_key});
/* Press mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -165,7 +165,7 @@ TEST_F(TappingForceHold, tap_mod_tap_hold_key_two_times) {
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press mod-tap-hold key again. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -186,7 +186,7 @@ TEST_F(TappingForceHold, tap_mod_tap_hold_key_twice_and_hold_on_second_time) {
set_keymap({mod_tap_hold_key});
/* Press mod-tap-hold key. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
run_one_scan_loop();
testing::Mock::VerifyAndClearExpectations(&driver);
@ -199,7 +199,7 @@ TEST_F(TappingForceHold, tap_mod_tap_hold_key_twice_and_hold_on_second_time) {
testing::Mock::VerifyAndClearExpectations(&driver);
/* Press mod-tap-hold key again. */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
mod_tap_hold_key.press();
idle_for(TAPPING_TERM);
testing::Mock::VerifyAndClearExpectations(&driver);

35
tests/test_common/test_driver.cpp
Unescape View File

@ -18,6 +18,19 @@
TestDriver* TestDriver::m_this = nullptr;
namespace {
// Given a hex digit between 0 and 15, returns the corresponding keycode.
uint8_t hex_digit_to_keycode(uint8_t digit) {
// clang-format off
static const uint8_t hex_keycodes[] = {
KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
KC_8, KC_9, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F
};
// clang-format on
return hex_keycodes[digit];
}
} // namespace
TestDriver::TestDriver() : m_driver{&TestDriver::keyboard_leds, &TestDriver::send_keyboard, &TestDriver::send_mouse, &TestDriver::send_system, &TestDriver::send_consumer} {
host_set_driver(&m_driver);
m_this = this;
@ -47,3 +60,25 @@ void TestDriver::send_system(uint16_t data) {
void TestDriver::send_consumer(uint16_t data) {
m_this->send_consumer(data);
}
namespace internal {
void expect_unicode_code_point(TestDriver& driver, uint32_t code_point) {
testing::InSequence seq;
EXPECT_REPORT(driver, (KC_LCTL, KC_LSFT, KC_U));
bool print_zero = false;
for (int i = 7; i >= 0; --i) {
if (i <= 3) {
print_zero = true;
}
const uint8_t digit = (code_point >> (i * 4)) & 0xf;
if (digit || print_zero) {
EXPECT_REPORT(driver, (hex_digit_to_keycode(digit)));
print_zero = true;
}
}
EXPECT_REPORT(driver, (KC_SPC));
}
} // namespace internal

62
tests/test_common/test_driver.hpp
Unescape View File

@ -26,7 +26,9 @@ class TestDriver {
public:
TestDriver();
~TestDriver();
void set_leds(uint8_t leds) { m_leds = leds; }
void set_leds(uint8_t leds) {
m_leds = leds;
}
MOCK_METHOD1(send_keyboard_mock, void(report_keyboard_t&));
MOCK_METHOD1(send_mouse_mock, void(report_mouse_t&));
@ -43,3 +45,61 @@ class TestDriver {
uint8_t m_leds = 0;
static TestDriver* m_this;
};
/**
* @brief Sets gmock expectation that a keyboard report of `report` keys will be sent.
* For this macro to parse correctly, the `report` arg must be surrounded by
* parentheses ( ). For instance,
*
* // Expect that a report of "KC_LSFT + KC_A" is sent to the host.
* EXPECT_REPORT(driver, (KC_LSFT, KC_A));
*
* is shorthand for
*
* EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport(KC_LSFT, KC_A)));
*
* It is possible to use .Times() and other gmock APIS with EXPECT_REPORT, for instance,
* allow only single report to be sent:
*
* EXPECT_REPORT(driver, (KC_LSFT, KC_A)).Times(1);
*/
#define EXPECT_REPORT(driver, report) EXPECT_CALL((driver), send_keyboard_mock(KeyboardReport report))
/**
* @brief Sets gmock expectation that Unicode `code_point` is sent with UC_LNX input
* mode. For instance for U+2013,
*
* EXPECT_UNICODE(driver, 0x2013);
*
* expects the sequence of keys:
*
* "Ctrl+Shift+U, 2, 0, 1, 3, space".
*/
#define EXPECT_UNICODE(driver, code_point) internal::expect_unicode_code_point((driver), (code_point))
/**
* @brief Sets gmock expectation that a empty keyboard report will be sent.
* It is possible to use .Times() and other gmock APIS with EXPECT_EMPTY_REPORT, for instance,
* allow any number of empty reports with:
*
* EXPECT_EMPTY_REPORT(driver).Times(AnyNumber());
*/
#define EXPECT_EMPTY_REPORT(driver) EXPECT_REPORT(driver, ())
/**
* @brief Sets gmock expectation that a keyboard report will be sent, without matching its content.
* It is possible to use .Times() and other gmock APIS with EXPECT_ANY_REPORT, for instance,
* allow a single arbitrary report with:
*
* EXPECT_ANY_REPORT(driver).Times(1);
*/
#define EXPECT_ANY_REPORT(driver) EXPECT_CALL((driver), send_keyboard_mock(_))
/**
* @brief Sets gmock expectation that no keyboard report will be sent at all.
*/
#define EXPECT_NO_REPORT(driver) EXPECT_ANY_REPORT(driver).Times(0)
namespace internal {
void expect_unicode_code_point(TestDriver& driver, uint32_t code_point);
} // namespace internal

9
tests/test_common/test_fixture.cpp
Unescape View File

@ -82,7 +82,7 @@ TestFixture::~TestFixture() {
testing::Mock::VerifyAndClearExpectations(&driver);
/* Verify that the matrix really is cleared */
EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
EXPECT_NO_REPORT(driver);
idle_for(TAPPING_TERM * 10);
testing::Mock::VerifyAndClearExpectations(&driver);
@ -101,6 +101,13 @@ void TestFixture::add_key(KeymapKey key) {
this->keymap.push_back(key);
}
void TestFixture::tap_key(KeymapKey key, unsigned delay_ms) {
key.press();
idle_for(delay_ms);
key.release();
run_one_scan_loop();
}
void TestFixture::set_keymap(std::initializer_list<KeymapKey> keys) {
this->keymap.clear();
for (auto& key : keys) {

17
tests/test_common/test_fixture.hpp
Unescape View File

@ -36,7 +36,22 @@ class TestFixture : public testing::Test {
void add_key(const KeymapKey key);
const KeymapKey* find_key(const layer_t layer_t, const keypos_t position) const;
void get_keycode(const layer_t layer, const keypos_t position, uint16_t* result) const;
void get_keycode(const layer_t layer, const keypos_t position, uint16_t* result) const;
/**
* @brief Taps `key` with `delay_ms` delay between press and release.
*/
void tap_key(KeymapKey key, unsigned delay_ms = 1);
/**
* @brief Taps multiple KeymapKey keys in order, e.g. `tap_keys(key_a, key_b)`.
*/
template <typename... Ts>
void tap_keys(Ts... keys) {
for (KeymapKey key : {keys...}) {
tap_key(key);
}
}
void run_one_scan_loop();
void idle_for(unsigned ms);

Write Preview
Loading…
Cancel
Save