Testing Firmware on Your PC

// wrap_bug.cpp - a bug that needs 49 days of running to appear, found in a moment on a PC
#include <cstdint>
#include <cstdio>

// The tempting way to write a timeout.
static bool expired_naive(uint32_t now_ms, uint32_t start_ms, uint32_t limit_ms) {
    return now_ms >= start_ms + limit_ms;
}

// The way that survives the millisecond counter wrapping round to zero.
static bool expired_safe(uint32_t now_ms, uint32_t start_ms, uint32_t limit_ms) {
    return now_ms - start_ms >= limit_ms;
}

int main() {
    std::printf("a 32-bit millisecond counter wraps after %.1f days\n", 4294967296.0 / 86400000.0);

    struct Case {
        uint32_t start, now;
    };
    const Case cases[] = {
        {1000, 1016},                   // an ordinary afternoon: 16 ms after starting
        {0xFFFFFF00u, 0xFFFFFF10u},     // the same 16 ms, just before the counter wraps
    };
    for (const Case &c : cases) {
        std::printf("start 0x%08X, 16 ms later: naive says %-7s safe says %s\n", static_cast<unsigned>(c.start),
                    expired_naive(c.now, c.start, 500) ? "expired," : "waiting,",
                    expired_safe(c.now, c.start, 500) ? "expired" : "waiting");
    }
    return 0;
}

// unit_tests.cpp - unit tests for the ring buffer, with a test helper in a dozen lines
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <source_location>

// ---- the code under test: the ring buffer from Volume 05 ----
template <typename T, size_t N>
class RingBuffer {
public:
    bool push(T item) {
        if (count_ == N) {
            return false;
        }
        items_[head_] = item;
        head_ = (head_ + 1) % N;
        count_++;
        return true;
    }
    bool pop(T &item) {
        if (count_ == 0) {
            return false;
        }
        item = items_[tail_];
        tail_ = (tail_ + 1) % N;
        count_--;
        return true;
    }

private:
    T items_[N] = {};
    size_t head_ = 0;
    size_t tail_ = 0;
    size_t count_ = 0;
};

// ---- the test helper: counts results, and says where a check failed ----
static int passed = 0;
static int failed = 0;

static void check(bool ok, const char *what, std::source_location where = std::source_location::current()) {
    if (ok) {
        passed++;
    } else {
        failed++;
        std::printf("FAILED line %u: %s\n", static_cast<unsigned>(where.line()), what);
    }
}

// ---- the tests: each one builds what it needs, and checks one idea ----
static void test_new_buffer_is_empty() {
    RingBuffer<uint8_t, 4> rb;
    uint8_t b = 0;
    check(!rb.pop(b), "pop on a new buffer finds nothing");
}

static void test_items_come_out_in_order() {
    RingBuffer<uint8_t, 4> rb;
    check(rb.push(1) && rb.push(2) && rb.push(3), "three pushes succeed");
    uint8_t a = 0, b = 0, c = 0;
    check(rb.pop(a) && rb.pop(b) && rb.pop(c), "three pops succeed");
    check(a == 1 && b == 2 && c == 3, "items come out in the order they went in");
}

static void test_full_buffer_refuses() {
    RingBuffer<uint8_t, 4> rb;
    for (uint8_t i = 0; i < 4; i++) {
        check(rb.push(i), "the first four pushes succeed");
    }
    check(!rb.push(99), "the fifth push is refused");
}

static void test_room_again_after_pop() {
    RingBuffer<uint8_t, 4> rb;
    for (uint8_t i = 0; i < 4; i++) {
        rb.push(i);
    }
    uint8_t b = 0;
    rb.pop(b);
    check(rb.push(99), "after one pop there is room for one push");
}

int main() {
    test_new_buffer_is_empty();
    test_items_come_out_in_order();
    test_full_buffer_refuses();
    test_room_again_after_pop();
    std::printf("%d checks passed, %d failed\n", passed, failed);
    return failed == 0 ? 0 : 1;             // a non-zero exit tells a build script the tests failed
}

// mock.cpp - a fake, and a mock that checks the conversation with the hardware
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstring>

class SerialPort {
public:
    virtual ~SerialPort() = default;
    virtual void write(uint8_t byte) = 0;
};

// The code under test: a modem driver that must send "AT" and a carriage return.
static void send_command(SerialPort &port, const char *command) {
    for (const char *p = command; *p != '\0'; p++) {
        port.write(static_cast<uint8_t>(*p));
    }
    port.write('\r');
}

// A mock: it is told what it should receive, and reports the first difference.
class MockSerialPort : public SerialPort {
public:
    explicit MockSerialPort(const char *expected) : expected_(expected) {}
    void write(uint8_t byte) override {
        if (count_ < std::strlen(expected_) && byte != static_cast<uint8_t>(expected_[count_]) && !mismatch_) {
            mismatch_ = true;
            std::printf("  byte %zu: expected 0x%02X, got 0x%02X\n", count_,
                        static_cast<unsigned>(static_cast<uint8_t>(expected_[count_])), static_cast<unsigned>(byte));
        }
        count_++;
    }
    bool satisfied() const { return !mismatch_ && count_ == std::strlen(expected_); }

private:
    const char *expected_;
    size_t count_ = 0;
    bool mismatch_ = false;
};

int main() {
    std::printf("send_command(\"AT\"), expecting \"AT\\r\":\n");
    MockSerialPort good("AT\r");
    send_command(good, "AT");
    std::printf("  %s\n", good.satisfied() ? "as expected" : "NOT as expected");

    std::printf("send_command(\"AT\"), expecting \"AT\\r\\n\":\n");
    MockSerialPort strict("AT\r\n");
    send_command(strict, "AT");
    std::printf("  %s\n", strict.satisfied() ? "as expected" : "NOT as expected: a byte is missing");
    return 0;
}

#!/bin/sh
# run_tests.sh - what a CI server runs on every change: build with warnings as errors, then test.
# Usage: sh run_tests.sh tests.cpp
set -e                                  # stop at the first command that fails
g++ -std=c++20 -Wall -Wextra -Werror -fno-exceptions -fno-rtti -O1 "$1" -o /tmp/tests
/tmp/tests                              # a non-zero exit here stops the script, and fails the build
echo "build and tests passed"