locker98/qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix layer switching from tap dances by redoing the keymap lookup (#17935)

Browse Source
This commit is contained in:
Sergey Vlasov 2022-10-03 12:48:16 +03:00 committed by GitHub
parent 0e6f191436
commit ca0c12847a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 874 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
quantum/process_keycode/process_tap_dance.c
View File

@ -115,12 +115,12 @@ static inline void process_tap_dance_action_on_dance_finished(qk_tap_dance_actio
}
}
void preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) {
bool preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) {
qk_tap_dance_action_t *action;
if (!record->event.pressed) return;
if (!record->event.pressed) return false;
if (!active_td || keycode == active_td) return;
if (!active_td || keycode == active_td) return false;
action = &tap_dance_actions[TD_INDEX(active_td)];
action->state.interrupted = true;
@ -130,6 +130,12 @@ void preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) {
// Tap dance actions can leave some weak mods active (e.g., if the tap dance is mapped to a keycode with
// modifiers), but these weak mods should not affect the keypress which interrupted the tap dance.
clear_weak_mods();
// Signal that a tap dance has been finished due to being interrupted,
// therefore the keymap lookup for the currently processed event needs to
// be repeated with the current layer state that might have been updated by
// the finished tap dance.
return true;
}
bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {

2
quantum/process_keycode/process_tap_dance.h
View File

@ -81,7 +81,7 @@ void reset_tap_dance(qk_tap_dance_state_t *state);
/* To be used internally */
void preprocess_tap_dance(uint16_t keycode, keyrecord_t *record);
bool preprocess_tap_dance(uint16_t keycode, keyrecord_t *record);
bool process_tap_dance(uint16_t keycode, keyrecord_t *record);
void tap_dance_task(void);

6
quantum/quantum.c
View File

@ -251,7 +251,11 @@ bool process_record_quantum(keyrecord_t *record) {
#endif
#ifdef TAP_DANCE_ENABLE
preprocess_tap_dance(keycode, record);
if (preprocess_tap_dance(keycode, record)) {
// The tap dance might have updated the layer state, therefore the
// result of the keycode lookup might change.
keycode = get_record_keycode(record, true);
}
#endif
if (!(

6
tests/tap_dance/tap_dance_layers/config.h Normal file
View File

@ -0,0 +1,6 @@
// Copyright 2022 Sergey Vlasov (@sigprof)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "test_common.h"

97
tests/tap_dance/tap_dance_layers/tap_dance_defs.c Normal file
View File

@ -0,0 +1,97 @@
// Copyright 2022 Sergey Vlasov (@sigprof)
// SPDX-License-Identifier: GPL-2.0-or-later
#include "quantum.h"
#include "tap_dance_defs.h"
// Implement custom keycodes which are used to check that the layer switching
// behaves properly.
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case FAST_AB:
case SLOW_AB:
if (record->event.pressed) {
tap_code(KC_A);
} else {
tap_code(KC_B);
}
return keycode == SLOW_AB;
case FAST_CD:
case SLOW_CD:
if (record->event.pressed) {
tap_code(KC_C);
} else {
tap_code(KC_D);
}
return keycode == SLOW_CD;
}
return true;
}
// Implement a custom tap dance with the following behavior:
// - single tap: KC_APP
// - single hold: MO(1)
// - double tap/hold: KC_RCTL
// (The single tap and hold actions are mostly equivalent to LT(1, KC_APP).)
enum lt_app_state {
LTA_NONE,
LTA_SINGLE_TAP,
LTA_SINGLE_HOLD,
LTA_DOUBLE_HOLD,
};
static enum lt_app_state saved_lt_app_state;
static enum lt_app_state get_lt_app_state(qk_tap_dance_state_t *state) {
if (state->count == 1) {
if (!state->pressed) {
return LTA_SINGLE_TAP;
} else {
return LTA_SINGLE_HOLD;
}
} else if (state->count == 2) {
return LTA_DOUBLE_HOLD;
} else {
return LTA_NONE;
}
}
static void lt_app_finished(qk_tap_dance_state_t *state, void *user_data) {
saved_lt_app_state = get_lt_app_state(state);
switch (saved_lt_app_state) {
case LTA_NONE:
break;
case LTA_SINGLE_TAP:
register_code(KC_APP);
break;
case LTA_SINGLE_HOLD:
layer_on(1);
break;
case LTA_DOUBLE_HOLD:
register_code(KC_RCTL);
break;
}
}
static void lt_app_reset(qk_tap_dance_state_t *state, void *user_data) {
switch (saved_lt_app_state) {
case LTA_NONE:
break;
case LTA_SINGLE_TAP:
unregister_code(KC_APP);
break;
case LTA_SINGLE_HOLD:
layer_off(1);
break;
case LTA_DOUBLE_HOLD:
unregister_code(KC_RCTL);
break;
}
}
qk_tap_dance_action_t tap_dance_actions[] = {
[TD_L_MOVE] = ACTION_TAP_DANCE_LAYER_MOVE(KC_APP, 1),
[TD_L_TOGG] = ACTION_TAP_DANCE_LAYER_TOGGLE(KC_APP, 1),
[TD_LT_APP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, lt_app_finished, lt_app_reset),
};

29
tests/tap_dance/tap_dance_layers/tap_dance_defs.h Normal file
View File

@ -0,0 +1,29 @@
// Copyright 2022 Sergey Vlasov (@sigprof)
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
enum custom_keycodes {
// (FAST|SLOW)_xy = tap KC_x on press, tap KC_y on release. For FAST_xy
// process_record_user() returns false to stop processing early; for
// SLOW_xy process_record_user() returns true, therefore all other key
// handlers are invoked.
FAST_AB = SAFE_RANGE,
FAST_CD,
SLOW_AB,
SLOW_CD,
};
enum tap_dance_ids {
TD_L_MOVE, // ACTION_TAP_DANCE_LAYER_MOVE(KC_APP, 1)
TD_L_TOGG, // ACTION_TAP_DANCE_LAYER_TOGGLE(KC_APP, 1)
TD_LT_APP, // similar to LT(1, KC_APP) with KC_RCTL on tap+hold or double tap
};
#ifdef __cplusplus
}
#endif

10
tests/tap_dance/tap_dance_layers/test.mk Normal file
View File

@ -0,0 +1,10 @@
# Copyright 2022 Sergey Vlasov (@sigprof)
# SPDX-License-Identifier: GPL-2.0-or-later
# --------------------------------------------------------------------------------
# Keep this file, even if it is empty, as a marker that this folder contains tests
# --------------------------------------------------------------------------------
TAP_DANCE_ENABLE = yes
SRC += tap_dance_defs.c

717
tests/tap_dance/tap_dance_layers/test_tap_dance_layers.cpp Normal file
View File

@ -0,0 +1,717 @@
// Copyright 2022 Sergey Vlasov (@sigprof)
// SPDX-License-Identifier: GPL-2.0-or-later
#include "keyboard_report_util.hpp"
#include "keycode.h"
#include "test_common.hpp"
#include "action_tapping.h"
#include "test_keymap_key.hpp"
#include "tap_dance_defs.h"
using testing::_;
using testing::InSequence;
struct TapDanceKeyParams {
std::string name; // Tap dance name (part of test name)
uint16_t keycode; // Tap dance keycode (TD(n))
uint16_t expect_on_tap; // Keycode for single tap
uint16_t expect_on_hold; // Keycode for single hold (may be MO(1))
uint16_t expect_on_double_tap; // Keycode for double tap (may be MO(1))
uint16_t expect_on_double_hold; // Keycode for double hold (may be MO(1))
};
struct OtherKeyLayerParams {
uint16_t keycode; // Keycode in the keymap
uint16_t expect_on_press; // Keycode to expect on press
uint16_t expect_on_release; // Keycode to expect on release (may be KC_NO if none)
};
struct OtherKeyParams {
std::string name; // Other key name (part of test name)
OtherKeyLayerParams l0; // Keycodes for layer 0
OtherKeyLayerParams l1; // Keycodes for layer 1
};
typedef std::tuple<TapDanceKeyParams, OtherKeyParams> TapDanceLayersParams;
class TapDanceLayers : public ::testing::WithParamInterface<TapDanceLayersParams>, public TestFixture {
protected:
TapDanceKeyParams tap_dance;
OtherKeyParams other_key;
std::unique_ptr<KeymapKey> key_td, key_td_l1, key_other, key_other_l1;
void SetUp() override {
std::tie(tap_dance, other_key) = GetParam();
key_td = std::make_unique<KeymapKey>(0, 1, 0, tap_dance.keycode);
key_td_l1 = std::make_unique<KeymapKey>(1, 1, 0, KC_TRNS);
key_other = std::make_unique<KeymapKey>(0, 2, 0, other_key.l0.keycode);
key_other_l1 = std::make_unique<KeymapKey>(1, 2, 0, other_key.l1.keycode);
set_keymap({*key_td, *key_td_l1, *key_other, *key_other_l1});
}
};
static const TapDanceKeyParams tap_dance_keys[] = {
TapDanceKeyParams{
"LayerMove",
TD(TD_L_MOVE),
KC_APP,
KC_APP,
MO(1),
MO(1),
},
TapDanceKeyParams{
"LayerToggle",
TD(TD_L_TOGG),
KC_APP,
KC_APP,
MO(1),
MO(1),
},
TapDanceKeyParams{
"CustomLT",
TD(TD_LT_APP),
KC_APP,
MO(1),
KC_RCTL,
KC_RCTL,
},
};
static const OtherKeyParams other_keys[] = {
OtherKeyParams{
"Builtin",
OtherKeyLayerParams{KC_A, KC_A, KC_NO},
OtherKeyLayerParams{KC_B, KC_B, KC_NO},
},
OtherKeyParams{
"CustomFast",
OtherKeyLayerParams{FAST_AB, KC_A, KC_B},
OtherKeyLayerParams{FAST_CD, KC_C, KC_D},
},
OtherKeyParams{
"CustomSlow",
OtherKeyLayerParams{SLOW_AB, KC_A, KC_B},
OtherKeyLayerParams{SLOW_CD, KC_C, KC_D},
},
};
// clang-format off
INSTANTIATE_TEST_CASE_P(
Layers,
TapDanceLayers,
::testing::Combine(
::testing::ValuesIn(tap_dance_keys),
::testing::ValuesIn(other_keys)
),
[](const ::testing::TestParamInfo<TapDanceLayersParams>& info) {
return std::get<0>(info.param).name + std::get<1>(info.param).name;
}
);
// clang-format on
// Test single tap of the tap dance key with tapping term delay after the tap.
TEST_P(TapDanceLayers, SingleTap) {
TestDriver driver;
InSequence s;
// The tap of the tap dance key does not result in sending a report
// immediately.
EXPECT_NO_REPORT(driver);
tap_key(*key_td);
// After the tapping term expires, a tap event for the single tap keycode
// is generated.
idle_for(TAPPING_TERM - 1);
EXPECT_REPORT(driver, (tap_dance.expect_on_tap));
EXPECT_EMPTY_REPORT(driver);
run_one_scan_loop();
// Pressing the other key produces the reports for the layer 0 mapping of
// that key.
EXPECT_REPORT(driver, (other_key.l0.expect_on_press));
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
}
key_other->press();
run_one_scan_loop();
// Releasing the other key produces the reports for the layer 0 mapping of
// that key.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l0.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test single tap of the tap dance key without a delay between the tap dance
// key and the other key.
TEST_P(TapDanceLayers, SingleTapFast) {
TestDriver driver;
InSequence s;
// The tap of the tap dance key does not result in sending a report
// immediately.
EXPECT_NO_REPORT(driver);
tap_key(*key_td);
// A quick press of the other key causes the tap event for the tap dance to
// be sent before the press event for the other key, and the layer 0
// mapping is used for the other key.
EXPECT_REPORT(driver, (tap_dance.expect_on_tap));
EXPECT_EMPTY_REPORT(driver);
EXPECT_REPORT(driver, (other_key.l0.expect_on_press));
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
}
key_other->press();
run_one_scan_loop();
// Releasing the other key produces the reports for the layer 0 mapping of
// that key.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l0.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test single hold of the tap dance key with tapping term delay after the hold
// (test variant for tap dances which switch the layer on hold).
TEST_P(TapDanceLayers, SingleHoldLayer) {
if (tap_dance.expect_on_hold != MO(1)) {
// Do nothing - the SingleHoldKeycode test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the hold of the tap dance key.
EXPECT_NO_REPORT(driver);
key_td->press();
run_one_scan_loop();
// After the tapping term expires, the tap dance finishes and switches the
// layer, but does not send a report.
EXPECT_NO_REPORT(driver);
idle_for(TAPPING_TERM);
run_one_scan_loop();
// Pressing the other key produces the reports for the layer 1 mapping of
// that key.
EXPECT_REPORT(driver, (other_key.l1.expect_on_press));
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
}
key_other->press();
run_one_scan_loop();
// Releasing the tap dance key does not produce a report.
EXPECT_NO_REPORT(driver);
key_td->release();
run_one_scan_loop();
// Releasing the other key produces the report for the layer 1 mapping of
// that key.
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l1.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test single hold of the tap dance key with tapping term delay after the hold
// (test variant for tap dances which send a keycode on single hold).
TEST_P(TapDanceLayers, SingleHoldKeycode) {
if (tap_dance.expect_on_hold == MO(1)) {
// Do nothing - the SingleHoldLayer test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the hold of the tap dance key.
EXPECT_NO_REPORT(driver);
key_td->press();
run_one_scan_loop();
// After the tapping term expires, the tap dance sends the report with the
// hold keycode.
EXPECT_NO_REPORT(driver);
idle_for(TAPPING_TERM);
EXPECT_REPORT(driver, (tap_dance.expect_on_hold));
run_one_scan_loop();
// Pressing the other key produces the reports for the layer 0 mapping of
// that key.
EXPECT_REPORT(driver, (tap_dance.expect_on_hold, other_key.l0.expect_on_press));
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (tap_dance.expect_on_hold));
}
key_other->press();
run_one_scan_loop();
// Releasing the tap dance key sends the release report for the
// corresponding hold keycode.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
} else {
EXPECT_REPORT(driver, (other_key.l0.expect_on_press));
}
key_td->release();
run_one_scan_loop();
// Releasing the other key produces the reports for the layer 0 mapping of
// that key.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l0.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test single hold of the tap dance key without tapping term delay after the
// hold (test variant for tap dances which switch the layer on hold).
TEST_P(TapDanceLayers, SingleHoldFastLayer) {
if (tap_dance.expect_on_hold != MO(1)) {
// Do nothing - the SingleHoldFastKeycode test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the hold of the tap dance key.
EXPECT_NO_REPORT(driver);
key_td->press();
run_one_scan_loop();
// Pressing the other key produces the reports for the layer 1 mapping of
// that key.
EXPECT_REPORT(driver, (other_key.l1.expect_on_press));
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
}
key_other->press();
run_one_scan_loop();
// Releasing the tap dance key does not produce a report.
EXPECT_NO_REPORT(driver);
key_td->release();
run_one_scan_loop();
// Releasing the other key produces the reports for the layer 1 mapping of
// that key.
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l1.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test single hold of the tap dance key without tapping term delay after the hold
// (test variant for tap dances which send a keycode on single hold).
TEST_P(TapDanceLayers, SingleHoldFastKeycode) {
if (tap_dance.expect_on_hold == MO(1)) {
// Do nothing - the SingleHoldFastLayer test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the hold of the tap dance key.
EXPECT_NO_REPORT(driver);
key_td->press();
run_one_scan_loop();
// Pressing the other key produces first the report for the tap dance hold
// keycode, and then the reports for the layer 0 mapping of the other key.
EXPECT_REPORT(driver, (tap_dance.expect_on_hold));
EXPECT_REPORT(driver, (tap_dance.expect_on_hold, other_key.l0.expect_on_press));
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (tap_dance.expect_on_hold));
}
key_other->press();
run_one_scan_loop();
// Releasing the tap dance key sends a release report for the corresponding
// hold keycode.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
} else {
EXPECT_REPORT(driver, (other_key.l0.expect_on_press));
}
key_td->release();
run_one_scan_loop();
// Releasing the other key produces the report for the layer 0 mapping of
// that key.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l0.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test double tap of the tap dance key with tapping term delay after the hold
// (test variant for tap dances which switch the layer on double tap).
TEST_P(TapDanceLayers, DoubleTapLayer) {
if (tap_dance.expect_on_double_tap != MO(1)) {
// Do nothing - the DoubleTapKeycode test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the double tap of the tap dance
// key.
EXPECT_NO_REPORT(driver);
tap_key(*key_td);
tap_key(*key_td);
// After the tapping term this tap dance does not send a report too.
EXPECT_NO_REPORT(driver);
idle_for(TAPPING_TERM);
run_one_scan_loop();
// Pressing the other key produces the reports for the layer 1 mapping of
// that key.
EXPECT_REPORT(driver, (other_key.l1.expect_on_press));
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
}
key_other->press();
run_one_scan_loop();
// Releasing the other key produces the report for the layer 1 mapping of
// that key.
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l1.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test double tap of the tap dance key with tapping term delay after the hold
// (test variant for tap dances which send a keycode on double tap).
TEST_P(TapDanceLayers, DoubleTapKeycode) {
if (tap_dance.expect_on_double_tap == MO(1)) {
// Do nothing - the DoubleTapLayer test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the double tap of the tap dance
// key.
EXPECT_NO_REPORT(driver);
tap_key(*key_td);
tap_key(*key_td);
// After the tapping term this tap dance sends the double tap keycode.
idle_for(TAPPING_TERM - 1);
EXPECT_REPORT(driver, (tap_dance.expect_on_double_tap));
EXPECT_EMPTY_REPORT(driver);
run_one_scan_loop();
// Pressing the other key produces the reports for the layer 0 mapping of
// that key.
EXPECT_REPORT(driver, (other_key.l0.expect_on_press));
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
}
key_other->press();
run_one_scan_loop();
// Releasing the other key produces the report for the layer 0 mapping of
// that key.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l0.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test double tap of the tap dance key without tapping term delay after the
// hold (test variant for tap dances which switch the layer on double tap).
TEST_P(TapDanceLayers, DoubleTapFastLayer) {
if (tap_dance.expect_on_double_tap != MO(1)) {
// Do nothing - the DoubleTapFastKeycode test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the double tap of the tap dance
// key.
EXPECT_NO_REPORT(driver);
tap_key(*key_td);
tap_key(*key_td);
// Pressing the other key produces the reports for the layer 1 mapping of
// that key.
EXPECT_REPORT(driver, (other_key.l1.expect_on_press));
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
}
key_other->press();
run_one_scan_loop();
// Releasing the other key produces the report for the layer 1 mapping of
// that key.
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l1.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test double tap of the tap dance key without tapping term delay after the
// hold (test variant for tap dances which send a keycode on double tap).
TEST_P(TapDanceLayers, DoubleTapFastKeycode) {
if (tap_dance.expect_on_double_tap == MO(1)) {
// Do nothing - the DoubleTapFastLayer test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the double tap of the tap dance
// key.
EXPECT_NO_REPORT(driver);
tap_key(*key_td);
tap_key(*key_td);
// Pressing the other key produces first the report for the tap dance
// double tap keycode, and then the reports for the layer 0 mapping of the
// other key.
EXPECT_REPORT(driver, (tap_dance.expect_on_double_tap));
EXPECT_EMPTY_REPORT(driver);
EXPECT_REPORT(driver, (other_key.l0.expect_on_press));
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
}
key_other->press();
run_one_scan_loop();
// Releasing the other key produces the report for the layer 0 mapping of
// that key.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l0.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test double hold of the tap dance key with tapping term delay after the hold
// (test variant for tap dances which switch the layer on double hold).
TEST_P(TapDanceLayers, DoubleHoldLayer) {
if (tap_dance.expect_on_double_hold != MO(1)) {
// Do nothing - the DoubleHoldKeycode test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the double hold of the tap dance
// key.
EXPECT_NO_REPORT(driver);
tap_key(*key_td);
key_td->press();
run_one_scan_loop();
// After the tapping term expires, the tap dance finishes and switches the
// layer, but does not send a report.
EXPECT_NO_REPORT(driver);
idle_for(TAPPING_TERM);
run_one_scan_loop();
// Pressing the other key produces the reports for the layer 1 mapping of
// that key.
EXPECT_REPORT(driver, (other_key.l1.expect_on_press));
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
}
key_other->press();
run_one_scan_loop();
// Releasing the tap dance key does not produce a report.
EXPECT_NO_REPORT(driver);
key_td->release();
run_one_scan_loop();
// Releasing the other key produces the report for the layer 1 mapping of
// that key.
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l1.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test double hold of the tap dance key with tapping term delay after the hold
// (test variant for tap dances which send a keycode on double hold).
TEST_P(TapDanceLayers, DoubleHoldKeycode) {
if (tap_dance.expect_on_double_hold == MO(1)) {
// Do nothing - the DoubleHoldLayer test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the double hold of the tap dance
// key.
EXPECT_NO_REPORT(driver);
tap_key(*key_td);
key_td->press();
run_one_scan_loop();
// After the tapping term expires, the tap dance sends the report with the
// double hold keycode.
EXPECT_NO_REPORT(driver);
idle_for(TAPPING_TERM);
EXPECT_REPORT(driver, (tap_dance.expect_on_double_hold));
run_one_scan_loop();
// Pressing the other key produces the reports for the layer 0 mapping of
// that key.
EXPECT_REPORT(driver, (tap_dance.expect_on_double_hold, other_key.l0.expect_on_press));
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (tap_dance.expect_on_double_hold));
}
key_other->press();
run_one_scan_loop();
// Releasing the tap dance key sends the release report for the
// corresponding double hold keycode.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
} else {
EXPECT_REPORT(driver, (other_key.l0.expect_on_press));
}
key_td->release();
run_one_scan_loop();
// Releasing the other key produces the reports for the layer 0 mapping of
// that key.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l0.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test double hold of the tap dance key without tapping term delay after the
// hold (test variant for tap dances which switch the layer on double hold).
TEST_P(TapDanceLayers, DoubleHoldFastLayer) {
if (tap_dance.expect_on_double_hold != MO(1)) {
// Do nothing - the DoubleHoldFastKeycode test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the double hold of the tap dance
// key.
EXPECT_NO_REPORT(driver);
tap_key(*key_td);
key_td->press();
run_one_scan_loop();
// Pressing the other key produces the reports for the layer 1 mapping of
// that key.
EXPECT_REPORT(driver, (other_key.l1.expect_on_press));
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
}
key_other->press();
run_one_scan_loop();
// Releasing the tap dance key does not produce a report.
EXPECT_NO_REPORT(driver);
key_td->release();
run_one_scan_loop();
// Releasing the other key produces the reports for the layer 1 mapping of
// that key.
if (other_key.l1.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l1.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}
// Test double hold of the tap dance key without tapping term delay after the hold
// (test variant for tap dances which send a keycode on double hold).
TEST_P(TapDanceLayers, DoubleHoldFastKeycode) {
if (tap_dance.expect_on_double_hold == MO(1)) {
// Do nothing - the DoubleHoldFastLayer test would run instead.
return;
}
TestDriver driver;
InSequence s;
// No report gets sent immediately after the double hold of the tap dance
// key.
EXPECT_NO_REPORT(driver);
tap_key(*key_td);
key_td->press();
run_one_scan_loop();
// Pressing the other key produces first the report for the tap dance
// double hold keycode, and then the reports for the layer 0 mapping of the
// other key.
EXPECT_REPORT(driver, (tap_dance.expect_on_double_hold));
EXPECT_REPORT(driver, (tap_dance.expect_on_double_hold, other_key.l0.expect_on_press));
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (tap_dance.expect_on_double_hold));
}
key_other->press();
run_one_scan_loop();
// Releasing the tap dance key sends a release report for the corresponding
// double hold keycode.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_EMPTY_REPORT(driver);
} else {
EXPECT_REPORT(driver, (other_key.l0.expect_on_press));
}
key_td->release();
run_one_scan_loop();
// Releasing the other key produces the report for the layer 0 mapping of
// that key.
if (other_key.l0.expect_on_release != KC_NO) {
EXPECT_REPORT(driver, (other_key.l0.expect_on_release));
}
EXPECT_EMPTY_REPORT(driver);
key_other->release();
run_one_scan_loop();
}