[Tests] Increase QMK test coverage take 2 (#15269)

* Add per-test keymaps

* Add better trace and info logs for failed unit-tests

* Add layer state assertion with tracing message

* Use individual test binaries configuration options

* Add basic qmk functionality tests

* Add tap hold configurations tests

* Add auto shift tests

Co-authored-by: Nick Brassel <nick@tzarc.org>

48 files changed, 2703 insertions, 246 deletions

diff --git a/Makefile b/Makefile
index c221cb89e0..88f430619e 100644
--- a/Makefile
+++ b/Makefile
@@ -378,11 +378,12 @@ define PARSE_ALL_KEYMAPS
 endef
 
 define BUILD_TEST
-    TEST_NAME := $1
+    TEST_PATH := $1
+    TEST_NAME := $$(notdir $$(TEST_PATH))
     MAKE_TARGET := $2
     COMMAND := $1
     MAKE_CMD := $$(MAKE) -r -R -C $(ROOT_DIR) -f build_test.mk $$(MAKE_TARGET)
-    MAKE_VARS := TEST=$$(TEST_NAME) FULL_TESTS="$$(FULL_TESTS)"
+    MAKE_VARS := TEST=$$(TEST_NAME) TEST_PATH=$$(TEST_PATH) FULL_TESTS="$$(FULL_TESTS)"
     MAKE_MSG := $$(MSG_MAKE_TEST)
     $$(eval $$(call BUILD))
     ifneq ($$(MAKE_TARGET),clean)
@@ -406,7 +407,7 @@ define PARSE_TEST
     ifeq ($$(TEST_NAME),all)
         MATCHED_TESTS := $$(TEST_LIST)
     else
-        MATCHED_TESTS := $$(foreach TEST,$$(TEST_LIST),$$(if $$(findstring $$(TEST_NAME),$$(TEST)),$$(TEST),))
+        MATCHED_TESTS := $$(foreach TEST, $$(TEST_LIST),$$(if $$(findstring $$(TEST_NAME), $$(notdir $$(TEST))), $$(TEST),))
     endif
     $$(foreach TEST,$$(MATCHED_TESTS),$$(eval $$(call BUILD_TEST,$$(TEST),$$(TEST_TARGET))))
 endef
diff --git a/build_full_test.mk b/build_full_test.mk
index f8030cb060..4cd1ac61b5 100644
--- a/build_full_test.mk
+++ b/build_full_test.mk
@@ -13,21 +13,24 @@
 # 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 $(TMK_PATH)/protocol.mk
+$(TEST)_INC := \
+	tests\test_common\common_config.h
 
-TEST_PATH=tests/$(TEST)
-
-$(TEST)_SRC= \
-	$(TEST_PATH)/keymap.c \
+$(TEST)_SRC := \
 	$(TMK_COMMON_SRC) \
 	$(QUANTUM_SRC) \
 	$(SRC) \
+	tests/test_common/keymap.c \
 	tests/test_common/matrix.c \
 	tests/test_common/test_driver.cpp \
 	tests/test_common/keyboard_report_util.cpp \
-	tests/test_common/test_fixture.cpp
-$(TEST)_SRC += $(patsubst $(ROOTDIR)/%,%,$(wildcard $(TEST_PATH)/*.cpp))
+	tests/test_common/test_fixture.cpp \
+	tests/test_common/test_keymap_key.cpp \
+	tests/test_common/test_logger.cpp \
+	$(patsubst $(ROOTDIR)/%,%,$(wildcard $(TEST_PATH)/*.cpp))
+
+$(TEST)_DEFS := $(TMK_COMMON_DEFS) $(OPT_DEFS)
+
+$(TEST)_CONFIG := $(TEST_PATH)/config.h
 
-$(TEST)_DEFS=$(TMK_COMMON_DEFS) $(OPT_DEFS)
-$(TEST)_CONFIG=$(TEST_PATH)/config.h
-VPATH+=$(TOP_DIR)/tests/test_common
+VPATH += $(TOP_DIR)/tests/test_common
\ No newline at end of file
diff --git a/build_test.mk b/build_test.mk
index 36cb7936ed..136a0455f0 100644
--- a/build_test.mk
+++ b/build_test.mk
@@ -16,14 +16,14 @@ TEST_OBJ = $(BUILD_DIR)/test_obj
 OUTPUTS := $(TEST_OBJ)/$(TEST) $(GTEST_OUTPUT)
 
 GTEST_INC := \
-	$(LIB_PATH)/googletest/googletest/include\
-	$(LIB_PATH)/googletest/googlemock/include\
+	$(LIB_PATH)/googletest/googletest/include \
+	$(LIB_PATH)/googletest/googlemock/include
 
-GTEST_INTERNAL_INC :=\
-	$(LIB_PATH)/googletest/googletest\
+GTEST_INTERNAL_INC := \
+	$(LIB_PATH)/googletest/googletest \
 	$(LIB_PATH)/googletest/googlemock
 
-$(GTEST_OUTPUT)_SRC :=\
+$(GTEST_OUTPUT)_SRC := \
 	googletest/src/gtest-all.cc\
 	googlemock/src/gmock-all.cc
 
@@ -33,9 +33,9 @@ $(GTEST_OUTPUT)_INC := $(GTEST_INC) $(GTEST_INTERNAL_INC)
 LDFLAGS += -lstdc++ -lpthread -shared-libgcc
 CREATE_MAP := no
 
-VPATH +=\
-	$(LIB_PATH)/googletest\
-	$(LIB_PATH)/googlemock\
+VPATH += \
+	$(LIB_PATH)/googletest \
+	$(LIB_PATH)/googlemock \
 	$(LIB_PATH)/printf
 
 all: elf
@@ -49,7 +49,8 @@ CONSOLE_ENABLE = yes
 endif
 
 ifneq ($(filter $(FULL_TESTS),$(TEST)),)
-include tests/$(TEST)/rules.mk
+include tests/test_common/build.mk
+include $(TEST_PATH)/test.mk
 endif
 
 include common_features.mk
diff --git a/testlist.mk b/testlist.mk
index cff784dad6..d2bb571be6 100644
--- a/testlist.mk
+++ b/testlist.mk
@@ -1,5 +1,5 @@
-TEST_LIST = $(notdir $(patsubst %/rules.mk,%,$(wildcard $(ROOT_DIR)/tests/*/rules.mk)))
-FULL_TESTS := $(TEST_LIST)
+TEST_LIST = $(sort $(patsubst %/test.mk,%, $(shell find $(ROOT_DIR)tests -type f -name test.mk)))
+FULL_TESTS := $(notdir $(TEST_LIST))
 
 include $(QUANTUM_PATH)/debounce/tests/testlist.mk
 include $(QUANTUM_PATH)/encoder/tests/testlist.mk
