diff options
| author | QMK Bot <hello@qmk.fm> | 2022-06-05 11:15:11 +0200 |
|---|---|---|
| committer | QMK Bot <hello@qmk.fm> | 2022-06-05 11:15:11 +0200 |
| commit | d6402fe9fb01efae5c4952c1a3c07cd128e81eea (patch) | |
| tree | 810fef1fc2ce6c7067d5c0daa0d90a09ef94b223 | |
| parent | 08c556b78b9dc672a2aa2388bbd3fdf408e3ce98 (diff) | |
| parent | 95d20e6d8bb1ffaf3024af793daf789ee0b75727 (diff) | |
Merge remote-tracking branch 'origin/master' into develop
28 files changed, 683 insertions, 298 deletions
diff --git a/quantum/process_keycode/process_unicode_common.c b/quantum/process_keycode/process_unicode_common.c index 652becbc9a..6cb2ba8dbb 100644 --- a/quantum/process_keycode/process_unicode_common.c +++ b/quantum/process_keycode/process_unicode_common.c @@ -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: diff --git a/quantum/quantum.c b/quantum/quantum.c index 4efcc6bd8f..d1cfb5fbe0 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -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 diff --git a/tests/auto_shift/test_auto_shift.cpp b/tests/auto_shift/test_auto_shift.cpp index a19b5dfa82..a83f436c33 100644 --- a/tests/auto_shift/test_auto_shift.cpp +++ b/tests/auto_shift/test_auto_shift.cpp @@ -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); -}
\ No newline at end of file +} diff --git a/tests/basic/test_action_layer.cpp b/tests/basic/test_action_layer.cpp index fe5c729f7c..fa339a3375 100644 --- a/tests/basic/test_action_layer.cpp +++ b/tests/basic/test_action_layer.cpp @@ -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)); diff --git a/tests/basic/test_keypress.cpp b/tests/basic/test_keypress.cpp index 044fc29378..bb68ced557 100644 --- a/tests/basic/test_keypress.cpp +++ b/tests/basic/test_keypress.cpp @@ -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); } diff --git a/tests/basic/test_one_shot_keys.cpp b/tests/basic/test_one_shot_keys.cpp index 43fc3e1ba3..bb14221140 100644 --- a/tests/basic/test_one_shot_keys.cpp +++ b/tests/basic/test_one_shot_keys.cpp @@ -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); diff --git a/tests/basic/test_tapping.cpp b/tests/basic/test_tapping.cpp index e4a7e4a9f3..6ff9cfe22b 100644 --- a/tests/basic/test_tapping.cpp +++ b/tests/basic/test_tapping.cpp @@ -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(); -}
\ No newline at end of file +} diff --git a/tests/caps_word/caps_word_autoshift/config.h b/tests/caps_word/caps_word_autoshift/config.h new file mode 100644 index 0000000000..b80f53b9dd --- /dev/null +++ b/tests/caps_word/caps_word_autoshift/config.h @@ -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 diff --git a/tests/caps_word/caps_word_autoshift/test.mk b/tests/caps_word/caps_word_autoshift/test.mk new file mode 100644 index 0000000000..7f717d7fc1 --- /dev/null +++ b/tests/caps_word/caps_word_autoshift/test.mk @@ -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 + diff --git a/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp b/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp new file mode 100644 index 0000000000..deb4d95766 --- /dev/null +++ b/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp @@ -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); +} diff --git a/tests/caps_word/caps_word_unicodemap/config.h b/tests/caps_word/caps_word_unicodemap/config.h new file mode 100644 index 0000000000..89fd7924d4 --- /dev/null +++ b/tests/caps_word/caps_word_unicodemap/config.h @@ -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 diff --git a/tests/caps_word/caps_word_unicodemap/test.mk b/tests/caps_word/caps_word_unicodemap/test.mk new file mode 100644 index 0000000000..92bcba762c --- /dev/null +++ b/tests/caps_word/caps_word_unicodemap/test.mk @@ -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 + diff --git a/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp b/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp new file mode 100644 index 0000000000..fb8f9333bb --- /dev/null +++ b/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp @@ -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); +} diff --git a/tests/caps_word/test_caps_word.cpp b/tests/caps_word/test_caps_word.cpp index f611d4c104..0af4b0175d 100644 --- a/tests/caps_word/test_caps_word.cpp +++ b/tests/caps_word/test_caps_word.cpp @@ -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(); diff --git a/tests/secure/test_secure.cpp b/tests/secure/test_secure.cpp index b7c51b0bd2..6ca98d78f3 100644 --- a/tests/secure/test_secure.cpp +++ b/tests/secure/test_secure.cpp @@ -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); diff --git a/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp b/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp index 90befcdffd..ecb79c2560 100644 --- a/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp +++ b/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp @@ -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); -}
\ No newline at end of file +} diff --git a/tests/tap_hold_configurations/ignore_mod_tap_interrupt/test_tap_hold.cpp b/tests/tap_hold_configurations/ignore_mod_tap_interrupt/test_tap_hold.cpp index 1702d604d3..5ece124c1d 100644 --- a/tests/tap_hold_configurations/ignore_mod_tap_interrupt/test_tap_hold.cpp +++ b/tests/tap_hold_configurations/ignore_mod_tap_interrupt/test_tap_hold.cpp @@ -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); diff --git a/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp b/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp index aa71ec397f..64a6ff58e6 100644 --- a/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp +++ b/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp @@ -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
\ No newline at end of file +// clang-format on diff --git a/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp b/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp index 00c2b33cb7..28fb17ca66 100644 --- a/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp +++ b/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp @@ -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); -}
\ No newline at end of file +} diff --git a/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test_tap_hold.cpp b/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test_tap_hold.cpp index 67706f80dc..f2d576e875 100644 --- a/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test_tap_hold.cpp +++ b/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test_tap_hold.cpp @@ -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); -}
\ No newline at end of file +} diff --git a/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp b/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp index 59ae77f781..b3d4e520f6 100644 --- a/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp +++ b/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp @@ -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); -}
\ No newline at end of file +} diff --git a/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp b/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp index cf23df8317..cd73f1e784 100644 --- a/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp +++ b/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp @@ -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); -}
\ No newline at end of file +} diff --git a/tests/tap_hold_configurations/tapping_force_hold/test_action_layer.cpp b/tests/tap_hold_configurations/tapping_force_hold/test_action_layer.cpp index 54e7daa22c..a67c6629e0 100644 --- a/tests/tap_hold_configurations/tapping_force_hold/test_action_layer.cpp +++ b/tests/tap_hold_configurations/tapping_force_hold/test_action_layer.cpp @@ -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); -}
\ No newline at end of file +} diff --git a/tests/tap_hold_configurations/tapping_force_hold/test_tap_hold.cpp b/tests/tap_hold_configurations/tapping_force_hold/test_tap_hold.cpp index 3ae7c4ccfd..04e66a02d9 100644 --- a/tests/tap_hold_configurations/tapping_force_hold/test_tap_hold.cpp +++ b/tests/tap_hold_configurations/tapping_force_hold/test_tap_hold.cpp @@ -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); diff --git a/tests/test_common/test_driver.cpp b/tests/test_common/test_driver.cpp index 68f1dfd17d..86644ab6bd 100644 --- a/tests/test_common/test_driver.cpp +++ b/tests/test_common/test_driver.cpp @@ -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 diff --git a/tests/test_common/test_driver.hpp b/tests/test_common/test_driver.hpp index f9197b3634..b58cfd1ebc 100644 --- a/tests/test_common/test_driver.hpp +++ b/tests/test_common/test_driver.hpp @@ -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 diff --git a/tests/test_common/test_fixture.cpp b/tests/test_common/test_fixture.cpp index c98a679554..5fc6964054 100644 --- a/tests/test_common/test_fixture.cpp +++ b/tests/test_common/test_fixture.cpp @@ -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) { diff --git a/tests/test_common/test_fixture.hpp b/tests/test_common/test_fixture.hpp index 73b5d8d3e8..81906f76c7 100644 --- a/tests/test_common/test_fixture.hpp +++ b/tests/test_common/test_fixture.hpp @@ -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); |