How would you test a hardware driver without the actual hardware?

The most effective technique is dependency injection through function pointers. Instead of having the driver directly access hardware registers, define a "hardware interface" struct with function pointers for each low-level operation:

typedef struct {
    void (*write_reg)(uint32_t addr, uint32_t val);
    uint32_t (*read_reg)(uint32_t addr);
    void (*delay_us)(uint32_t us);
} hw_interface_t;

In production, these point to real register access functions. In unit tests, they point to mock functions that record what was written and return pre-programmed values. This lets you verify that the driver writes the correct values to the correct registers in the correct order, without touching real hardware. You can also inject error conditions — make read_reg() return a status register value indicating a timeout or NACK — to test error handling paths that are difficult to trigger on real hardware.

For integration-level testing, emulators like QEMU (for Cortex-M) or Renode provide a simulated MCU with modeled peripherals. You flash your actual firmware binary into the emulator and it executes on a virtual CPU with virtual UART, SPI, GPIO, and DMA controllers. Renode is particularly powerful because it models peripheral behavior accurately enough to test DMA transfers, interrupt timing, and multi-peripheral interactions. You can script test scenarios — "inject 50 bytes on the virtual UART RX at 115200 baud and verify the firmware echoes them back" — and run these tests in CI/CD pipelines on every commit.

A practical middle ground is hardware-in-the-loop (HIL) testing, where the MCU runs on a physical development board connected to a test host via a debug probe. The host scripts test sequences: send data over UART, toggle GPIO lines, capture logic analyzer traces, and verify the firmware's responses. This catches issues that pure software mocking misses — like DMA configuration errors, clock tree misconfiguration, or interrupt priority bugs — while still being automated and repeatable.