diff --git a/tests/auto_shift/config.h b/tests/auto_shift/config.h
new file mode 100644
index 0000000000..4f343b4529
--- /dev/null
+++ b/tests/auto_shift/config.h
@@ -0,0 +1,19 @@
+/* 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "test_common.h"
\ No newline at end of file
diff --git a/tests/auto_shift/test.mk b/tests/auto_shift/test.mk
new file mode 100644
index 0000000000..4259c606e4
--- /dev/null
+++ b/tests/auto_shift/test.mk
@@ -0,0 +1,20 @@
+# 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 <http://www.gnu.org/licenses/>.
+
+# --------------------------------------------------------------------------------
+# Keep this file, even if it is empty, as a marker that this folder contains tests
+# --------------------------------------------------------------------------------
+
+AUTO_SHIFT_ENABLE = yes
\ No newline at end of file
diff --git a/tests/auto_shift/test_auto_shift.cpp b/tests/auto_shift/test_auto_shift.cpp
new file mode 100644
index 0000000000..9c5ed9a832
--- /dev/null
+++ b/tests/auto_shift/test_auto_shift.cpp
@@ -0,0 +1,73 @@
+/* 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "keyboard_report_util.hpp"
+#include "keycode.h"
+#include "test_common.hpp"
+#include "action_tapping.h"
+#include "test_fixture.hpp"
+#include "test_keymap_key.hpp"
+
+using testing::_;
+using testing::InSequence;
+
+class AutoShift : public TestFixture {};
+
+TEST_F(AutoShift, key_release_before_timeout) {
+    TestDriver driver;
+    InSequence s;
+    auto       regular_key = KeymapKey(0, 2, 0, KC_A);
+
+    set_keymap({regular_key});
+
+    /* Press regular key */
+    EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
+    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_CALL(driver, send_keyboard_mock(KeyboardReport()));
+    regular_key.release();
+    run_one_scan_loop();
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(AutoShift, key_release_after_timeout) {
+    TestDriver driver;
+    InSequence s;
+    auto       regular_key = KeymapKey(0, 2, 0, KC_A);
+
+    set_keymap({regular_key});
+
+    /* Press regular key */
+    EXPECT_CALL(driver, send_keyboard_mock(_)).Times(0);
+    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_CALL(driver, send_keyboard_mock(KeyboardReport()));
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport()));
+    regular_key.release();
+    run_one_scan_loop();
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
\ No newline at end of file
diff --git a/tests/basic/config.h b/tests/basic/config.h
index 99bd62d991..85fa9d691d 100644
--- a/tests/basic/config.h
+++ b/tests/basic/config.h
@@ -16,5 +16,4 @@
 
 #pragma once
 
