diff --git a/tests/test_helpers_hex_formatting.cpp b/tests/test_helpers_hex_formatting.cpp
new file mode 100644
index 00000000000..4c39ff69134
--- /dev/null
+++ b/tests/test_helpers_hex_formatting.cpp
@@ -0,0 +1,212 @@
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+
+// Copy the implementations to test them in isolation
+
+inline char format_hex_char(uint8_t v, char base) { return v >= 10 ? base + (v - 10) : '0' + v; }
+inline char format_hex_char(uint8_t v) { return format_hex_char(v, 'a'); }
+inline char format_hex_pretty_char(uint8_t v) { return format_hex_char(v, 'A'); }
+
+constexpr size_t format_hex_pretty_size(size_t byte_count) { return byte_count * 3; }
+
+static char *format_hex_internal(char *buffer, size_t buffer_size, const uint8_t *data, size_t length, char separator,
+                                 char base) {
+  if (length == 0) {
+    buffer[0] = '\0';
+    return buffer;
+  }
+  uint8_t stride = separator ? 3 : 2;
+  size_t max_bytes = separator ? (buffer_size / stride) : ((buffer_size - 1) / stride);
+  if (max_bytes == 0) {
+    buffer[0] = '\0';
+    return buffer;
+  }
+  if (length > max_bytes) {
+    length = max_bytes;
+  }
+  for (size_t i = 0; i < length; i++) {
+    size_t pos = i * stride;
+    buffer[pos] = format_hex_char(data[i] >> 4, base);
+    buffer[pos + 1] = format_hex_char(data[i] & 0x0F, base);
+    if (separator && i < length - 1) {
+      buffer[pos + 2] = separator;
+    }
+  }
+  buffer[length * stride - (separator ? 1 : 0)] = '\0';
+  return buffer;
+}
+
+char *format_hex_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length) {
+  return format_hex_internal(buffer, buffer_size, data, length, 0, 'a');
+}
+
+char *format_hex_pretty_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length, char separator) {
+  return format_hex_internal(buffer, buffer_size, data, length, separator, 'A');
+}
+
+template<size_t N>
+char *format_hex_pretty_to(char (&buffer)[N], const uint8_t *data, size_t length, char separator = ':') {
+  return format_hex_pretty_to(buffer, N, data, length, separator);
+}
+
+static constexpr size_t MAC_ADDRESS_SIZE = 6;
+static constexpr size_t MAC_ADDRESS_PRETTY_BUFFER_SIZE = format_hex_pretty_size(MAC_ADDRESS_SIZE);
+static constexpr size_t MAC_ADDRESS_BUFFER_SIZE = MAC_ADDRESS_SIZE * 2 + 1;
+
+inline void format_mac_addr_upper(const uint8_t *mac, char *output) {
+  format_hex_pretty_to(output, MAC_ADDRESS_PRETTY_BUFFER_SIZE, mac, MAC_ADDRESS_SIZE, ':');
+}
+
+inline void format_mac_addr_lower_no_sep(const uint8_t *mac, char *output) {
+  format_hex_to(output, MAC_ADDRESS_BUFFER_SIZE, mac, MAC_ADDRESS_SIZE);
+}
+
+// Tests
+
+void test_format_hex_char_base() {
+  assert(format_hex_char(0, 'a') == '0');
+  assert(format_hex_char(9, 'a') == '9');
+  assert(format_hex_char(10, 'a') == 'a');
+  assert(format_hex_char(15, 'a') == 'f');
+  assert(format_hex_char(0, 'A') == '0');
+  assert(format_hex_char(10, 'A') == 'A');
+  assert(format_hex_char(15, 'A') == 'F');
+  printf("✓ format_hex_char with base\n");
+}
+
+void test_format_hex_char_lowercase() {
+  assert(format_hex_char(0) == '0');
+  assert(format_hex_char(10) == 'a');
+  assert(format_hex_char(15) == 'f');
+  printf("✓ format_hex_char lowercase\n");
+}
+
+void test_format_hex_pretty_char_uppercase() {
+  assert(format_hex_pretty_char(0) == '0');
+  assert(format_hex_pretty_char(10) == 'A');
+  assert(format_hex_pretty_char(15) == 'F');
+  printf("✓ format_hex_pretty_char uppercase\n");
+}
+
+void test_format_hex_to() {
+  uint8_t data[] = {0xde, 0xad, 0xbe, 0xef};
+  char buf[9];
+  format_hex_to(buf, sizeof(buf), data, 4);
+  assert(strcmp(buf, "deadbeef") == 0);
+  printf("✓ format_hex_to lowercase\n");
+}
+
+void test_format_hex_pretty_to_colon() {
+  uint8_t data[] = {0xDE, 0xAD, 0xBE, 0xEF};
+  char buf[12];
+  format_hex_pretty_to(buf, sizeof(buf), data, 4, ':');
+  assert(strcmp(buf, "DE:AD:BE:EF") == 0);
+  printf("✓ format_hex_pretty_to with colon\n");
+}
+
+void test_format_hex_pretty_to_dot() {
+  uint8_t data[] = {0xAA, 0xBB, 0xCC};
+  char buf[9];
+  format_hex_pretty_to(buf, sizeof(buf), data, 3, '.');
+  assert(strcmp(buf, "AA.BB.CC") == 0);
+  printf("✓ format_hex_pretty_to with dot\n");
+}
+
+void test_buffer_overflow_protection() {
+  uint8_t data[] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE};
+  char buf[11];
+  format_hex_pretty_to(buf, 11, data, 5, ':');
+  assert(strcmp(buf, "AA:BB:CC") == 0);
+  printf("✓ buffer overflow protection\n");
+}
+
+void test_exact_fit() {
+  uint8_t data[] = {0xAA, 0xBB, 0xCC, 0xDD};
+  char buf[12];
+  format_hex_pretty_to(buf, 12, data, 4, ':');
+  assert(strcmp(buf, "AA:BB:CC:DD") == 0);
+  printf("✓ exact fit buffer\n");
+}
+
+void test_mac_addr_upper() {
+  uint8_t mac[] = {0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
+  char buf[18];
+  format_mac_addr_upper(mac, buf);
+  assert(strcmp(buf, "AA:BB:CC:DD:EE:FF") == 0);
+  printf("✓ format_mac_addr_upper\n");
+}
+
+void test_mac_addr_lower_no_sep() {
+  uint8_t mac[] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};
+  char buf[13];
+  format_mac_addr_lower_no_sep(mac, buf);
+  assert(strcmp(buf, "aabbccddeeff") == 0);
+  printf("✓ format_mac_addr_lower_no_sep\n");
+}
+
+void test_empty() {
+  uint8_t data[] = {0xAA};
+  char buf[12];
+  format_hex_pretty_to(buf, sizeof(buf), data, 0, ':');
+  assert(strcmp(buf, "") == 0);
+  printf("✓ empty data\n");
+}
+
+void test_single_byte() {
+  uint8_t data[] = {0x42};
+  char buf[3];
+  format_hex_pretty_to(buf, sizeof(buf), data, 1, ':');
+  assert(strcmp(buf, "42") == 0);
+  printf("✓ single byte\n");
+}
+
+void test_template() {
+  uint8_t data[] = {0xDE, 0xAD, 0xBE, 0xEF};
+  char buf[format_hex_pretty_size(4)];
+  format_hex_pretty_to(buf, data, 4);
+  assert(strcmp(buf, "DE:AD:BE:EF") == 0);
+  printf("✓ template version\n");
+}
+
+void test_no_separator() {
+  uint8_t data[] = {0xDE, 0xAD};
+  char buf[5];
+  format_hex_pretty_to(buf, sizeof(buf), data, 2, 0);
+  assert(strcmp(buf, "DEAD") == 0);
+  printf("✓ no separator\n");
+}
+
+void test_constexpr() {
+  static_assert(format_hex_pretty_size(1) == 3, "");
+  static_assert(format_hex_pretty_size(4) == 12, "");
+  static_assert(format_hex_pretty_size(6) == 18, "");
+  static_assert(MAC_ADDRESS_SIZE == 6, "");
+  static_assert(MAC_ADDRESS_PRETTY_BUFFER_SIZE == 18, "");
+  static_assert(MAC_ADDRESS_BUFFER_SIZE == 13, "");
+  printf("✓ constexpr values\n");
+}
+
+int main() {
+  printf("Running hex formatting tests...\n\n");
+
+  test_format_hex_char_base();
+  test_format_hex_char_lowercase();
+  test_format_hex_pretty_char_uppercase();
+  test_format_hex_to();
+  test_format_hex_pretty_to_colon();
+  test_format_hex_pretty_to_dot();
+  test_buffer_overflow_protection();
+  test_exact_fit();
+  test_mac_addr_upper();
+  test_mac_addr_lower_no_sep();
+  test_empty();
+  test_single_byte();
+  test_template();
+  test_no_separator();
+  test_constexpr();
+
+  printf("\n✅ All 15 tests passed!\n");
+  return 0;
+}