From 48a79b08ccbcd0af5269e2e9334042c8347d18f8 Mon Sep 17 00:00:00 2001 From: Drashna Jaelre Date: Sat, 18 Feb 2023 17:08:03 -0800 Subject: [PATCH] Fix functions when `NO_ACTION_TAPPING` is defined (#11528) --- quantum/action.c | 46 +++++--- quantum/action_tapping.h | 4 +- quantum/keymap_common.c | 40 ++++++- quantum/process_keycode/process_autocorrect.c | 6 +- quantum/process_keycode/process_caps_word.c | 6 +- tests/no_tapping/no_action_tapping/config.h | 21 ++++ tests/no_tapping/no_action_tapping/test.mk | 18 +++ .../no_action_tapping/test_layer_tap.cpp | 63 +++++++++++ .../no_action_tapping/test_mod_tap.cpp | 107 ++++++++++++++++++ .../no_action_tapping/test_one_shot_keys.cpp | 105 +++++++++++++++++ tests/no_tapping/no_mod_tap_mods/config.h | 22 ++++ tests/no_tapping/no_mod_tap_mods/test.mk | 18 +++ .../no_mod_tap_mods/test_tapping.cpp | 104 +++++++++++++++++ 13 files changed, 537 insertions(+), 23 deletions(-) create mode 100644 tests/no_tapping/no_action_tapping/config.h create mode 100644 tests/no_tapping/no_action_tapping/test.mk create mode 100644 tests/no_tapping/no_action_tapping/test_layer_tap.cpp create mode 100644 tests/no_tapping/no_action_tapping/test_mod_tap.cpp create mode 100644 tests/no_tapping/no_action_tapping/test_one_shot_keys.cpp create mode 100644 tests/no_tapping/no_mod_tap_mods/config.h create mode 100644 tests/no_tapping/no_mod_tap_mods/test.mk create mode 100644 tests/no_tapping/no_mod_tap_mods/test_tapping.cpp diff --git a/quantum/action.c b/quantum/action.c index d2e54bf8ec..7d3f40a950 100644 --- a/quantum/action.c +++ b/quantum/action.c @@ -399,9 +399,9 @@ void process_action(keyrecord_t *record, action_t action) { } } } break; -#ifndef NO_ACTION_TAPPING case ACT_LMODS_TAP: case ACT_RMODS_TAP: { +#ifndef NO_ACTION_TAPPING uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ? action.key.mods : action.key.mods << 4; switch (action.layer_tap.code) { # ifndef NO_ACTION_ONESHOT @@ -523,8 +523,8 @@ void process_action(keyrecord_t *record, action_t action) { } break; } +#endif // NO_ACTION_TAPPING } break; -#endif #ifdef EXTRAKEY_ENABLE /* other HID usage */ case ACT_USAGE: @@ -537,7 +537,7 @@ void process_action(keyrecord_t *record, action_t action) { break; } break; -#endif +#endif // EXTRAKEY_ENABLE /* Mouse key */ case ACT_MOUSEKEY: register_mouse(action.key.code, event.pressed); @@ -597,10 +597,10 @@ void process_action(keyrecord_t *record, action_t action) { layer_off(action.layer_mods.layer); } break; -# ifndef NO_ACTION_TAPPING case ACT_LAYER_TAP: case ACT_LAYER_TAP_EXT: switch (action.layer_tap.code) { +# ifndef NO_ACTION_TAPPING case OP_TAP_TOGGLE: /* tap toggle */ if (event.pressed) { @@ -613,6 +613,7 @@ void process_action(keyrecord_t *record, action_t action) { } } break; +# endif case OP_ON_OFF: event.pressed ? layer_on(action.layer_tap.val) : layer_off(action.layer_tap.val); break; @@ -622,7 +623,7 @@ void process_action(keyrecord_t *record, action_t action) { case OP_SET_CLEAR: event.pressed ? layer_move(action.layer_tap.val) : layer_clear(); break; -# ifndef NO_ACTION_ONESHOT +# if !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING) case OP_ONESHOT: // Oneshot modifier if (!keymap_config.oneshot_enable) { @@ -632,7 +633,7 @@ void process_action(keyrecord_t *record, action_t action) { layer_off(action.layer_tap.val); } } else { -# if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1 +# if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1 do_release_oneshot = false; if (event.pressed) { if (get_oneshot_layer_state() == ONESHOT_TOGGLED) { @@ -651,7 +652,7 @@ void process_action(keyrecord_t *record, action_t action) { clear_oneshot_layer_state(ONESHOT_PRESSED); } } -# else +# else if (event.pressed) { layer_on(action.layer_tap.val); set_oneshot_layer(action.layer_tap.val, ONESHOT_START); @@ -661,12 +662,18 @@ void process_action(keyrecord_t *record, action_t action) { clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED); } } -# endif - } - break; # endif + } +# else // NO_ACTION_ONESHOT && NO_ACTION_TAPPING + if (event.pressed) { + layer_on(action.layer_tap.val); + } else { + layer_off(action.layer_tap.val); + } +# endif // !defined(NO_ACTION_ONESHOT) && !defined(NO_ACTION_TAPPING) + break; default: - /* tap key */ +# ifndef NO_ACTION_TAPPING /* tap key */ if (event.pressed) { if (tap_count > 0) { ac_dprintf("KEYMAP_TAP_KEY: Tap: register_code\n"); @@ -689,11 +696,24 @@ void process_action(keyrecord_t *record, action_t action) { layer_off(action.layer_tap.val); } } +# else + if (event.pressed) { + ac_dprintf("KEYMAP_TAP_KEY: Tap: register_code\n"); + register_code(action.layer_tap.code); + } else { + ac_dprintf("KEYMAP_TAP_KEY: Tap: unregister_code\n"); + if (action.layer_tap.code == KC_CAPS) { + wait_ms(TAP_HOLD_CAPS_DELAY); + } else { + wait_ms(TAP_CODE_DELAY); + } + unregister_code(action.layer_tap.code); + } +# endif break; } break; -# endif -#endif +#endif // NO_ACTION_LAYER #ifdef SWAP_HANDS_ENABLE case ACT_SWAP_HANDS: diff --git a/quantum/action_tapping.h b/quantum/action_tapping.h index c078488c04..6099d80d6d 100644 --- a/quantum/action_tapping.h +++ b/quantum/action_tapping.h @@ -51,9 +51,9 @@ bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record); extern uint16_t g_tapping_term; #endif -#ifdef TAPPING_TERM_PER_KEY +#if defined(TAPPING_TERM_PER_KEY) && !defined(NO_ACTION_TAPPING) # define GET_TAPPING_TERM(keycode, record) get_tapping_term(keycode, record) -#elif defined(DYNAMIC_TAPPING_TERM_ENABLE) +#elif defined(DYNAMIC_TAPPING_TERM_ENABLE) && !defined(NO_ACTION_TAPPING) # define GET_TAPPING_TERM(keycode, record) g_tapping_term #else # define GET_TAPPING_TERM(keycode, record) (TAPPING_TERM) diff --git a/quantum/keymap_common.c b/quantum/keymap_common.c index b4feb39739..7b863af3b5 100644 --- a/quantum/keymap_common.c +++ b/quantum/keymap_common.c @@ -80,14 +80,20 @@ action_t action_for_keycode(uint16_t keycode) { action.code = ACTION_MODS_KEY(mod_config(QK_MODS_GET_MODS(keycode)), keycode_config(QK_MODS_GET_BASIC_KEYCODE(keycode))); // adds modifier to key #endif // LEGACY_MAGIC_HANDLING break; -#ifndef NO_ACTION_LAYER case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: +#if !defined(NO_ACTION_LAYER) && !defined(NO_ACTION_TAPPING) # ifdef LEGACY_MAGIC_HANDLING action.code = ACTION_LAYER_TAP_KEY(QK_LAYER_TAP_GET_LAYER(keycode), QK_LAYER_TAP_GET_TAP_KEYCODE(keycode)); # else // LEGACY_MAGIC_HANDLING action.code = ACTION_LAYER_TAP_KEY(QK_LAYER_TAP_GET_LAYER(keycode), keycode_config(QK_LAYER_TAP_GET_TAP_KEYCODE(keycode))); # endif // LEGACY_MAGIC_HANDLING +#else + // pass through keycode_config again, since it previously missed it + // and then only send as ACTION_KEY to bypass most of action.c handling + action.code = ACTION_KEY(keycode_config(QK_LAYER_TAP_GET_TAP_KEYCODE(keycode))); +#endif break; +#ifndef NO_ACTION_LAYER case QK_TO ... QK_TO_MAX:; // Layer set "GOTO" action_layer = QK_TO_GET_LAYER(keycode); @@ -115,32 +121,54 @@ action_t action_for_keycode(uint16_t keycode) { action_layer = QK_ONE_SHOT_LAYER_GET_LAYER(keycode); action.code = ACTION_LAYER_ONESHOT(action_layer); break; +#endif // NO_ACTION_ONESHOT case QK_ONE_SHOT_MOD ... QK_ONE_SHOT_MOD_MAX:; // OSM(mod) - One-shot mod - mod = mod_config(QK_ONE_SHOT_MOD_GET_MODS(keycode)); + mod = mod_config(QK_ONE_SHOT_MOD_GET_MODS(keycode)); +#if defined(NO_ACTION_TAPPING) || defined(NO_ACTION_ONESHOT) + action.code = ACTION_MODS(mod); +#else // defined(NO_ACTION_TAPPING) || defined(NO_ACTION_ONESHOT) action.code = ACTION_MODS_ONESHOT(mod); +#endif // defined(NO_ACTION_TAPPING) || defined(NO_ACTION_ONESHOT) break; -#endif #ifndef NO_ACTION_LAYER case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX: +# ifndef NO_ACTION_TAPPING action.code = ACTION_LAYER_TAP_TOGGLE(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode)); +# else // NO_ACTION_TAPPING +# ifdef NO_ACTION_TAPPING_TAP_TOGGLE_MO + action.code = ACTION_LAYER_MOMENTARY(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode)); +# else // NO_ACTION_TAPPING_TAP_TOGGLE_MO + action.code = ACTION_LAYER_TOGGLE(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode)); +# endif // NO_ACTION_TAPPING_TAP_TOGGLE_MO +# endif // NO_ACTION_TAPPING break; case QK_LAYER_MOD ... QK_LAYER_MOD_MAX: mod = mod_config(QK_LAYER_MOD_GET_MODS(keycode)); action_layer = QK_LAYER_MOD_GET_LAYER(keycode); action.code = ACTION_LAYER_MODS(action_layer, (mod & 0x10) ? mod << 4 : mod); break; -#endif -#ifndef NO_ACTION_TAPPING +#endif // NO_ACTION_LAYER case QK_MOD_TAP ... QK_MOD_TAP_MAX: +#ifndef NO_ACTION_TAPPING mod = mod_config(QK_MOD_TAP_GET_MODS(keycode)); # ifdef LEGACY_MAGIC_HANDLING action.code = ACTION_MODS_TAP_KEY(mod, QK_MOD_TAP_GET_TAP_KEYCODE(keycode)); # else // LEGACY_MAGIC_HANDLING action.code = ACTION_MODS_TAP_KEY(mod, keycode_config(QK_MOD_TAP_GET_TAP_KEYCODE(keycode))); # endif // LEGACY_MAGIC_HANDLING +#else // NO_ACTION_TAPPING +# ifdef NO_ACTION_TAPPING_MODTAP_MODS + // pass through mod_config again, since it previously missed it + // and then only send as ACTION_KEY to bypass most of action.c handling + action.code = ACTION_MODS(mod_config(QK_MOD_TAP_GET_MODS(keycode))); +# else // NO_ACTION_TAPPING_MODTAP_MODS + // pass through keycode_config again, since it previously missed it + // and then only send as ACTION_KEY to bypass most of action.c handling + action.code = ACTION_KEY(keycode_config(QK_MOD_TAP_GET_TAP_KEYCODE(keycode))); +# endif // NO_ACTION_TAPPING_MODTAP_MODS +#endif // NO_ACTION_TAPPING break; -#endif #ifdef SWAP_HANDS_ENABLE case QK_SWAP_HANDS ... QK_SWAP_HANDS_MAX: # ifdef LEGACY_MAGIC_HANDLING diff --git a/quantum/process_keycode/process_autocorrect.c b/quantum/process_keycode/process_autocorrect.c index c89dffeaad..1376788266 100644 --- a/quantum/process_keycode/process_autocorrect.c +++ b/quantum/process_keycode/process_autocorrect.c @@ -128,7 +128,11 @@ __attribute__((weak)) bool process_autocorrect_user(uint16_t *keycode, keyrecord #ifdef SWAP_HANDS_ENABLE // Note: IS_SWAP_HANDS_KEYCODE() actually tests for the special action keycodes like SH_TOGG, SH_TT, ..., // which currently overlap the SH_T(kc) range. - if (IS_SWAP_HANDS_KEYCODE(*keycode) || !record->tap.count) { + if (IS_SWAP_HANDS_KEYCODE(*keycode) +# ifndef NO_ACTION_TAPPING + || !record->tap.count +# endif // NO_ACTION_TAPPING + ) { return false; } *keycode = QK_SWAP_HANDS_GET_TAP_KEYCODE(*keycode); diff --git a/quantum/process_keycode/process_caps_word.c b/quantum/process_keycode/process_caps_word.c index 933abe629e..94302b29ae 100644 --- a/quantum/process_keycode/process_caps_word.c +++ b/quantum/process_keycode/process_caps_word.c @@ -145,7 +145,11 @@ bool process_caps_word(uint16_t keycode, keyrecord_t* record) { case QK_SWAP_HANDS ... QK_SWAP_HANDS_MAX: // Note: IS_SWAP_HANDS_KEYCODE() actually tests for the special action keycodes like SH_TOGG, SH_TT, ..., // which currently overlap the SH_T(kc) range. - if (IS_SWAP_HANDS_KEYCODE(keycode) || record->tap.count == 0) { + if (IS_SWAP_HANDS_KEYCODE(keycode) +# ifndef NO_ACTION_TAPPING + || record->tap.count == 0 +# endif // NO_ACTION_TAPPING + ) { return true; } keycode = QK_SWAP_HANDS_GET_TAP_KEYCODE(keycode); diff --git a/tests/no_tapping/no_action_tapping/config.h b/tests/no_tapping/no_action_tapping/config.h new file mode 100644 index 0000000000..3156e697fb --- /dev/null +++ b/tests/no_tapping/no_action_tapping/config.h @@ -0,0 +1,21 @@ +/* Copyright 2017 Fred Sundvik + * + * 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 . + */ + +#pragma once + +#include "test_common.h" + +#define NO_ACTION_TAPPING diff --git a/tests/no_tapping/no_action_tapping/test.mk b/tests/no_tapping/no_action_tapping/test.mk new file mode 100644 index 0000000000..29690d1adf --- /dev/null +++ b/tests/no_tapping/no_action_tapping/test.mk @@ -0,0 +1,18 @@ +# Copyright 2017 Fred Sundvik +# +# 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 . + +# -------------------------------------------------------------------------------- +# Keep this file, even if it is empty, as a marker that this folder contains tests +# -------------------------------------------------------------------------------- \ No newline at end of file diff --git a/tests/no_tapping/no_action_tapping/test_layer_tap.cpp b/tests/no_tapping/no_action_tapping/test_layer_tap.cpp new file mode 100644 index 0000000000..568c3c35d6 --- /dev/null +++ b/tests/no_tapping/no_action_tapping/test_layer_tap.cpp @@ -0,0 +1,63 @@ +/* Copyright 2017 Fred Sundvik + * + * 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 . + */ + +#include "keyboard_report_util.hpp" +#include "keycode.h" +#include "test_common.hpp" +#include "action_tapping.h" +#include "test_keymap_key.hpp" + +using testing::_; +using testing::InSequence; + +class Tapping : public TestFixture {}; + +TEST_F(Tapping, TapP_Layer_Tap_KeyReportsKey) { + TestDriver driver; + InSequence s; + auto key_shift_hold_p_tap = KeymapKey(0, 7, 0, LT(1, KC_P)); + + set_keymap({key_shift_hold_p_tap}); + + key_shift_hold_p_tap.press(); + EXPECT_REPORT(driver, (KC_P)); + run_one_scan_loop(); + + key_shift_hold_p_tap.release(); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(Tapping, HoldP_Layer_Tap_KeyReportsKey) { + TestDriver driver; + InSequence s; + auto mod_tap_hold_key = KeymapKey(0, 7, 0, LT(1, KC_P)); + + set_keymap({mod_tap_hold_key}); + + mod_tap_hold_key.press(); + EXPECT_REPORT(driver, (KC_P)); + + idle_for(TAPPING_TERM); + run_one_scan_loop(); + EXPECT_NO_REPORT(driver); + + mod_tap_hold_key.release(); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} diff --git a/tests/no_tapping/no_action_tapping/test_mod_tap.cpp b/tests/no_tapping/no_action_tapping/test_mod_tap.cpp new file mode 100644 index 0000000000..68d8ab5a12 --- /dev/null +++ b/tests/no_tapping/no_action_tapping/test_mod_tap.cpp @@ -0,0 +1,107 @@ +/* Copyright 2017 Fred Sundvik + * + * 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 . + */ + +#include "keyboard_report_util.hpp" +#include "keycode.h" +#include "test_common.hpp" +#include "action_tapping.h" +#include "test_keymap_key.hpp" + +using testing::_; +using testing::InSequence; + +class Tapping : public TestFixture {}; + +TEST_F(Tapping, TapA_SHFT_T_KeyReportsKey) { + TestDriver driver; + InSequence s; + auto key_shift_hold_p_tap = KeymapKey(0, 7, 0, SFT_T(KC_P)); + + set_keymap({key_shift_hold_p_tap}); + + key_shift_hold_p_tap.press(); + EXPECT_REPORT(driver, (KC_P)); + run_one_scan_loop(); + + key_shift_hold_p_tap.release(); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(Tapping, HoldA_SHFT_T_KeyReportsShift) { + TestDriver driver; + InSequence s; + auto mod_tap_hold_key = KeymapKey(0, 7, 0, SFT_T(KC_P)); + + set_keymap({mod_tap_hold_key}); + + mod_tap_hold_key.press(); + EXPECT_REPORT(driver, (KC_P)); + + idle_for(TAPPING_TERM); + run_one_scan_loop(); + EXPECT_NO_REPORT(driver); + + mod_tap_hold_key.release(); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) { + // See issue #1478 for more information + TestDriver driver; + InSequence s; + auto key_shift_hold_p_tap = KeymapKey(0, 7, 0, SFT_T(KC_P)); + + set_keymap({key_shift_hold_p_tap}); + + // Tapping keys does nothing on press + key_shift_hold_p_tap.press(); + EXPECT_REPORT(driver, (KC_P)); + run_one_scan_loop(); + + key_shift_hold_p_tap.release(); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); + + key_shift_hold_p_tap.press(); + EXPECT_REPORT(driver, (KC_P)); + run_one_scan_loop(); + + key_shift_hold_p_tap.release(); + EXPECT_EMPTY_REPORT(driver); + idle_for(TAPPING_TERM + 1); + + key_shift_hold_p_tap.press(); + EXPECT_REPORT(driver, (KC_P)); + run_one_scan_loop(); + key_shift_hold_p_tap.release(); + + EXPECT_EMPTY_REPORT(driver); + idle_for(TAPPING_TERM + 1); + + key_shift_hold_p_tap.press(); + // Shouldn't be called here really + EXPECT_REPORT(driver, (KC_P)); + idle_for(TAPPING_TERM); + + EXPECT_EMPTY_REPORT(driver); + key_shift_hold_p_tap.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} diff --git a/tests/no_tapping/no_action_tapping/test_one_shot_keys.cpp b/tests/no_tapping/no_action_tapping/test_one_shot_keys.cpp new file mode 100644 index 0000000000..e2ca61120d --- /dev/null +++ b/tests/no_tapping/no_action_tapping/test_one_shot_keys.cpp @@ -0,0 +1,105 @@ +/* Copyright 2021 Stefan Kerkmann + * + * 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 . + */ + +#include "action_util.h" +#include "keyboard_report_util.hpp" +#include "test_common.hpp" + +using testing::_; +using testing::InSequence; + +class OneShot : public TestFixture {}; + +TEST_F(OneShot, OSMWithoutAdditionalKeypressDoesNothing) { + TestDriver driver; + auto osm_key = KeymapKey(0, 0, 0, OSM(MOD_LSFT), KC_LSFT); + + set_keymap({osm_key}); + + /* Press and release OSM key*/ + EXPECT_NO_REPORT(driver); + osm_key.press(); + EXPECT_REPORT(driver, (osm_key.report_code)); + run_one_scan_loop(); + EXPECT_NO_REPORT(driver); + osm_key.release(); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(OneShot, OSL_No_ReportPress) { + TestDriver driver; + auto osl_key = KeymapKey{0, 0, 0, OSL(1)}; + auto empty_key = KeymapKey{0, 1, 0, KC_NO}; + auto regular_key = KeymapKey{1, 1, 0, KC_A}; + + set_keymap({osl_key, empty_key, regular_key}); + + /* Press OSL key */ + EXPECT_NO_REPORT(driver); + osl_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release OSL key */ + EXPECT_NO_REPORT(driver); + osl_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Press regular key */ + EXPECT_NO_REPORT(driver); + regular_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release regular key */ + EXPECT_NO_REPORT(driver); + regular_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(OneShot, OSL_ReportPress) { + TestDriver driver; + auto osl_key = KeymapKey{0, 0, 0, OSL(1)}; + auto empty_key = KeymapKey{0, 1, 0, KC_NO}; + auto regular_key = KeymapKey{1, 1, 0, KC_A}; + + set_keymap({osl_key, empty_key, regular_key}); + + /* Press OSL key */ + osl_key.press(); + run_one_scan_loop(); + EXPECT_NO_REPORT(driver); + + /* Press regular key */ + regular_key.press(); + run_one_scan_loop(); + EXPECT_NO_REPORT(driver); + + /* Release regular key */ + regular_key.release(); + run_one_scan_loop(); + EXPECT_NO_REPORT(driver); + + /* Release OSL key */ + osl_key.release(); + run_one_scan_loop(); + EXPECT_NO_REPORT(driver); + VERIFY_AND_CLEAR(driver); +} diff --git a/tests/no_tapping/no_mod_tap_mods/config.h b/tests/no_tapping/no_mod_tap_mods/config.h new file mode 100644 index 0000000000..5fca42a8ea --- /dev/null +++ b/tests/no_tapping/no_mod_tap_mods/config.h @@ -0,0 +1,22 @@ +/* Copyright 2017 Fred Sundvik + * + * 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 . + */ + +#pragma once + +#include "test_common.h" + +#define NO_ACTION_TAPPING +#define NO_ACTION_TAPPING_MODTAP_MODS diff --git a/tests/no_tapping/no_mod_tap_mods/test.mk b/tests/no_tapping/no_mod_tap_mods/test.mk new file mode 100644 index 0000000000..29690d1adf --- /dev/null +++ b/tests/no_tapping/no_mod_tap_mods/test.mk @@ -0,0 +1,18 @@ +# Copyright 2017 Fred Sundvik +# +# 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 . + +# -------------------------------------------------------------------------------- +# Keep this file, even if it is empty, as a marker that this folder contains tests +# -------------------------------------------------------------------------------- \ No newline at end of file diff --git a/tests/no_tapping/no_mod_tap_mods/test_tapping.cpp b/tests/no_tapping/no_mod_tap_mods/test_tapping.cpp new file mode 100644 index 0000000000..079c008833 --- /dev/null +++ b/tests/no_tapping/no_mod_tap_mods/test_tapping.cpp @@ -0,0 +1,104 @@ +/* Copyright 2017 Fred Sundvik + * + * 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 . + */ + +#include "keyboard_report_util.hpp" +#include "keycode.h" +#include "test_common.hpp" +#include "action_tapping.h" +#include "test_keymap_key.hpp" + +using testing::_; +using testing::InSequence; + +class Tapping : public TestFixture {}; + +TEST_F(Tapping, TapA_SHFT_T_KeyReportsKey) { + TestDriver driver; + InSequence s; + auto key_shift_hold_p_tap = KeymapKey(0, 7, 0, SFT_T(KC_P)); + + set_keymap({key_shift_hold_p_tap}); + + key_shift_hold_p_tap.press(); + EXPECT_REPORT(driver, (KC_LSFT)); + run_one_scan_loop(); + + key_shift_hold_p_tap.release(); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); +} + +TEST_F(Tapping, HoldA_SHFT_T_KeyReportsShift) { + TestDriver driver; + InSequence s; + auto mod_tap_hold_key = KeymapKey(0, 7, 0, SFT_T(KC_P)); + + set_keymap({mod_tap_hold_key}); + + mod_tap_hold_key.press(); + EXPECT_REPORT(driver, (KC_LSFT)); + + idle_for(TAPPING_TERM); + run_one_scan_loop(); + EXPECT_NO_REPORT(driver); + + mod_tap_hold_key.release(); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); +} + +TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) { + // See issue #1478 for more information + TestDriver driver; + InSequence s; + auto key_shift_hold_p_tap = KeymapKey(0, 7, 0, SFT_T(KC_P)); + + set_keymap({key_shift_hold_p_tap}); + + // Tapping keys does nothing on press + key_shift_hold_p_tap.press(); + EXPECT_REPORT(driver, (KC_LSFT)); + run_one_scan_loop(); + + key_shift_hold_p_tap.release(); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); + + key_shift_hold_p_tap.press(); + EXPECT_REPORT(driver, (KC_LSFT)); + run_one_scan_loop(); + + key_shift_hold_p_tap.release(); + EXPECT_EMPTY_REPORT(driver); + idle_for(TAPPING_TERM + 1); + + key_shift_hold_p_tap.press(); + EXPECT_REPORT(driver, (KC_LSFT)); + run_one_scan_loop(); + key_shift_hold_p_tap.release(); + + EXPECT_EMPTY_REPORT(driver); + idle_for(TAPPING_TERM + 1); + + key_shift_hold_p_tap.press(); + // Shouldn't be called here really + EXPECT_REPORT(driver, (KC_LSFT)); + idle_for(TAPPING_TERM); + + EXPECT_EMPTY_REPORT(driver); + key_shift_hold_p_tap.release(); + run_one_scan_loop(); +}