-#define MATRIX_ROWS 4
-#define MATRIX_COLS 10
+#include "test_common.h"
\ No newline at end of file
diff --git a/tests/basic/keymap.c b/tests/basic/keymap.c
deleted file mode 100644
index 2b5747abb7..0000000000
--- a/tests/basic/keymap.c
+++ /dev/null
@@ -1,45 +0,0 @@
-/* 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 <http://www.gnu.org/licenses/>.
- */
-
-#include "quantum.h"
-
-// Don't rearrange keys as existing tests might rely on the order
-// Col2, Row 0 has to be KC_NO, because tests rely on it
-
-#define COMBO1 RSFT(LCTL(KC_O))
-
-const uint16_t PROGMEM
-               keymaps[][MATRIX_ROWS][MATRIX_COLS] =
-        {
-            [0] =
-                {
-                    // 0    1      2      3        4        5        6       7            8      9
-                    {KC_A, KC_B, KC_NO, KC_LSFT, KC_RSFT, KC_LCTL, COMBO1, SFT_T(KC_P), M(0), KC_NO},
-                    {KC_EQL, KC_PLUS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO},
-                    {KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO},
-                    {KC_C, KC_D, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO},
-                },
-};
-
-const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
-    if (record->event.pressed) {
-        switch (id) {
-            case 0:
-                return MACRO(D(LSFT), T(H), U(LSFT), T(E), T(L), T(L), T(O), T(SPACE), W(100), D(LSFT), T(W), U(LSFT), I(10), T(O), T(R), T(L), T(D), D(LSFT), T(1), U(LSFT), END);
-        }
-    }
-    return MACRO_NONE;
-};
diff --git a/tests/basic/test.mk b/tests/basic/test.mk
new file mode 100644
index 0000000000..29690d1adf
--- /dev/null
+++ b/tests/basic/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 <http://www.gnu.org/licenses/>.
+
+# --------------------------------------------------------------------------------
+# 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/basic/test_action_layer.cpp b/tests/basic/test_action_layer.cpp
index d00a0859b9..1b12d13642 100644
--- a/tests/basic/test_action_layer.cpp
+++ b/tests/basic/test_action_layer.cpp
@@ -14,39 +14,54 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "gtest/gtest.h"
+#include "keyboard_report_util.hpp"
 #include "test_common.hpp"
 
 using testing::_;
