Avoid 8-bit timer overflows in debounce algorithms (#12240)

* Add fast_timer_t that is 16-bit or 32-bit based on architecture

A 16-bit timer will overflow sooner but be faster to compare on AVR.

* Avoid 8-bit timer overflows in debounce algorithms

Count down remaining elapsed time instead of trying to do 8-bit timer
comparisons.

Add a "none" implementation that is automatically used if DEBOUNCE is
0 otherwise it will break the _pk/_pr count down.

* Avoid unnecessary polling of the entire matrix in sym_eager_pk

The matrix only needs to be updated when a debounce timer expires.

* Avoid unnecessary polling of the entire matrix in sym_eager_pr

The matrix only needs to be updated when a debounce timer expires.

The use of the "needed_update" variable is trying to do what
"matrix_need_update" was added to fix but didn't work because it only
applied when all keys finished debouncing.

* Fix sym_defer_g timing inconsistency compared to other debounce algorithms

DEBOUNCE=5 should process the key after 5ms, not 6ms

* Add debounce tests

8 files changed, 1321 insertions, 0 deletions

diff --git a/quantum/debounce/tests/debounce_test_common.cpp b/quantum/debounce/tests/debounce_test_common.cpp
new file mode 100644
index 0000000000..1c5e7c9f4e
--- /dev/null
+++ b/quantum/debounce/tests/debounce_test_common.cpp
@@ -0,0 +1,229 @@
+/* Copyright 2021 Simon Arlott
+ *
+ * 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 "gtest/gtest.h"
+
+#include "debounce_test_common.h"
+
+#include <algorithm>
+#include <iomanip>
+#include <sstream>
+
+extern "C" {
+#include "quantum.h"
+#include "timer.h"
+#include "debounce.h"
+
+void set_time(uint32_t t);
+void advance_time(uint32_t ms);
+}
+
+void DebounceTest::addEvents(std::initializer_list<DebounceTestEvent> events) {
+    events_.insert(events_.end(), events.begin(), events.end());
+}
+
+void DebounceTest::runEvents() {
+    /* Run the test multiple times, from 1kHz to 10kHz scan rate */
+    for (extra_iterations_ = 0; extra_iterations_ < 10; extra_iterations_++) {
+        if (time_jumps_) {
+            /* Don't advance time smoothly, jump to the next event (some tests require this) */
+            auto_advance_time_ = false;
+            runEventsInternal();
+        } else {
+            /* Run the test with both smooth and irregular time; it must produce the same result */
+            auto_advance_time_ = true;
+            runEventsInternal();
+            auto_advance_time_ = false;
+            runEventsInternal();
+        }
+    }
+}
+
+void DebounceTest::runEventsInternal() {
+    fast_timer_t previous = 0;
+    bool first = true;
+
+    /* Initialise keyboard with start time (offset to avoid testing at 0) and all keys UP */
+    debounce_init(MATRIX_ROWS);
+    set_time(time_offset_);
+    std::fill(std::begin(input_matrix_), std::end(input_matrix_), 0);
+    std::fill(std::begin(output_matrix_), std::end(output_matrix_), 0);
+
+    for (auto &event : events_) {
+        if (!auto_advance_time_) {
+            /* Jump to the next event */
+            set_time(time_offset_ + event.time_);
+        } else if (!first && event.time_ == previous + 1) {
+            /* This event immediately follows the previous one, don't make extra debounce() calls */
+            advance_time(1);
+        } else {
+            /* Fast forward to the time for this event, calling debounce() with no changes */
+            ASSERT_LT((time_offset_ + event.time_) - timer_read_fast(), 60000) << "Test tries to advance more than 1 minute of time";
+
+            while (timer_read_fast() != time_offset_ + event.time_) {
+                runDebounce(false);
+                checkCookedMatrix(false, "debounce() modified cooked matrix");
+                advance_time(1);
+            }
+        }
+
+        first = false;
+        previous = event.time_;
+
+        /* Prepare input matrix */
+        for (auto &input : event.inputs_) {
+            matrixUpdate(input_matrix_, "input", input);
+        }
+
+        /* Call debounce */
+        runDebounce(!event.inputs_.empty());
+
+        /* Prepare output matrix */
+        for (auto &output : event.outputs_) {
+            matrixUpdate(output_matrix_, "output", output);
+        }
+
+        /* Check output matrix has expected change events */
+        for (auto &output : event.outputs_) {
+            EXPECT_EQ(!!(cooked_matrix_[output.row_] & (1U << output.col_)), directionValue(output.direction_))
+                    << "Missing event at " << strTime()
+                    << " expected key " << output.row_ << "," << output.col_ << " " << directionLabel(output.direction_)
+                    << "\ninput_matrix: changed=" << !event.inputs_.empty() << "\n" << strMatrix(input_matrix_)
+                    << "\nexpected_matrix:\n" << strMatrix(output_matrix_)
+                    << "\nactual_matrix:\n" << strMatrix(cooked_matrix_);
+        }
+
+        /* Check output matrix has no other changes */
+        checkCookedMatrix(!event.inputs_.empty(), "debounce() cooked matrix does not match expected output matrix");
+
+        /* Perform some extra iterations of the matrix scan with no changes */
+        for (int i = 0; i < extra_iterations_; i++) {
+            runDebounce(false);
+            checkCookedMatrix(false, "debounce() modified cooked matrix");
+        }
+    }
+
+    /* Check that no further changes happen for 1 minute */
+    for (int i = 0; i < 60000; i++) {
+        runDebounce(false);
+        checkCookedMatrix(false, "debounce() modified cooked matrix");
+        advance_time(1);
+    }
+
+    debounce_free();
+}
+
+void DebounceTest::runDebounce(bool changed) {
+    std::copy(std::begin(input_matrix_), std::end(input_matrix_), std::begin(raw_matrix_));
+    std::copy(std::begin(output_matrix_), std::end(output_matrix_), std::begin(cooked_matrix_));
+
+    debounce(raw_matrix_, cooked_matrix_, MATRIX_ROWS, changed);
+
+    if (!std::equal(std::begin(input_matrix_), std::end(input_matrix_), std::begin(raw_matrix_))) {
+        FAIL() << "Fatal error: debounce() modified raw matrix at " << strTime()
+            << "\ninput_matrix: changed=" << changed << "\n" << strMatrix(input_matrix_)
+            << "\nraw_matrix:\n" << strMatrix(raw_matrix_);
+    }
+}
+
+void DebounceTest::checkCookedMatrix(bool changed, const std::string &error_message) {
+    if (!std::equal(std::begin(output_matrix_), std::end(output_matrix_), std::begin(cooked_matrix_))) {
+        FAIL() << "Unexpected event: " << error_message << " at " << strTime()
+            << "\ninput_matrix: changed=" << changed << "\n" << strMatrix(input_matrix_)
+            << "\nexpected_matrix:\n" << strMatrix(output_matrix_)
+            << "\nactual_matrix:\n" << strMatrix(cooked_matrix_);
+    }
+}
+
+std::string DebounceTest::strTime() {
+    std::stringstream text;
+
+    text << "time " << (timer_read_fast() - time_offset_)
+        << " (extra_iterations=" << extra_iterations_
+        << ", auto_advance_time=" << auto_advance_time_ << ")";
+
+    return text.str();
+}
+
+std::string DebounceTest::strMatrix(matrix_row_t matrix[]) {
+    std::stringstream text;
+
+    text << "\t" << std::setw(3) << "";
+    for (int col = 0; col < MATRIX_COLS; col++) {
+        text << " " << std::setw(2) << col;
+    }
+    text << "\n";
+
+    for (int row = 0; row < MATRIX_ROWS; row++) {
+        text << "\t" << std::setw(2) << row << ":";
+        for (int col = 0; col < MATRIX_COLS; col++) {
+            text << ((matrix[row] & (1U << col)) ? " XX" : " __");
+        }
+
+        text << "\n";
+    }
+
+    return text.str();
+}
+
+bool DebounceTest::directionValue(Direction direction) {
+    switch (direction) {
+    case DOWN:
+        return true;
+
+    case UP:
+        return false;
+    }
+}
+
+std::string DebounceTest::directionLabel(Direction direction) {
+    switch (direction) {
+    case DOWN:
+        return "DOWN";
+
+    case UP:
+        return "UP";
+    }
+}
+
+/* Modify a matrix and verify that events always specify a change */
+void DebounceTest::matrixUpdate(matrix_row_t matrix[], const std::string &name, const MatrixTestEvent &event) {
+    ASSERT_NE(!!(matrix[event.row_] & (1U << event.col_)), directionValue(event.direction_))
+        << "Test " << name << " at " << strTime()
+        << " sets key " << event.row_ << "," << event.col_ << " " << directionLabel(event.direction_)
+        << " but it is already " << directionLabel(event.direction_)
+        << "\n" << name << "_matrix:\n" << strMatrix(matrix);
+
+    switch (event.direction_) {
+    case DOWN:
+        matrix[event.row_] |= (1U << event.col_);
+        break;
+
+    case UP:
+        matrix[event.row_] &= ~(1U << event.col_);
+        break;
+    }
+}
+
+DebounceTestEvent::DebounceTestEvent(fast_timer_t time,
+        std::initializer_list<MatrixTestEvent> inputs,
+        std::initializer_list<MatrixTestEvent> outputs)
+        : time_(time), inputs_(inputs), outputs_(outputs) {
+}
+
+MatrixTestEvent::MatrixTestEvent(int row, int col, Direction direction)
+        : row_(row), col_(col), direction_(direction) {
+}
diff --git a/quantum/debounce/tests/debounce_test_common.h b/quantum/debounce/tests/debounce_test_common.h
new file mode 100644
index 0000000000..d87e310594
--- /dev/null
+++ b/quantum/debounce/tests/debounce_test_common.h
@@ -0,0 +1,83 @@
+/* Copyright 2021 Simon Arlott
+ *
+ * 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 "gtest/gtest.h"
+
+#include <initializer_list>
+#include <list>
+#include <string>
+
+extern "C" {
+#include "quantum.h"
+#include "timer.h"
+}
+
+enum Direction {
+    DOWN,
+    UP,
+};
+
+class MatrixTestEvent {
+public:
+    MatrixTestEvent(int row, int col, Direction direction);
+
+    const int row_;
+    const int col_;
+    const Direction direction_;
+};
+
+class DebounceTestEvent {
+public:
+    // 0, {{0, 1, DOWN}}, {{0, 1, DOWN}})
+    DebounceTestEvent(fast_timer_t time,
+        std::initializer_list<MatrixTestEvent> inputs,
+        std::initializer_list<MatrixTestEvent> outputs);
+
+    const fast_timer_t time_;
+    const std::list<MatrixTestEvent> inputs_;
+    const std::list<MatrixTestEvent> outputs_;
+};
+
+class DebounceTest : public ::testing::Test {
+protected:
+    void addEvents(std::initializer_list<DebounceTestEvent> events);
+    void runEvents();
+
+    fast_timer_t time_offset_ = 7777;
+    bool time_jumps_ = false;
+
+private:
+    static bool directionValue(Direction direction);
+    static std::string directionLabel(Direction direction);
+
+    void runEventsInternal();
+    void runDebounce(bool changed);
+    void checkCookedMatrix(bool changed, const std::string &error_message);
+    void matrixUpdate(matrix_row_t matrix[], const std::string &name, const MatrixTestEvent &event);
+
+    std::string strTime();
+    std::string strMatrix(matrix_row_t matrix[]);
+
+    std::list<DebounceTestEvent> events_;
+
+    matrix_row_t input_matrix_[MATRIX_ROWS];
+    matrix_row_t raw_matrix_[MATRIX_ROWS];
+    matrix_row_t cooked_matrix_[MATRIX_ROWS];
+    matrix_row_t output_matrix_[MATRIX_ROWS];
+
+    int extra_iterations_;
+    bool auto_advance_time_;
+};
diff --git a/quantum/debounce/tests/rules.mk b/quantum/debounce/tests/rules.mk
new file mode 100644
index 0000000000..29fda7889f
--- /dev/null
+++ b/quantum/debounce/tests/rules.mk
@@ -0,0 +1,39 @@
+# Copyright 2021 Simon Arlott
+#
+# 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/>.
+
+DEBOUNCE_COMMON_DEFS := -DMATRIX_ROWS=4 -DMATRIX_COLS=10 -DDEBOUNCE=5
+
+DEBOUNCE_COMMON_SRC := $(QUANTUM_PATH)/debounce/tests/debounce_test_common.cpp \
+	$(TMK_PATH)/common/test/timer.c
+
+debounce_sym_defer_g_DEFS := $(DEBOUNCE_COMMON_DEFS)
+debounce_sym_defer_g_SRC := $(DEBOUNCE_COMMON_SRC) \
+	$(QUANTUM_PATH)/debounce/sym_defer_g.c \
+	$(QUANTUM_PATH)/debounce/tests/sym_defer_g_tests.cpp
+
+debounce_sym_defer_pk_DEFS := $(DEBOUNCE_COMMON_DEFS)
+debounce_sym_defer_pk_SRC := $(DEBOUNCE_COMMON_SRC) \
+	$(QUANTUM_PATH)/debounce/sym_defer_pk.c \
+	$(QUANTUM_PATH)/debounce/tests/sym_defer_pk_tests.cpp
+
+debounce_sym_eager_pk_DEFS := $(DEBOUNCE_COMMON_DEFS)
+debounce_sym_eager_pk_SRC := $(DEBOUNCE_COMMON_SRC) \
+	$(QUANTUM_PATH)/debounce/sym_eager_pk.c \
+	$(QUANTUM_PATH)/debounce/tests/sym_eager_pk_tests.cpp
+
+debounce_sym_eager_pr_DEFS := $(DEBOUNCE_COMMON_DEFS)
+debounce_sym_eager_pr_SRC := $(DEBOUNCE_COMMON_SRC) \
+	$(QUANTUM_PATH)/debounce/sym_eager_pr.c \
+	$(QUANTUM_PATH)/debounce/tests/sym_eager_pr_tests.cpp
diff --git a/quantum/debounce/tests/sym_defer_g_tests.cpp b/quantum/debounce/tests/sym_defer_g_tests.cpp
new file mode 100644
index 0000000000..a56aecd8f3
--- /dev/null
+++ b/quantum/debounce/tests/sym_defer_g_tests.cpp
@@ -0,0 +1,223 @@
+/* Copyright 2021 Simon Arlott
+ *
+ * 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 "gtest/gtest.h"
+
+#include "debounce_test_common.h"
+
+TEST_F(DebounceTest, OneKeyShort1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+        /* 0ms delay (fast scan rate) */
+        {5, {{0, 1, UP}}, {}},
+
+        {10, {}, {{0, 1, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+        /* 1ms delay */
+        {6, {{0, 1, UP}}, {}},
+
+        {11, {}, {{0, 1, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort3) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+        /* 2ms delay */
+        {7, {{0, 1, UP}}, {}},
+
+        {12, {}, {{0, 1, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyTooQuick1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+        /* Release key exactly on the debounce time */
+        {5, {{0, 1, UP}}, {}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyTooQuick2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+        {6, {{0, 1, UP}}, {}},
+
+        /* Press key exactly on the debounce time */
+        {11, {{0, 1, DOWN}}, {}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyBouncing1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+        {1, {{0, 1, UP}}, {}},
+        {2, {{0, 1, DOWN}}, {}},
+        {3, {{0, 1, UP}}, {}},
+        {4, {{0, 1, DOWN}}, {}},
+        {5, {{0, 1, UP}}, {}},
+        {6, {{0, 1, DOWN}}, {}},
+        {11, {}, {{0, 1, DOWN}}}, /* 5ms after DOWN at time 7 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyBouncing2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+        {5, {}, {{0, 1, DOWN}}},
+        {6, {{0, 1, UP}}, {}},
+        {7, {{0, 1, DOWN}}, {}},
+        {8, {{0, 1, UP}}, {}},
+        {9, {{0, 1, DOWN}}, {}},
+        {10, {{0, 1, UP}}, {}},
+        {15, {}, {{0, 1, UP}}}, /* 5ms after UP at time 10 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyLong) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+
+        {25, {{0, 1, UP}}, {}},
+
+        {30, {}, {{0, 1, UP}}},
+
+        {50, {{0, 1, DOWN}}, {}},
+
+        {55, {}, {{0, 1, DOWN}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoKeysShort) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+        {1, {{0, 2, DOWN}}, {}},
+
+        {6, {}, {{0, 1, DOWN}, {0, 2, DOWN}}},
+
+        {7, {{0, 1, UP}}, {}},
+        {8, {{0, 2, UP}}, {}},
+
+        {13, {}, {{0, 1, UP}, {0, 2, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoKeysSimultaneous1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}, {0, 2, DOWN}}},
+        {6, {{0, 1, UP}, {0, 2, UP}}, {}},
+
+        {11, {}, {{0, 1, UP}, {0, 2, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoKeysSimultaneous2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+        {1, {{0, 2, DOWN}}, {}},
+
+        {5, {}, {}},
+        {6, {}, {{0, 1, DOWN}, {0, 2, DOWN}}},
+        {7, {{0, 1, UP}}, {}},
+        {8, {{0, 2, UP}}, {}},
+
+        {13, {}, {{0, 1, UP}, {0, 2, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        /* Processing is very late */
+        {300, {}, {{0, 1, DOWN}}},
+        /* Immediately release key */
+        {300, {{0, 1, UP}}, {}},
+
+        {305, {}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        /* Processing is very late */
+        {300, {}, {{0, 1, DOWN}}},
+        /* Release key after 1ms */
+        {301, {{0, 1, UP}}, {}},
+
+        {306, {}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan3) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        /* Release key before debounce expires */
+        {300, {{0, 1, UP}}, {}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan4) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        /* Processing is a bit late */
+        {50, {}, {{0, 1, DOWN}}},
+        /* Release key after 1ms */
+        {51, {{0, 1, UP}}, {}},
+
+        {56, {}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
diff --git a/quantum/debounce/tests/sym_defer_pk_tests.cpp b/quantum/debounce/tests/sym_defer_pk_tests.cpp
new file mode 100644
index 0000000000..1f3061e59c
--- /dev/null
+++ b/quantum/debounce/tests/sym_defer_pk_tests.cpp
@@ -0,0 +1,225 @@
+/* Copyright 2021 Simon Arlott
+ *
+ * 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 "gtest/gtest.h"
+
+#include "debounce_test_common.h"
+
+TEST_F(DebounceTest, OneKeyShort1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+        /* 0ms delay (fast scan rate) */
+        {5, {{0, 1, UP}}, {}},
+
+        {10, {}, {{0, 1, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+        /* 1ms delay */
+        {6, {{0, 1, UP}}, {}},
+
+        {11, {}, {{0, 1, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort3) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+        /* 2ms delay */
+        {7, {{0, 1, UP}}, {}},
+
+        {12, {}, {{0, 1, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyTooQuick1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+        /* Release key exactly on the debounce time */
+        {5, {{0, 1, UP}}, {}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyTooQuick2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+        {6, {{0, 1, UP}}, {}},
+
+        /* Press key exactly on the debounce time */
+        {11, {{0, 1, DOWN}}, {}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyBouncing1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+        {1, {{0, 1, UP}}, {}},
+        {2, {{0, 1, DOWN}}, {}},
+        {3, {{0, 1, UP}}, {}},
+        {4, {{0, 1, DOWN}}, {}},
+        {5, {{0, 1, UP}}, {}},
+        {6, {{0, 1, DOWN}}, {}},
+        {11, {}, {{0, 1, DOWN}}}, /* 5ms after DOWN at time 7 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyBouncing2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+        {5, {}, {{0, 1, DOWN}}},
+        {6, {{0, 1, UP}}, {}},
+        {7, {{0, 1, DOWN}}, {}},
+        {8, {{0, 1, UP}}, {}},
+        {9, {{0, 1, DOWN}}, {}},
+        {10, {{0, 1, UP}}, {}},
+        {15, {}, {{0, 1, UP}}}, /* 5ms after UP at time 10 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyLong) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+
+        {25, {{0, 1, UP}}, {}},
+
+        {30, {}, {{0, 1, UP}}},
+
+        {50, {{0, 1, DOWN}}, {}},
+
+        {55, {}, {{0, 1, DOWN}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoKeysShort) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+        {1, {{0, 2, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+        {6, {}, {{0, 2, DOWN}}},
+
+        {7, {{0, 1, UP}}, {}},
+        {8, {{0, 2, UP}}, {}},
+
+        {12, {}, {{0, 1, UP}}},
+        {13, {}, {{0, 2, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoKeysSimultaneous1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}, {0, 2, DOWN}}},
+        {6, {{0, 1, UP}, {0, 2, UP}}, {}},
+
+        {11, {}, {{0, 1, UP}, {0, 2, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoKeysSimultaneous2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+        {1, {{0, 2, DOWN}}, {}},
+
+        {5, {}, {{0, 1, DOWN}}},
+        {6, {{0, 1, UP}}, {{0, 2, DOWN}}},
+        {7, {{0, 2, UP}}, {}},
+
+        {11, {}, {{0, 1, UP}}},
+        {12, {}, {{0, 2, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        /* Processing is very late */
+        {300, {}, {{0, 1, DOWN}}},
+        /* Immediately release key */
+        {300, {{0, 1, UP}}, {}},
+
+        {305, {}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        /* Processing is very late */
+        {300, {}, {{0, 1, DOWN}}},
+        /* Release key after 1ms */
+        {301, {{0, 1, UP}}, {}},
+
+        {306, {}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan3) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        /* Release key before debounce expires */
+        {300, {{0, 1, UP}}, {}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan4) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {}},
+
+        /* Processing is a bit late */
+        {50, {}, {{0, 1, DOWN}}},
+        /* Release key after 1ms */
+        {51, {{0, 1, UP}}, {}},
+
+        {56, {}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
diff --git a/quantum/debounce/tests/sym_eager_pk_tests.cpp b/quantum/debounce/tests/sym_eager_pk_tests.cpp
new file mode 100644
index 0000000000..e0fc205e33
--- /dev/null
+++ b/quantum/debounce/tests/sym_eager_pk_tests.cpp
@@ -0,0 +1,237 @@
+/* Copyright 2021 Simon Arlott
+ *
+ * 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 "gtest/gtest.h"
+
+#include "debounce_test_common.h"
+
+TEST_F(DebounceTest, OneKeyShort1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 1ms delay (debounce has not yet finished) */
+        {6, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 2ms delay (debounce has not yet finished) */
+        {7, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort3) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 3ms delay (debounce has not yet finished) */
+        {8, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort4) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 4ms delay (debounce has not yet finished) */
+        {9, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort5) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 5ms delay (debounce has finished) */
+        {10, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort6) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key after after 6ms delay (debounce has finished) */
+        {11, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyBouncing1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+        {2, {{0, 1, DOWN}}, {}},
+        {3, {{0, 1, UP}}, {}},
+        {4, {{0, 1, DOWN}}, {}},
+        {5, {{0, 1, UP}}, {{0, 1, UP}}},
+        /* Press key again after 1ms delay (debounce has not yet finished) */
+        {6, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyBouncing2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        /* Change twice in the same time period */
+        {1, {{0, 1, UP}}, {}},
+        {1, {{0, 1, DOWN}}, {}},
+        /* Change three times in the same time period */
+        {2, {{0, 1, UP}}, {}},
+        {2, {{0, 1, DOWN}}, {}},
+        {2, {{0, 1, UP}}, {}},
+        /* Change three times in the same time period */
+        {3, {{0, 1, DOWN}}, {}},
+        {3, {{0, 1, UP}}, {}},
+        {3, {{0, 1, DOWN}}, {}},
+        /* Change twice in the same time period */
+        {4, {{0, 1, UP}}, {}},
+        {4, {{0, 1, DOWN}}, {}},
+        {5, {{0, 1, UP}}, {{0, 1, UP}}},
+        /* Press key again after 1ms delay (debounce has not yet finished) */
+        {6, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyLong) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        {25, {{0, 1, UP}}, {{0, 1, UP}}},
+
+        {50, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoKeysShort) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+        {2, {{0, 2, DOWN}}, {{0, 2, DOWN}}},
+        {3, {{0, 2, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 1ms delay (debounce has not yet finished) */
+        {6, {{0, 1, DOWN}}, {}},
+        {7, {}, {{0, 2, UP}}},
+
+        /* Press key again after 1ms delay (debounce has not yet finished) */
+        {9, {{0, 2, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+
+        {12, {}, {{0, 2, DOWN}}}, /* 5ms after UP at time 7 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is very late but the change will now be accepted */
+        {300, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is very late but the change will now be accepted even with a 1 scan delay */
+        {300, {}, {}},
+        {300, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan3) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is very late but the change will now be accepted even with a 1ms delay */
+        {300, {}, {}},
+        {301, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan4) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is a bit late but the change will now be accepted */
+        {50, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan5) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is very late but the change will now be accepted even with a 1 scan delay */
+        {50, {}, {}},
+        {50, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan6) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is very late but the change will now be accepted even with a 1ms delay */
+        {50, {}, {}},
+        {51, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
diff --git a/quantum/debounce/tests/sym_eager_pr_tests.cpp b/quantum/debounce/tests/sym_eager_pr_tests.cpp
new file mode 100644
index 0000000000..2c4bca127e
--- /dev/null
+++ b/quantum/debounce/tests/sym_eager_pr_tests.cpp
@@ -0,0 +1,280 @@
+/* Copyright 2021 Simon Arlott
+ *
+ * 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 "gtest/gtest.h"
+
+#include "debounce_test_common.h"
+
+TEST_F(DebounceTest, OneKeyShort1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 1ms delay (debounce has not yet finished) */
+        {6, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 2ms delay (debounce has not yet finished) */
+        {7, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort3) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 3ms delay (debounce has not yet finished) */
+        {8, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort4) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 4ms delay (debounce has not yet finished) */
+        {9, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort5) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 5ms delay (debounce has finished) */
+        {10, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyShort6) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key after after 6ms delay (debounce has finished) */
+        {11, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyBouncing1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+        {2, {{0, 1, DOWN}}, {}},
+        {3, {{0, 1, UP}}, {}},
+        {4, {{0, 1, DOWN}}, {}},
+        {5, {{0, 1, UP}}, {{0, 1, UP}}},
+        /* Press key again after 1ms delay (debounce has not yet finished) */
+        {6, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyBouncing2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        /* Change twice in the same time period */
+        {1, {{0, 1, UP}}, {}},
+        {1, {{0, 1, DOWN}}, {}},
+        /* Change three times in the same time period */
+        {2, {{0, 1, UP}}, {}},
+        {2, {{0, 1, DOWN}}, {}},
+        {2, {{0, 1, UP}}, {}},
+        /* Change three times in the same time period */
+        {3, {{0, 1, DOWN}}, {}},
+        {3, {{0, 1, UP}}, {}},
+        {3, {{0, 1, DOWN}}, {}},
+        /* Change twice in the same time period */
+        {4, {{0, 1, UP}}, {}},
+        {4, {{0, 1, DOWN}}, {}},
+        {5, {{0, 1, UP}}, {{0, 1, UP}}},
+        /* Press key again after 1ms delay (debounce has not yet finished) */
+        {6, {{0, 1, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyLong) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        {25, {{0, 1, UP}}, {{0, 1, UP}}},
+
+        {50, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoRowsShort) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+        {2, {{2, 0, DOWN}}, {{2, 0, DOWN}}},
+        {3, {{2, 0, UP}}, {}},
+
+        {5, {}, {{0, 1, UP}}},
+        /* Press key again after 1ms delay (debounce has not yet finished) */
+        {6, {{0, 1, DOWN}}, {}},
+        {7, {}, {{2, 0, UP}}},
+
+        /* Press key again after 1ms delay (debounce has not yet finished) */
+        {9, {{2, 0, DOWN}}, {}},
+        {10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */
+
+        {12, {}, {{2, 0, DOWN}}}, /* 5ms after UP at time 7 */
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoKeysOverlap) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+        {1, {{0, 1, UP}}, {}},
+        /* Press a second key during the first debounce */
+        {2, {{0, 2, DOWN}}, {}},
+
+        /* Key registers as soon as debounce finishes, 5ms after time 0 */
+        {5, {}, {{0, 1, UP}, {0, 2, DOWN}}},
+        {6, {{0, 1, DOWN}}, {}},
+
+        /* Key registers as soon as debounce finishes, 5ms after time 5 */
+        {10, {}, {{0, 1, DOWN}}},
+        /* Release both keys */
+        {11, {{0, 1, UP}}, {}},
+        {12, {{0, 2, UP}}, {}},
+
+        /* Keys register as soon as debounce finishes, 5ms after time 10 */
+        {15, {}, {{0, 1, UP}, {0, 2, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoKeysSimultaneous1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {{0, 1, DOWN}, {0, 2, DOWN}}},
+        {20, {{0, 1, UP}}, {{0, 1, UP}}},
+        {21, {{0, 2, UP}}, {}},
+
+        /* Key registers as soon as debounce finishes, 5ms after time 20 */
+        {25, {}, {{0, 2, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, TwoKeysSimultaneous2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {{0, 1, DOWN}, {0, 2, DOWN}}},
+        {20, {{0, 1, UP}, {0, 2, UP}}, {{0, 1, UP}, {0, 2, UP}}},
+    });
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan1) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is very late but the change will now be accepted */
+        {300, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan2) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is very late but the change will now be accepted even with a 1 scan delay */
+        {300, {}, {}},
+        {300, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan3) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is very late but the change will now be accepted even with a 1ms delay */
+        {300, {}, {}},
+        {301, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan4) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is a bit late but the change will now be accepted */
+        {50, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan5) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is very late but the change will now be accepted even with a 1 scan delay */
+        {50, {}, {}},
+        {50, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
+
+TEST_F(DebounceTest, OneKeyDelayedScan6) {
+    addEvents({ /* Time, Inputs, Outputs */
+        {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
+
+        /* Processing is very late but the change will now be accepted even with a 1ms delay */
+        {50, {}, {}},
+        {51, {{0, 1, UP}}, {{0, 1, UP}}},
+    });
+    time_jumps_ = true;
+    runEvents();
+}
diff --git a/quantum/debounce/tests/testlist.mk b/quantum/debounce/tests/testlist.mk
new file mode 100644
index 0000000000..16ce8a0a8e
--- /dev/null
+++ b/quantum/debounce/tests/testlist.mk
@@ -0,0 +1,5 @@
+TEST_LIST += \
+	debounce_sym_defer_g \
+	debounce_sym_defer_pk \
+	debounce_sym_eager_pk \
+	debounce_sym_eager_pr