Format code according to conventions (#15193)

22 files changed, 438 insertions, 359 deletions

diff --git a/quantum/action.c b/quantum/action.c
index be135f18f2..208690f5e4 100644
--- a/quantum/action.c
+++ b/quantum/action.c
@@ -782,9 +782,10 @@ void register_code(uint8_t code) {
     }
 #endif
 
-    else if IS_KEY (code) {
-        // TODO: should push command_proc out of this block?
-        if (command_proc(code)) return;
+    else if
+        IS_KEY(code) {
+            // TODO: should push command_proc out of this block?
+            if (command_proc(code)) return;
 
 #ifndef NO_ACTION_ONESHOT
 /* TODO: remove
@@ -801,33 +802,35 @@ void register_code(uint8_t code) {
         } else
 */
 #endif
-        {
-            // Force a new key press if the key is already pressed
-            // without this, keys with the same keycode, but different
-            // modifiers will be reported incorrectly, see issue #1708
-            if (is_key_pressed(keyboard_report, code)) {
-                del_key(code);
+            {
+                // Force a new key press if the key is already pressed
+                // without this, keys with the same keycode, but different
+                // modifiers will be reported incorrectly, see issue #1708
+                if (is_key_pressed(keyboard_report, code)) {
+                    del_key(code);
+                    send_keyboard_report();
+                }
+                add_key(code);
                 send_keyboard_report();
             }
-            add_key(code);
+        }
+    else if
+        IS_MOD(code) {
+            add_mods(MOD_BIT(code));
             send_keyboard_report();
         }
-    } else if IS_MOD (code) {
-        add_mods(MOD_BIT(code));
-        send_keyboard_report();
-    }
 #ifdef EXTRAKEY_ENABLE
-    else if IS_SYSTEM (code) {
-        host_system_send(KEYCODE2SYSTEM(code));
-    } else if IS_CONSUMER (code) {
-        host_consumer_send(KEYCODE2CONSUMER(code));
-    }
+    else if
+        IS_SYSTEM(code) { host_system_send(KEYCODE2SYSTEM(code)); }
+    else if
+        IS_CONSUMER(code) { host_consumer_send(KEYCODE2CONSUMER(code)); }
 #endif
 #ifdef MOUSEKEY_ENABLE
-    else if IS_MOUSEKEY (code) {
-        mousekey_on(code);
-        mousekey_send();
-    }
+    else if
+        IS_MOUSEKEY(code) {
+            mousekey_on(code);
+            mousekey_send();
+        }
 #endif
 }
 
@@ -872,22 +875,26 @@ void unregister_code(uint8_t code) {
     }
 #endif
 
-    else if IS_KEY (code) {
-        del_key(code);
-        send_keyboard_report();
-    } else if IS_MOD (code) {
-        del_mods(MOD_BIT(code));
-        send_keyboard_report();
-    } else if IS_SYSTEM (code) {
-        host_system_send(0);
-    } else if IS_CONSUMER (code) {
-        host_consumer_send(0);
-    }
+    else if
+        IS_KEY(code) {
+            del_key(code);
+            send_keyboard_report();
+        }
+    else if
+        IS_MOD(code) {
+            del_mods(MOD_BIT(code));
+            send_keyboard_report();
+        }
+    else if
+        IS_SYSTEM(code) { host_system_send(0); }
+    else if
+        IS_CONSUMER(code) { host_consumer_send(0); }
 #ifdef MOUSEKEY_ENABLE
-    else if IS_MOUSEKEY (code) {
-        mousekey_off(code);
-        mousekey_send();
-    }
+    else if
+        IS_MOUSEKEY(code) {
+            mousekey_off(code);
+            mousekey_send();
+        }
 #endif
 }
 
diff --git a/quantum/action.h b/quantum/action.h
index 8a357ded87..b562f18c5b 100644
--- a/quantum/action.h
+++ b/quantum/action.h
@@ -88,7 +88,7 @@ extern bool disable_action_cache;
 
 /* Code for handling one-handed key modifiers. */
 #ifdef SWAP_HANDS_ENABLE
-extern bool                   swap_hands;
+extern bool           swap_hands;
 extern const keypos_t PROGMEM hand_swap_config[MATRIX_ROWS][MATRIX_COLS];
 #    if (MATRIX_COLS <= 8)
 typedef uint8_t swap_state_row_t;
diff --git a/quantum/action_tapping.c b/quantum/action_tapping.c
index 36839f9faf..60e56fb811 100644
--- a/quantum/action_tapping.c
+++ b/quantum/action_tapping.c
@@ -18,11 +18,11 @@
 #    define IS_TAPPING_PRESSED() (IS_TAPPING() && tapping_key.event.pressed)
 #    define IS_TAPPING_RELEASED() (IS_TAPPING() && !tapping_key.event.pressed)
 #    define IS_TAPPING_KEY(k) (IS_TAPPING() && KEYEQ(tapping_key.event.key, (k)))
-#ifndef COMBO_ENABLE
-#    define IS_TAPPING_RECORD(r) (IS_TAPPING() && KEYEQ(tapping_key.event.key, (r->event.key)))
-#else
-#    define IS_TAPPING_RECORD(r) (IS_TAPPING() && KEYEQ(tapping_key.event.key, (r->event.key)) && tapping_key.keycode == r->keycode)
-#endif
+#    ifndef COMBO_ENABLE
+#        define IS_TAPPING_RECORD(r) (IS_TAPPING() && KEYEQ(tapping_key.event.key, (r->event.key)))
+#    else
+#        define IS_TAPPING_RECORD(r) (IS_TAPPING() && KEYEQ(tapping_key.event.key, (r->event.key)) && tapping_key.keycode == r->keycode)
+#    endif
 
 __attribute__((weak)) uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { return TAPPING_TERM; }
 
@@ -212,11 +212,15 @@ bool process_tapping(keyrecord_t *keyp) {
                     if (tapping_key.tap.count > 1) {
                         debug("Tapping: Start new tap with releasing last tap(>1).\n");
                         // unregister key
-                        process_record(&(keyrecord_t){.tap = tapping_key.tap, .event.key = tapping_key.event.key, .event.time = event.time, .event.pressed = false,
-#ifdef COMBO_ENABLE
-                                .keycode = tapping_key.keycode,
-#endif
-                                });
+                        process_record(&(keyrecord_t){
+                            .tap           = tapping_key.tap,
+                            .event.key     = tapping_key.event.key,
+                            .event.time    = event.time,
+                            .event.pressed = false,
+#    ifdef COMBO_ENABLE
+                            .keycode = tapping_key.keycode,
+#    endif
+                        });
                     } else {
                         debug("Tapping: Start while last tap(1).\n");
                     }
@@ -254,11 +258,15 @@ bool process_tapping(keyrecord_t *keyp) {
                     if (tapping_key.tap.count > 1) {
                         debug("Tapping: Start new tap with releasing last timeout tap(>1).\n");
                         // unregister key
-                        process_record(&(keyrecord_t){.tap = tapping_key.tap, .event.key = tapping_key.event.key, .event.time = event.time, .event.pressed = false,
-#ifdef COMBO_ENABLE
-                                .keycode = tapping_key.keycode,
-#endif
-                                });
+                        process_record(&(keyrecord_t){
+                            .tap           = tapping_key.tap,
+                            .event.key     = tapping_key.event.key,
+                            .event.time    = event.time,
+                            .event.pressed = false,
+#    ifdef COMBO_ENABLE
+                            .keycode = tapping_key.keycode,
+#    endif
+                        });
                     } else {
                         debug("Tapping: Start while last timeout tap(1).\n");
                     }
diff --git a/quantum/debounce/asym_eager_defer_pk.c b/quantum/debounce/asym_eager_defer_pk.c
index 24380dc5e5..81f39383c4 100644
--- a/quantum/debounce/asym_eager_defer_pk.c
+++ b/quantum/debounce/asym_eager_defer_pk.c
@@ -46,17 +46,17 @@ When no state changes have occured for DEBOUNCE milliseconds, we push the state.
 #define ROW_SHIFTER ((matrix_row_t)1)
 
 typedef struct {
-    bool pressed : 1;
+    bool    pressed : 1;
     uint8_t time : 7;
 } debounce_counter_t;
 
 #if DEBOUNCE > 0
 static debounce_counter_t *debounce_counters;
-static fast_timer_t last_time;
-static bool counters_need_update;
-static bool matrix_need_update;
+static fast_timer_t        last_time;
+static bool                counters_need_update;
+static bool                matrix_need_update;
 
-#define DEBOUNCE_ELAPSED 0
+#    define DEBOUNCE_ELAPSED 0
 
 static void update_debounce_counters_and_transfer_if_expired(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, uint8_t elapsed_time);
 static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows);
@@ -64,7 +64,7 @@ static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], ui
 // we use num_rows rather than MATRIX_ROWS to support split keyboards
 void debounce_init(uint8_t num_rows) {
     debounce_counters = malloc(num_rows * MATRIX_COLS * sizeof(debounce_counter_t));
-    int i = 0;
+    int i             = 0;
     for (uint8_t r = 0; r < num_rows; r++) {
         for (uint8_t c = 0; c < MATRIX_COLS; c++) {
             debounce_counters[i++].time = DEBOUNCE_ELAPSED;
@@ -81,10 +81,10 @@ void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool
     bool updated_last = false;
 
     if (counters_need_update) {
-        fast_timer_t now = timer_read_fast();
+        fast_timer_t now          = timer_read_fast();
         fast_timer_t elapsed_time = TIMER_DIFF_FAST(now, last_time);
 
-        last_time = now;
+        last_time    = now;
         updated_last = true;
         if (elapsed_time > UINT8_MAX) {
             elapsed_time = UINT8_MAX;
@@ -108,7 +108,7 @@ static void update_debounce_counters_and_transfer_if_expired(matrix_row_t raw[],
     debounce_counter_t *debounce_pointer = debounce_counters;
 
     counters_need_update = false;
-    matrix_need_update = false;
+    matrix_need_update   = false;
 
     for (uint8_t row = 0; row < num_rows; row++) {
         for (uint8_t col = 0; col < MATRIX_COLS; col++) {
@@ -146,8 +146,8 @@ static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], ui
             if (delta & col_mask) {
                 if (debounce_pointer->time == DEBOUNCE_ELAPSED) {
                     debounce_pointer->pressed = (raw[row] & col_mask);
-                    debounce_pointer->time = DEBOUNCE;
-                    counters_need_update = true;
+                    debounce_pointer->time    = DEBOUNCE;
+                    counters_need_update      = true;
 
                     if (debounce_pointer->pressed) {
                         // key-down: eager
diff --git a/quantum/debounce/sym_defer_g.c b/quantum/debounce/sym_defer_g.c
index fbefd55ede..9155eb914c 100644
--- a/quantum/debounce/sym_defer_g.c
+++ b/quantum/debounce/sym_defer_g.c
@@ -25,7 +25,7 @@ When no state changes have occured for DEBOUNCE milliseconds, we push the state.
 #endif
 
 #if DEBOUNCE > 0
-static bool debouncing = false;
+static bool         debouncing = false;
 static fast_timer_t debouncing_time;
 
 void debounce_init(uint8_t num_rows) {}
diff --git a/quantum/debounce/sym_defer_pk.c b/quantum/debounce/sym_defer_pk.c
index 626a9be841..1b698ba347 100644
--- a/quantum/debounce/sym_defer_pk.c
+++ b/quantum/debounce/sym_defer_pk.c
@@ -49,7 +49,7 @@ static debounce_counter_t *debounce_counters;
 static fast_timer_t        last_time;
 static bool                counters_need_update;
 
-#define DEBOUNCE_ELAPSED 0
+#    define DEBOUNCE_ELAPSED 0
 
 static void update_debounce_counters_and_transfer_if_expired(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, uint8_t elapsed_time);
 static void start_debounce_counters(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows);
@@ -74,10 +74,10 @@ void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool
     bool updated_last = false;
 
     if (counters_need_update) {
-        fast_timer_t now = timer_read_fast();
+        fast_timer_t now          = timer_read_fast();
         fast_timer_t elapsed_time = TIMER_DIFF_FAST(now, last_time);
 
-        last_time = now;
+        last_time    = now;
         updated_last = true;
         if (elapsed_time > UINT8_MAX) {
             elapsed_time = UINT8_MAX;
diff --git a/quantum/debounce/sym_eager_pk.c b/quantum/debounce/sym_eager_pk.c
index 15a3242e68..9da000ea9a 100644
--- a/quantum/debounce/sym_eager_pk.c
+++ b/quantum/debounce/sym_eager_pk.c
@@ -50,7 +50,7 @@ static fast_timer_t        last_time;
 static bool                counters_need_update;
 static bool                matrix_need_update;
 
-#define DEBOUNCE_ELAPSED 0
+#    define DEBOUNCE_ELAPSED 0
 
 static void update_debounce_counters(uint8_t num_rows, uint8_t elapsed_time);
 static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows);
@@ -75,10 +75,10 @@ void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool
     bool updated_last = false;
 
     if (counters_need_update) {
-        fast_timer_t now = timer_read_fast();
+        fast_timer_t now          = timer_read_fast();
         fast_timer_t elapsed_time = TIMER_DIFF_FAST(now, last_time);
 
-        last_time = now;
+        last_time    = now;
         updated_last = true;
         if (elapsed_time > UINT8_MAX) {
             elapsed_time = UINT8_MAX;
@@ -107,7 +107,7 @@ static void update_debounce_counters(uint8_t num_rows, uint8_t elapsed_time) {
         for (uint8_t col = 0; col < MATRIX_COLS; col++) {
             if (*debounce_pointer != DEBOUNCE_ELAPSED) {
                 if (*debounce_pointer <= elapsed_time) {
-                    *debounce_pointer = DEBOUNCE_ELAPSED;
+                    *debounce_pointer  = DEBOUNCE_ELAPSED;
                     matrix_need_update = true;
                 } else {
                     *debounce_pointer -= elapsed_time;
diff --git a/quantum/debounce/sym_eager_pr.c b/quantum/debounce/sym_eager_pr.c
index 2ad592c5a6..eda92a263b 100644
--- a/quantum/debounce/sym_eager_pr.c
+++ b/quantum/debounce/sym_eager_pr.c
@@ -49,7 +49,7 @@ static debounce_counter_t *debounce_counters;
 static fast_timer_t        last_time;
 static bool                counters_need_update;
 
-#define DEBOUNCE_ELAPSED 0
+#    define DEBOUNCE_ELAPSED 0
 
 static void update_debounce_counters(uint8_t num_rows, uint8_t elapsed_time);
 static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows);
@@ -71,10 +71,10 @@ void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool
     bool updated_last = false;
 
     if (counters_need_update) {
-        fast_timer_t now = timer_read_fast();
+        fast_timer_t now          = timer_read_fast();
         fast_timer_t elapsed_time = TIMER_DIFF_FAST(now, last_time);
 
-        last_time = now;
+        last_time    = now;
         updated_last = true;
         if (elapsed_time > UINT8_MAX) {
             elapsed_time = UINT8_MAX;
@@ -102,7 +102,7 @@ static void update_debounce_counters(uint8_t num_rows, uint8_t elapsed_time) {
     for (uint8_t row = 0; row < num_rows; row++) {
         if (*debounce_pointer != DEBOUNCE_ELAPSED) {
             if (*debounce_pointer <= elapsed_time) {
-                *debounce_pointer = DEBOUNCE_ELAPSED;
+                *debounce_pointer  = DEBOUNCE_ELAPSED;
                 matrix_need_update = true;
             } else {
                 *debounce_pointer -= elapsed_time;
diff --git a/quantum/debounce/tests/asym_eager_defer_pk_tests.cpp b/quantum/debounce/tests/asym_eager_defer_pk_tests.cpp
index fe374c3dfa..44b4fe1956 100644
--- a/quantum/debounce/tests/asym_eager_defer_pk_tests.cpp
+++ b/quantum/debounce/tests/asym_eager_defer_pk_tests.cpp
@@ -19,7 +19,8 @@
 #include "debounce_test_common.h"
 
 TEST_F(DebounceTest, OneKeyShort1) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
         /* Release key after 1ms delay */
         {1, {{0, 1, UP}}, {}},
@@ -43,7 +44,8 @@ TEST_F(DebounceTest, OneKeyShort1) {
 }
 
 TEST_F(DebounceTest, OneKeyShort2) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
         /* Release key after 2ms delay */
         {2, {{0, 1, UP}}, {}},
@@ -58,7 +60,8 @@ TEST_F(DebounceTest, OneKeyShort2) {
 }
 
 TEST_F(DebounceTest, OneKeyShort3) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
         /* Release key after 3ms delay */
         {3, {{0, 1, UP}}, {}},
@@ -73,7 +76,8 @@ TEST_F(DebounceTest, OneKeyShort3) {
 }
 
 TEST_F(DebounceTest, OneKeyShort4) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
         /* Release key after 4ms delay */
         {4, {{0, 1, UP}}, {}},
@@ -88,7 +92,8 @@ TEST_F(DebounceTest, OneKeyShort4) {
 }
 
 TEST_F(DebounceTest, OneKeyShort5) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         /* Release key after 5ms delay */
@@ -102,7 +107,8 @@ TEST_F(DebounceTest, OneKeyShort5) {
 }
 
 TEST_F(DebounceTest, OneKeyShort6) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         /* Release key after 6ms delay */
@@ -116,7 +122,8 @@ TEST_F(DebounceTest, OneKeyShort6) {
 }
 
 TEST_F(DebounceTest, OneKeyShort7) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         /* Release key after 7ms delay */
@@ -130,7 +137,8 @@ TEST_F(DebounceTest, OneKeyShort7) {
 }
 
 TEST_F(DebounceTest, OneKeyShort8) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
         /* Release key after 1ms delay */
         {1, {{0, 1, UP}}, {}},
@@ -145,7 +153,8 @@ TEST_F(DebounceTest, OneKeyShort8) {
 }
 
 TEST_F(DebounceTest, OneKeyShort9) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
         /* Release key after 1ms delay */
         {1, {{0, 1, UP}}, {}},
@@ -159,7 +168,8 @@ TEST_F(DebounceTest, OneKeyShort9) {
 }
 
 TEST_F(DebounceTest, OneKeyBouncing1) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
         {1, {{0, 1, UP}}, {}},
         {2, {{0, 1, DOWN}}, {}},
@@ -185,7 +195,8 @@ TEST_F(DebounceTest, OneKeyBouncing1) {
 }
 
 TEST_F(DebounceTest, OneKeyBouncing2) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
         /* Change twice in the same time period */
         {1, {{0, 1, UP}}, {}},
@@ -217,7 +228,8 @@ TEST_F(DebounceTest, OneKeyBouncing2) {
 }
 
 TEST_F(DebounceTest, OneKeyLong) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         {25, {{0, 1, UP}}, {}},
@@ -236,7 +248,8 @@ TEST_F(DebounceTest, OneKeyLong) {
 }
 
 TEST_F(DebounceTest, TwoKeysShort) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
         {1, {{0, 2, DOWN}}, {{0, 2, DOWN}}},
         /* Release key after 2ms delay */
@@ -249,14 +262,14 @@ TEST_F(DebounceTest, TwoKeysShort) {
         {10, {}, {{0, 1, UP}}}, /* 5ms+5ms after DOWN at time 0 */
         /* Press key again after 1ms delay */
         {11, {{0, 1, DOWN}}, {{0, 1, DOWN}, {0, 2, UP}}}, /* 5ms+5ms after DOWN at time 0 */
-        {12, {{0, 2, DOWN}}, {{0, 2, DOWN}}}, /* 5ms+5ms after DOWN at time 0 */
+        {12, {{0, 2, DOWN}}, {{0, 2, DOWN}}},             /* 5ms+5ms after DOWN at time 0 */
     });
     runEvents();
 }
 
-
 TEST_F(DebounceTest, OneKeyDelayedScan1) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         /* Processing is very late, immediately release key */
@@ -269,7 +282,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan1) {
 }
 
 TEST_F(DebounceTest, OneKeyDelayedScan2) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         /* Processing is very late, immediately release key */
@@ -283,7 +297,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan2) {
 }
 
 TEST_F(DebounceTest, OneKeyDelayedScan3) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         /* Processing is very late */
@@ -298,7 +313,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan3) {
 }
 
 TEST_F(DebounceTest, OneKeyDelayedScan4) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         /* Processing is very late */
@@ -314,7 +330,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan4) {
 }
 
 TEST_F(DebounceTest, OneKeyDelayedScan5) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         {5, {{0, 1, UP}}, {}},
@@ -329,7 +346,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan5) {
 }
 
 TEST_F(DebounceTest, OneKeyDelayedScan6) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         {5, {{0, 1, UP}}, {}},
@@ -345,7 +363,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan6) {
 }
 
 TEST_F(DebounceTest, OneKeyDelayedScan7) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         {5, {{0, 1, UP}}, {}},
@@ -358,7 +377,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan7) {
 }
 
 TEST_F(DebounceTest, OneKeyDelayedScan8) {
-    addEvents({ /* Time, Inputs, Outputs */
+    addEvents({
+        /* Time, Inputs, Outputs */
         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
 
         /* Processing is a bit late */
diff --git a/quantum/debounce/tests/debounce_test_common.cpp b/quantum/debounce/tests/debounce_test_common.cpp
index 1c5e7c9f4e..f9414e571d 100644
--- a/quantum/debounce/tests/debounce_test_common.cpp
+++ b/quantum/debounce/tests/debounce_test_common.cpp
@@ -31,9 +31,7 @@ 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::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 */
@@ -54,7 +52,7 @@ void DebounceTest::runEvents() {
 
 void DebounceTest::runEventsInternal() {
     fast_timer_t previous = 0;
-    bool first = true;
+    bool         first    = true;
 
     /* Initialise keyboard with start time (offset to avoid testing at 0) and all keys UP */
     debounce_init(MATRIX_ROWS);
@@ -80,7 +78,7 @@ void DebounceTest::runEventsInternal() {
             }
         }
 
-        first = false;
+        first    = false;
         previous = event.time_;
 
         /* Prepare input matrix */
@@ -98,12 +96,7 @@ void DebounceTest::runEventsInternal() {
 
         /* 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_);
+            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 */
@@ -133,27 +126,20 @@ void DebounceTest::runDebounce(bool changed) {
     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_);
+        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_);
+        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_ << ")";
+    text << "time " << (timer_read_fast() - time_offset_) << " (extra_iterations=" << extra_iterations_ << ", auto_advance_time=" << auto_advance_time_ << ")";
 
     return text.str();
 }
@@ -181,49 +167,39 @@ std::string DebounceTest::strMatrix(matrix_row_t matrix[]) {
 
 bool DebounceTest::directionValue(Direction direction) {
     switch (direction) {
-    case DOWN:
-        return true;
+        case DOWN:
+            return true;
 
-    case UP:
-        return false;
+        case UP:
+            return false;
     }
 }
 
 std::string DebounceTest::directionLabel(Direction direction) {
     switch (direction) {
-    case DOWN:
-        return "DOWN";
+        case DOWN:
+            return "DOWN";
 
-    case UP:
-        return "UP";
+        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);
+    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 DOWN:
+            matrix[event.row_] |= (1U << event.col_);
+            break;
 
-    case UP:
-        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) {
-}
+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) {
-}
+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
index d87e310594..b7becb3782 100644
--- a/quantum/debounce/tests/debounce_test_common.h
+++ b/quantum/debounce/tests/debounce_test_common.h
@@ -31,36 +31,34 @@ enum Direction {
 };
 
 class MatrixTestEvent {
-public:
+   public:
     MatrixTestEvent(int row, int col, Direction direction);
 
-    const int row_;
-    const int col_;
+    const int       row_;
+    const int       col_;
     const Direction direction_;
 };
 
 class DebounceTestEvent {
-public:
+   public:
     // 0, {{0, 1, DOWN}}, {{0, 1, DOWN}})
-    DebounceTestEvent(fast_timer_t time,
-        std::initializer_list<MatrixTestEvent> inputs,
-        std::initializer_list<MatrixTestEvent> outputs);
+    DebounceTestEvent(fast_timer_t