-using testing::Return;
+using testing::InSequence;
 
 class ActionLayer : public TestFixture {};
 
-// TEST_F(ActionLayer, LayerStateDBG) {
-//     layer_state_set(0);
-// }
-
-// TEST_F(ActionLayer, LayerStateSet) {
-//     layer_state_set(0);
-//     EXPECT_EQ(layer_state, 0);
-//     layer_state_set(0b001100);
-//     EXPECT_EQ(layer_state, 0b001100);
-// }
-
-// TEST_F(ActionLayer, LayerStateIs) {
-//     layer_state_set(0);
-//     EXPECT_EQ(layer_state_is(0), true);
-//     EXPECT_EQ(layer_state_is(1), true);
-//     layer_state_set(1);
-//     EXPECT_EQ(layer_state_is(0), true);
-//     EXPECT_EQ(layer_state_is(1), true);
-//     layer_state_set(2);
-//     EXPECT_EQ(layer_state_is(0), false);
-//     EXPECT_EQ(layer_state_is(1), false);
-//     EXPECT_EQ(layer_state_is(2), true);
-// }
+TEST_F(ActionLayer, LayerStateDBG) {
+    TestDriver driver;
+
+    layer_state_set(0);
+
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, LayerStateSet) {
+    TestDriver driver;
+
+    layer_state_set(0);
+    EXPECT_EQ(layer_state, 0);
+    layer_state_set(0b001100);
+    EXPECT_EQ(layer_state, 0b001100);
+
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, LayerStateIs) {
+    TestDriver driver;
+
+    layer_state_set(0);
+    EXPECT_EQ(layer_state_is(0), true);
+    EXPECT_EQ(layer_state_is(1), false);
+    layer_state_set(1);
+    EXPECT_EQ(layer_state_is(0), true);
+    EXPECT_EQ(layer_state_is(1), false);
+    layer_state_set(2);
+    EXPECT_EQ(layer_state_is(0), false);
+    EXPECT_EQ(layer_state_is(1), true);
+    EXPECT_EQ(layer_state_is(2), false);
+
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
 
 TEST_F(ActionLayer, LayerStateCmp) {
-    uint32_t prev_layer;
+    TestDriver driver;
+    uint32_t   prev_layer;
 
     prev_layer = 0;
     EXPECT_EQ(layer_state_cmp(prev_layer, 0), true);
@@ -60,33 +75,339 @@ TEST_F(ActionLayer, LayerStateCmp) {
     EXPECT_EQ(layer_state_cmp(prev_layer, 0), false);
     EXPECT_EQ(layer_state_cmp(prev_layer, 1), true);
     EXPECT_EQ(layer_state_cmp(prev_layer, 2), false);
+
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, LayerClear) {
+    TestDriver driver;
+
+    layer_clear();
+    EXPECT_EQ(layer_state, 0);
+
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, LayerMove) {
+    TestDriver driver;
+
+    layer_move(0);
+    EXPECT_EQ(layer_state, 1);
+    layer_move(3);
+    EXPECT_EQ(layer_state, 0b1000);
+
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, LayerOn) {
+    TestDriver driver;
+
+    layer_clear();
+    layer_on(1);
+    layer_on(3);
+    layer_on(3);
+    EXPECT_EQ(layer_state, 0b1010);
+
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, LayerOff) {
+    TestDriver driver;
+
+    layer_clear();
+    layer_on(1);
+    layer_on(3);
+    layer_off(3);
+    layer_off(2);
+    EXPECT_EQ(layer_state, 0b0010);
+
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, MomentaryLayerDoesNothing) {
+    TestDriver driver;
+    KeymapKey  layer_key = KeymapKey{0, 0, 0, MO(1)};
+
+    set_keymap({layer_key});
+
+    /* Press and release MO, nothing should happen. */
+    /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
+    layer_key.press();
+    run_one_scan_loop();
+    testing::Mock::VerifyAndClearExpectations(&driver);
+
+    /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
+    layer_key.release();
+    run_one_scan_loop();
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, MomentaryLayerWithKeypress) {
+    TestDriver driver;
+    KeymapKey  layer_key = KeymapKey{0, 0, 0, MO(1)};
+
+    /* These keys must have the same position in the matrix, only the layer is different. */
+    KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
+    set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
+
+    /* Press MO. */
+    /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
+    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);
+    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);
+    regular_key.release();
+    run_one_scan_loop();
+    EXPECT_TRUE(layer_state_is(1));
+    testing::Mock::VerifyAndClearExpectations(&driver);
+
+    /* Release MO */
+    /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
+    layer_key.release();
+    run_one_scan_loop();
+    EXPECT_TRUE(layer_state_is(0));
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, ToggleLayerDoesNothing) {
+    GTEST_SKIP() << "TODO: Toggle layer does not activate the expected layer on key press but on release.";
+
+    TestDriver driver;
+    KeymapKey  layer_key = KeymapKey{0, 0, 0, TG(1)};
+
+    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);
+    layer_key.press();
+    run_one_scan_loop();
+    EXPECT_TRUE(layer_state_is(1));
+    testing::Mock::VerifyAndClearExpectations(&driver);
+
+    /* Release TG. */
+    /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
+    layer_key.release();
+    run_one_scan_loop();
+    EXPECT_TRUE(layer_state_is(1));
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, ToggleLayerUpAndDown) {
+    GTEST_SKIP() << "TODO: Toggle layer does not activate the expected layer on key press but on release.";
+
+    TestDriver driver;
+    KeymapKey  toggle_layer_1_on_layer_0 = KeymapKey{0, 0, 0, TG(1)};
+    KeymapKey  toggle_layer_0_on_layer_1 = KeymapKey{1, 1, 0, TG(0)};
+
+    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);
+    toggle_layer_1_on_layer_0.press();
+    run_one_scan_loop();
+    EXPECT_TRUE(layer_state_is(1));
+    testing::Mock::VerifyAndClearExpectations(&driver);
+
+    /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
+    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);
+    toggle_layer_0_on_layer_1.press();
+    run_one_scan_loop();
+    EXPECT_TRUE(layer_state_is(0));
+    testing::Mock::VerifyAndClearExpectations(&driver);
+
+    /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(1);
+    toggle_layer_0_on_layer_1.release();
+    run_one_scan_loop();
+    EXPECT_TRUE(layer_state_is(0));
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, LayerTapToggleDoesNothing) {
+    GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
+
+    TestDriver driver;
+    KeymapKey  layer_key = KeymapKey{0, 0, 0, TT(1)};
+
+    set_keymap({layer_key});
+
+    /* Press and release TT. */
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
+    layer_key.press();
+    run_one_scan_loop();
+    EXPECT_TRUE(layer_state_is(1));
+    testing::Mock::VerifyAndClearExpectations(&driver);
+
+    /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(2);
+    layer_key.release();
+    run_one_scan_loop();
+    EXPECT_TRUE(layer_state_is(0));
+    testing::Mock::VerifyAndClearExpectations(&driver);
+}
+
+TEST_F(ActionLayer, LayerTapToggleWithKeypress) {
+    GTEST_SKIP() << "TODO: Tap toggle layer does not activate the expected layer on key press.";
+
+    TestDriver driver;
+    KeymapKey  layer_key = KeymapKey{0, 0, 0, TT(1)};
+
+    /* These keys must have the same position in the matrix, only the layer is different. */
+    KeymapKey regular_key = KeymapKey{0, 1, 0, KC_A};
+    set_keymap({layer_key, regular_key, KeymapKey{1, 1, 0, KC_B}});
+
+    /* Press TT. */
+    /* TODO: QMK currently sends an empty report even if nothing needs to be reported to the host! */
+    EXPECT_CALL(driver, send_keyboard_mock(KeyboardReport())).Times(0);
+    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);
+    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);
+    regular_key.release();
+    run_one_scan_loop();
+    EXPECT_TRUE(layer_state_is(1));