test_jled.cpp

// JLed Unit tests (runs on host)
// Copyright 2017-2025 Jan Delgado jdelgado@gmx.net
#include <jled_base.h>  // NOLINT

#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <utility>
#include <vector>

#include "brightness.h"
#include "catch2/catch_amalgamated.hpp"
#include "hal_mock.h"              // NOLINT
#include "mock_brightness_eval.h"  // NOLINT

using jled::TJLed;

// TestJLed is a JLed class using HalMock, which implements the HAL protocol
// directly. This allows to test the code abstracted from the actual hardware
// in use.
class TestJLed : public TJLed<HalMock, TimeMock, uint8_t, TestJLed> {
    using TJLed<HalMock, TimeMock, uint8_t, TestJLed>::TJLed;
};
// instanciate for test coverage measurement
template class TJLed<HalMock, TimeMock, uint8_t, TestJLed>;

// Type aliases for 8-bit evaluators (used in tests)
using BlinkBrightnessEvaluator = jled::BlinkBrightnessEvaluator<uint8_t>;
using BreatheBrightnessEvaluator = jled::BreatheBrightnessEvaluator<uint8_t>;
using CandleBrightnessEvaluator = jled::CandleBrightnessEvaluator<uint8_t>;
using ConstantBrightnessEvaluator = jled::ConstantBrightnessEvaluator<uint8_t>;

// expected result when a JLed object is updated: return value
// of Update() and the current brightness
using ExpectedUpdate = std::pair<bool, uint8_t>;
using ExpectedUpdates = std::vector<ExpectedUpdate>;

// helper to check if a led evaluates to given sequence. TODO use a catch
// matcher
template<class T>
void check_led(T* led, const ExpectedUpdates& expected) {
    uint32_t time = 0;
    for (const auto& current : expected) {
        TimeMock::set_millis(time);
        const auto updated = led->Update();
        const auto val = led->GetHal().Value();
        UNSCOPED_INFO("t=" << time << ", actual=(" << (updated.IsRunning() ? "true" : "false")
                           << ", " << static_cast<int>(val) << "), expected=("
                           << (current.first ? "true" : "false") << ", "
                           << static_cast<int>(current.second) << ")");
        CHECK(current.first == updated.IsRunning());
        CHECK(current.second == val);
        time++;
    }
}

TEST_CASE("jled without effect does nothing", "[jled]") {
    auto led = TestJLed(1);
    CHECK(!led.Update());
}

TEST_CASE("On/Off function configuration", "[jled]") {
    // class used to access proteced fields during test
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            SECTION(
                "using On() effect uses a BrightnessEval that turns the LED "
                "on") {
                TestableJLed jled(1);
                jled.On(123);
                REQUIRE(jled.eval_storage_.type == jled::EvalType::CONSTANT);
                const auto& eval = jled.eval_storage_.data.constant;
                CHECK(123 == eval.duration_);
                CHECK(jled::BrightnessTraits<uint8_t>::kFullBrightness == eval.val_);
            }

            SECTION(
                "using Off() effect uses a BrightnessEval that turns the LED "
                "off") {
                TestableJLed jled(1);
                jled.Off(123);
                REQUIRE(jled.eval_storage_.type == jled::EvalType::CONSTANT);
                const auto& eval = jled.eval_storage_.data.constant;
                CHECK(123 == eval.duration_);
                CHECK(jled::BrightnessTraits<uint8_t>::kZeroBrightness == eval.val_);
            }

            SECTION("using Set() allows to set custom brightness level") {
                TestableJLed jled(1);
                jled.Set(123);
                REQUIRE(jled.eval_storage_.type == jled::EvalType::CONSTANT);
                const auto& eval = jled.eval_storage_.data.constant;
                CHECK(1 == eval.duration_);
                CHECK(123 == eval.val_);
            }

            SECTION("using Set(0) allows to turn LED off") {
                TestableJLed jled(1);
                jled.Set(0);
                REQUIRE(jled.eval_storage_.type == jled::EvalType::CONSTANT);
                const auto& eval = jled.eval_storage_.data.constant;
                CHECK(1 == eval.duration_);
                CHECK(jled::BrightnessTraits<uint8_t>::kZeroBrightness == eval.val_);
            }
        }
    };
    TestableJLed::test();
}

TEST_CASE("using Blink() configures BlinkBrightnessEvaluator", "[jled]") {
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            TestableJLed jled(1);
            jled.Blink(1, 2, 3);
            REQUIRE(jled.eval_storage_.type == jled::EvalType::BLINK);
            const auto& eval = jled.eval_storage_.data.blink;
            CHECK((1 + 2) * 3 == eval.Period());
            CHECK(1 == eval.duration_on_);
            CHECK(1 + 2 == eval.sub_period_);
        }
    };
    TestableJLed::test();
}

TEST_CASE("using Breathe() configures BreatheBrightnessEvaluator", "[jled]") {
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            TestableJLed jled(1);
            jled.Breathe(100, 200, 300);
            REQUIRE(jled.eval_storage_.type == jled::EvalType::BREATHE);
            const auto& eval = jled.eval_storage_.data.breathe;
            CHECK(100 == eval.duration_fade_on_);
            CHECK(200 == eval.duration_on_);
            CHECK(300 == eval.duration_fade_off_);
        }
    };
    TestableJLed::test();
}

TEST_CASE("Breathe(period) splits period evenly into fade-on and fade-off", "[jled]") {
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            TestableJLed jled(1);
            jled.Breathe(1000);
            REQUIRE(jled.eval_storage_.type == jled::EvalType::BREATHE);
            const auto& eval = jled.eval_storage_.data.breathe;
            CHECK(1000 == eval.Period());
            CHECK(500 == eval.duration_fade_on_);
            CHECK(0 == eval.duration_on_);
            CHECK(500 == eval.duration_fade_off_);
        }
    };
    TestableJLed::test();
}

TEST_CASE("using Candle() with offset configures CandleBrightnessEvaluator", "[jled]") {
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            TestableJLed jled(1);
            jled.Candle(1, 2, 3, 4);
            REQUIRE(jled.eval_storage_.type == jled::EvalType::CANDLE);
            const auto& eval = jled.eval_storage_.data.candle;
            CHECK(3 == eval.period_);
            CHECK(1 == eval.speed_);
            CHECK(2 == eval.jitter_);
            CHECK(4 == eval.offset_);
        }
    };
    TestableJLed::test();
}

TEST_CASE("using default Candle() configures CandleBrightnessEvaluator with semi-random offset",
          "[jled]") {
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            TimeMock::set_millis(0);
            TestableJLed jled(1);
            jled.Candle(1, 2, 3);
            REQUIRE(jled.eval_storage_.type == jled::EvalType::CANDLE);
            const auto& eval = jled.eval_storage_.data.candle;
            CHECK(3 == eval.period_);
            CHECK(1 == eval.speed_);
            CHECK(2 == eval.jitter_);
            // if no explicit offset is given, offset is derived by hashing the
            // instance's address together with the current time
            const auto expected = static_cast<uint16_t>(jled::hash32(
                static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&jled)) ^ TimeMock::millis()));
            CHECK(expected == eval.offset_);
        }
    };
    TestableJLed::test();
}

TEST_CASE(
    "using default Candle() varies the auto-offset with construction time, not just the address",
    "[jled]") {
    // On most embedded targets an instance's address is fixed at link time,
    // so it alone would reproduce the exact same flicker pattern every power
    // cycle. Mixing in the current time avoids that.
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            TestableJLed jled(1);

            TimeMock::set_millis(0);
            jled.Candle(1, 2, 3);
            const auto offset_at_t0 = jled.eval_storage_.data.candle.offset_;

            TimeMock::set_millis(12345);
            jled.Candle(1, 2, 3);
            const auto offset_at_t1 = jled.eval_storage_.data.candle.offset_;

            CHECK(offset_at_t0 != offset_at_t1);
        }
    };
    TestableJLed::test();
}

TEST_CASE("using default Candle() decorrelates offsets of adjacent instances", "[jled]") {
    // Adjacent array elements have addresses only sizeof(TestJLed) apart. The
    // auto-derived offset must not simply track that small, constant address
    // delta (which is what previously caused adjacent LEDs to flicker as a
    // visibly correlated, delayed copy of one another, looking like a wave).
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            TimeMock::set_millis(0);
            TestableJLed leds[3] = {TestableJLed(1), TestableJLed(2), TestableJLed(3)};
            for (auto& led : leds) led.Candle(6, 15);

            const auto o0 = leds[0].eval_storage_.data.candle.offset_;
            const auto o1 = leds[1].eval_storage_.data.candle.offset_;
            const auto o2 = leds[2].eval_storage_.data.candle.offset_;

            CHECK(static_cast<uint16_t>(o1 - o0) != static_cast<uint16_t>(o2 - o1));
        }
    };
    TestableJLed::test();
}

TEST_CASE("using Fadeon(), FadeOff() configures Fade-BrightnessEvaluators", "[jled]") {
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            SECTION("FadeOff() initializes with BreatheBrightnessEvaluator") {
                TestableJLed jled(1);
                jled.FadeOff(100);
                REQUIRE(jled.eval_storage_.type == jled::EvalType::BREATHE);
                const auto& eval = jled.eval_storage_.data.breathe;
                CHECK(0 == eval.duration_fade_on_);
                CHECK(0 == eval.duration_on_);
                CHECK(100 == eval.duration_fade_off_);
            }
            SECTION("FadeOn() initializes with BreatheBrightnessEvaluator") {
                TestableJLed jled(1);
                jled.FadeOn(100);
                REQUIRE(jled.eval_storage_.type == jled::EvalType::BREATHE);
                const auto& eval = jled.eval_storage_.data.breathe;
                CHECK(100 == eval.duration_fade_on_);
                CHECK(0 == eval.duration_on_);
                CHECK(0 == eval.duration_fade_off_);
            }
        }
    };
    TestableJLed::test();
}

TEST_CASE("using Fade() configures BreatheBrightnessEvaluator", "[jled]") {
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            SECTION("fade with from < to") {
                TestableJLed jled(1);
                jled.Fade(100, 200, 300);  // from, to, duration
                REQUIRE(jled.eval_storage_.type == jled::EvalType::BREATHE);
                const auto& eval = jled.eval_storage_.data.breathe;
                CHECK(300 == eval.duration_fade_on_);
                CHECK(0 == eval.duration_on_);
                CHECK(0 == eval.duration_fade_off_);
                CHECK(100 == static_cast<int>(eval.from_));
                CHECK(200 == static_cast<int>(eval.to_));
            }
            SECTION("fade with from >= to") {
                TestableJLed jled(1);
                jled.Fade(200, 100, 300);
                REQUIRE(jled.eval_storage_.type == jled::EvalType::BREATHE);
                const auto& eval = jled.eval_storage_.data.breathe;
                CHECK(0 == eval.duration_fade_on_);
                CHECK(0 == eval.duration_on_);
                CHECK(300 == eval.duration_fade_off_);
                CHECK(100 == static_cast<int>(eval.from_));
                CHECK(200 == static_cast<int>(eval.to_));
            }
        }
    };
    TestableJLed::test();
}
TEST_CASE("UserFunc() allows to use a custom brightness evaluator", "[jled]") {
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            TestableJLed jled(1);
            auto cust = MockBrightnessEvaluator(std::vector<uint8_t>{});
            jled.UserFunc(&cust);
            REQUIRE(jled.eval_storage_.type == jled::EvalType::USER);
        }
    };
    TestableJLed::test();
}

TEST_CASE("ConstantBrightnessEvaluator returns constant provided value", "[jled]") {
    auto cbZero = ConstantBrightnessEvaluator{0, 1};
    CHECK(1 == cbZero.Period());
    CHECK(0 == cbZero.Eval(0));
    CHECK(0 == cbZero.Eval(1000));

    auto cbFull = ConstantBrightnessEvaluator{255, 1};
    CHECK(1 == cbFull.Period());
    CHECK(255 == cbFull.Eval(0));
    CHECK(255 == cbFull.Eval(1000));
}

TEST_CASE(
    "BlinkBrightnessEvaluator calculates switches between on and off in given "
    "time frames",
    "[jled]") {
    SECTION("single cycle (n == 1) does one on-off cycle") {
        auto eval = BlinkBrightnessEvaluator{10, 5, 1};
        CHECK(10 + 5 == eval.Period());
        CHECK(255 == eval.Eval(0));
        CHECK(255 == eval.Eval(9));
        CHECK(0 == eval.Eval(10));
        CHECK(0 == eval.Eval(14));
    }

    SECTION("multiple cycles (n > 1) repeat the on-off cycle") {
        auto eval = BlinkBrightnessEvaluator{1, 2, 3};
        CHECK((1 + 2) * 3 == eval.Period());
        // each of the 3 sub-cycles: on at slot 0, off at slots 1 and 2
        CHECK(255 == eval.Eval(0));
        CHECK(0 == eval.Eval(1));
        CHECK(0 == eval.Eval(2));

        CHECK(255 == eval.Eval(3));
        CHECK(0 == eval.Eval(4));
        CHECK(0 == eval.Eval(5));

        CHECK(255 == eval.Eval(6));
        CHECK(0 == eval.Eval(7));
        CHECK(0 == eval.Eval(8));
    }
}

TEST_CASE("CandleBrightnessEvaluator simulates candle flickering", "[jled]") {
    auto eval = CandleBrightnessEvaluator(7, 15, 1000);
    CHECK(1000 == eval.Period());
    // hash8(0>>7 + 0) = hash8(0) = 0xf3 = 243 >= 15 -> full brightness
    CHECK(255 == eval.Eval(0));
    // deterministic: same t always yields the same result
    CHECK(eval.Eval(0) == eval.Eval(0));
    CHECK(eval.Eval(128) == eval.Eval(128));
}

TEST_CASE("CandleBrightnessEvaluator jitter=0 always returns full brightness", "[jled]") {
    auto eval = CandleBrightnessEvaluator(0, 0, 1000);
    // rnd >= 0 is always true
    CHECK(255 == eval.Eval(0));
    CHECK(255 == eval.Eval(500));
    CHECK(255 == eval.Eval(999));
}

TEST_CASE("CandleBrightnessEvaluator table lookup", "[jled]") {
    // jitter=255: gate=hash8(slot), index=hash8(~slot)&0xf (decoupled)
    // slot=0: hash8(0)=243 < 255 -> table; hash8(~0)&0xf=2 -> kCandleTable[2]=21
    auto eval = CandleBrightnessEvaluator(0, 255, 1000);
    CHECK(21 == eval.Eval(0));
    // slot=1: hash8(1)=148 < 255 -> table; hash8(~1)&0xf=10 -> kCandleTable[10]=124
    CHECK(124 == eval.Eval(1));
}

TEST_CASE("CandleBrightnessEvaluator offset shifts sequence", "[jled]") {
    auto eval0 = CandleBrightnessEvaluator(0, 255, 1000, 0);
    auto eval1 = CandleBrightnessEvaluator(0, 255, 1000, 1);
    // different offsets produce different outputs for the same t
    CHECK(eval0.Eval(0) != eval1.Eval(0));
    // same offset always produces the same output
    CHECK(eval0.Eval(42) == eval0.Eval(42));
}

TEST_CASE("CandleBrightnessEvaluator offset is equivalent to time shift", "[jled]") {
    // Candle(offset=N).Eval(t) == Candle(offset=0).Eval(t+N) for any t
    constexpr uint16_t kOffset = 100;
    auto base = CandleBrightnessEvaluator(0, 15, 65535, 0);
    auto shifted = CandleBrightnessEvaluator(0, 15, 65535, kOffset);
    for (uint32_t t : {0u, 50u, 200u}) {
        CHECK(base.Eval(t + kOffset) == shifted.Eval(t));
    }
}

TEST_CASE("CandleBrightnessEvaluator speed groups same slot", "[jled]") {
    // speed=1: t>>1 is the slot index, so t=0,1 share slot 0
    auto eval = CandleBrightnessEvaluator(1, 15, 1000);
    CHECK(eval.Eval(0) == eval.Eval(1));
    CHECK(eval.Eval(2) == eval.Eval(3));
}

TEST_CASE("CandleBrightnessEvaluator 16-bit scales table values correctly", "[jled]") {
    auto eval = jled::CandleBrightnessEvaluator<uint16_t>(0, 255, 1000);
    // gate: hash8(0)=243 < 255 -> table; index: hash8(~0)&0xf=2 -> kCandleTable[2]=21
    const uint16_t expected = static_cast<uint16_t>((21u << 8) | 21u);
    CHECK(expected == eval.Eval(0));
    // jitter=0 → always full brightness → 0xffff
    auto eval_full = jled::CandleBrightnessEvaluator<uint16_t>(0, 0, 1000);
    CHECK(0xffffu == eval_full.Eval(0));
}

TEST_CASE("BreatheEvaluator evaluates to bell curve distributed brightness curve", "[jled]") {
    auto eval = BreatheBrightnessEvaluator{100, 200, 300, 0, 255};
    CHECK(100 + 200 + 300 == eval.Period());

    const std::map<uint32_t, uint8_t> test_values = {{0, 0},
                                                     {50, 68},
                                                     {80, 200},
                                                     {99, 255},
                                                     {100, 255},
                                                     {299, 255},
                                                     {300, 255},
                                                     {399, 138},
                                                     {499, 26},
                                                     {599, 0}};

    for (const auto& x : test_values) {
        INFO("t=" << x.first);
        CHECK((int)x.second == (int)eval.Eval(x.first));
    }
}

TEST_CASE("Forever flag", "[jled]") {
    SECTION("is initially false") {
        CHECK_FALSE(TestJLed(1).IsForever());
    }
    SECTION("is set by Forever()") {
        CHECK(TestJLed(1).Forever().IsForever());
    }
}

TEST_CASE("dont evaluate twice during one time tick", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{0, 1, 2});
    TestJLed jled = TestJLed(1).UserFunc(&eval);

    jled.Update(0);
    CHECK(eval.TimesEvalWasCalled() == 1);
    jled.Update(0);
    CHECK(eval.TimesEvalWasCalled() == 1);
    jled.Update(1);

    CHECK(eval.TimesEvalWasCalled() == 2);
}

TEST_CASE("Handles millis overflow during effect", "[jled]") {
    TestJLed jled = TestJLed(10);
    // Set time close to overflow
    auto time = std::numeric_limits<uint32_t>::max() - 25;
    CHECK_FALSE(jled.Update(time));
    // Start fade off
    jled.FadeOff(100);
    CHECK(jled.Update(time));
    CHECK(jled.IsRunning());
    CHECK(jled.GetHal().Value() > 0);
    // Set time after overflow, before effect ends
    CHECK(jled.Update(time + 50));
    CHECK(jled.IsRunning());
    CHECK(jled.GetHal().Value() > 0);
    // Set time after effect ends
    CHECK_FALSE(jled.Update(time + 150));
    CHECK_FALSE(jled.IsRunning());
    CHECK(0 == jled.GetHal().Value());
}

TEST_CASE("UpdateResult::Brightness() reports the value written to the HAL", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{0, 10});
    TestJLed jled = TestJLed(1).UserFunc(&eval);

    auto r0 = jled.Update(0);
    REQUIRE(r0.HasBrightness());
    CHECK(r0.Brightness() == 0);

    auto r1 = jled.Update(1);
    REQUIRE(r1.HasBrightness());
    CHECK(r1.Brightness() == 10);
}

TEST_CASE("UpdateResult::HasBrightness() is false when nothing was written this tick", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{0, 10});
    TestJLed jled = TestJLed(1).UserFunc(&eval).DelayBefore(1);

    auto r0 = jled.Update(0);
    CHECK_FALSE(r0.HasBrightness());  // still within delay_before_

    auto r1 = jled.Update(5);
    REQUIRE(r1.HasBrightness());
    CHECK(r1.Brightness() == 10);

    auto r2 = jled.Update(5);  // effect already stopped by t=5
    CHECK_FALSE(r2.HasBrightness());
}

// --- Lifecycle events (UpdateResult) ---

TEST_CASE("kStart fires once, on the first call, even with delay_before_", "[jled]") {
    TestJLed jled = TestJLed(1).Blink(2, 2).DelayBefore(3);

    auto r0 = jled.Update(0);
    CHECK(r0.IsStarted());
    CHECK(r0.IsRunning());
    CHECK_FALSE(r0.IsFirstOutput());

    auto r1 = jled.Update(1);
    CHECK_FALSE(r1.IsStarted());

    auto r3 = jled.Update(3);
    CHECK_FALSE(r3.IsStarted());
    CHECK(r3.IsFirstOutput());
    CHECK(r3.IsRepeatStarted());
}

TEST_CASE("kStart re-arms after Reset()", "[jled]") {
    TestJLed jled = TestJLed(1).On();
    auto r0 = jled.Update(0);
    CHECK(r0.IsStarted());
    CHECK(r0.IsDone());

    jled.Reset();
    auto r1 = jled.Update(1);
    CHECK(r1.IsStarted());
}

TEST_CASE("kRepeatStart fires on every repetition, including across a DelayAfter gap", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(10).UserFunc(&eval).Repeat(2).DelayAfter(2);

    auto r0 = jled.Update(0);
    CHECK(r0.IsRepeatStarted());
    CHECK(r0.IsFirstOutput());

    auto r1 = jled.Update(1);
    CHECK_FALSE(r1.IsRepeatStarted());

    auto r2 = jled.Update(2);
    CHECK(r2.IsEnteringDelayAfter());
    CHECK_FALSE(r2.IsRepeatStarted());

    auto r3 = jled.Update(3);
    CHECK_FALSE(r3.IsRepeatStarted());
    CHECK_FALSE(r3.IsEnteringDelayAfter());

    // second repetition's kRepeatStart, even though the tick before it left
    // the LED in ST_IN_DELAY_AFTER_PHASE, not ST_RUNNING.
    auto r4 = jled.Update(4);
    CHECK(r4.IsRepeatStarted());
    CHECK_FALSE(r4.IsFirstOutput());  // second repetition, not the first

    auto r6 = jled.Update(6);
    CHECK(r6.IsEnteringDelayAfter());

    auto r7 = jled.Update(7);
    CHECK(r7.IsDone());
    CHECK_FALSE(r7.IsRunning());
}

TEST_CASE("kEnterDelayAfter never fires when delay_after_ is zero", "[jled]") {
    TestJLed jled = TestJLed(1).Blink(2, 2).Repeat(3);

    for (uint32_t t = 0; t < 20; t++) {
        auto r = jled.Update(t);
        CHECK_FALSE(r.IsEnteringDelayAfter());
        if (!r.IsRunning()) break;
    }
}

TEST_CASE("kEnterDelayAfter fires exactly once per repetition, including the final one", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(10).UserFunc(&eval).Repeat(3).DelayAfter(2);

    int count = 0;
    for (uint32_t t = 0; t < 20; t++) {
        auto r = jled.Update(t);
        if (r.IsEnteringDelayAfter()) count++;
        if (!r.IsRunning()) break;
    }
    CHECK(count == 3);
}

TEST_CASE("kDone fires exactly once, on the terminal tick", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(10).UserFunc(&eval);

    int doneCount = 0;
    bool sawNotRunning = false;
    for (uint32_t t = 0; t < 6; t++) {
        auto r = jled.Update(t);
        if (r.IsDone()) doneCount++;
        if (!r.IsRunning()) sawNotRunning = true;
    }
    CHECK(doneCount == 1);
    CHECK(sawNotRunning);
}

TEST_CASE("single-tick effect fires kStart|kFirstOutput|kRepeatStart|kDone on its one call",
          "[jled]") {
    TestJLed jled(1);
    jled.On();
    auto r = jled.Update(0);
    CHECK_FALSE(r.IsRunning());
    CHECK(r.IsStarted());
    CHECK(r.IsFirstOutput());
    CHECK(r.IsRepeatStarted());
    CHECK(r.IsDone());
    REQUIRE(r.HasBrightness());
    CHECK(r.Brightness() == 255);
}

TEST_CASE("repeated single-tick effect: final kRepeatStart lands on the terminal tick", "[jled]") {
    TestJLed jled = TestJLed(1).Set(100, 1).Repeat(3);

    auto r0 = jled.Update(0);
    CHECK(r0.IsRepeatStarted());
    CHECK(r0.IsFirstOutput());
    CHECK_FALSE(r0.IsDone());

    auto r1 = jled.Update(1);
    CHECK(r1.IsRepeatStarted());
    CHECK_FALSE(r1.IsFirstOutput());
    CHECK_FALSE(r1.IsDone());

    auto r2 = jled.Update(2);
    CHECK(r2.IsRepeatStarted());
    CHECK_FALSE(r2.IsFirstOutput());
    CHECK(r2.IsDone());
}

TEST_CASE("delay_after_ == 1 on the final repetition: kEnterDelayAfter and kDone fire together",
          "[jled]") {
    TestJLed jled = TestJLed(1).Set(100, 1).Repeat(2).DelayAfter(1);

    auto r0 = jled.Update(0);
    CHECK(r0.IsRepeatStarted());
    CHECK_FALSE(r0.IsDone());

    auto r1 = jled.Update(1);
    CHECK(r1.IsEnteringDelayAfter());
    CHECK_FALSE(r1.IsDone());

    auto r2 = jled.Update(2);
    CHECK(r2.IsRepeatStarted());

    auto r3 = jled.Update(3);
    CHECK(r3.IsEnteringDelayAfter());
    CHECK(r3.IsDone());
}

TEST_CASE("On* callback chain invokes matching hooks on a coincident tick", "[jled]") {
    TestJLed jled(1);
    jled.On();

    int startCount = 0, activeCount = 0, repeatCount = 0, enterDelayCount = 0, doneCount = 0;
    jled.Update(0)
        .OnStart([&](TestJLed&) { startCount++; })
        .OnFirstOutput([&](TestJLed&) { activeCount++; })
        .OnRepeatStart([&](TestJLed&) { repeatCount++; })
        .OnEnterDelayAfter([&](TestJLed&) { enterDelayCount++; })
        .OnDone([&](TestJLed&) { doneCount++; });

    CHECK(startCount == 1);
    CHECK(activeCount == 1);
    CHECK(repeatCount == 1);
    CHECK(enterDelayCount == 0);  // delay_after_ == 0 for On()
    CHECK(doneCount == 1);
}

TEST_CASE("run length is cycle_period * repetitions even when that exceeds 16 bits", "[jled]") {
    // 1000ms cycle x 100 repetitions = 100000ms, which does not fit in 16 bits.
    // The end-time computation must therefore happen in 32 bits. On AVR, where
    // int is 16 bits wide, computing it in int truncates 100000 to 34464 and
    // the effect stops after roughly a third of its length.
    TestJLed jled = TestJLed(1).Blink(500, 500).Repeat(100);

    CHECK(jled.Update(0).IsRunning());
    CHECK(jled.Update(99998).IsRunning());

    auto last = jled.Update(99999);
    CHECK(last.IsDone());
    CHECK_FALSE(last.IsRunning());
}

TEST_CASE("OnEnterDelayAfter never fires across a full run when delay_after_ == 0", "[jled]") {
    TestJLed jled = TestJLed(1).Blink(2, 2).Repeat(3);

    int enterDelayCount = 0;
    for (uint32_t t = 0; t < 20; t++) {
        auto r = jled.Update(t);
        r.OnEnterDelayAfter([&](TestJLed&) { enterDelayCount++; });
        if (!r.IsRunning()) break;
    }
    CHECK(enterDelayCount == 0);
}

TEST_CASE("UpdateResult stays usable as a plain bool (backwards compatibility)", "[jled]") {
    TestJLed jled = TestJLed(1).On();

    bool x = jled.Update(0);
    CHECK_FALSE(x);  // On() with duration=1 completes on the first tick

    TestJLed jled2 = TestJLed(1).Blink(2, 2);
    if (jled2.Update(0)) {
        SUCCEED("effect is still running after first tick");
    } else {
        FAIL("expected effect to still be running");
    }
}

TEST_CASE("Stop() stops the effect", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{255, 255, 255, 0});
    TestJLed jled = TestJLed(10).UserFunc(&eval);

    REQUIRE(jled.IsRunning());
    jled.Update();
    jled.Stop();

    CHECK(!jled.IsRunning());
}

TEST_CASE("Stop() idle modes", "[jled]") {
    using P = std::pair<jled::eIdleMode, int>;
    auto tc = GENERATE(values<P>({
        {jled::eIdleMode::TO_MIN_BRIGHTNESS, 50},
        {jled::eIdleMode::FULL_OFF, 0},
        {jled::eIdleMode::KEEP_CURRENT, 130},
    }));
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{100, 0});
    TestJLed jled = TestJLed(10).UserFunc(&eval).MinBrightness(50);
    jled.Update();
    REQUIRE(130 == static_cast<int>(jled.GetHal().Value()));  // 100 scaled to [50,255]
    jled.Stop(tc.first);
    CHECK(tc.second == static_cast<int>(jled.GetHal().Value()));
}

TEST_CASE("Stop() default mode is TO_MIN_BRIGHTNESS", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{100, 0});
    TestJLed jled = TestJLed(10).UserFunc(&eval).MinBrightness(50);
    jled.Update();
    jled.Stop();
    CHECK(50 == static_cast<int>(jled.GetHal().Value()));
}

TEST_CASE("Stop() makes the next Update() fire kDone exactly once", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20, 30});
    TestJLed jled = TestJLed(1).UserFunc(&eval);

    TimeMock::set_millis(0);
    auto r0 = jled.Update();  // running
    CHECK(r0.IsRunning());
    CHECK_FALSE(r0.IsDone());

    jled.Stop();

    TimeMock::set_millis(1);
    auto r1 = jled.Update();  // first tick after Stop(): kDone fires
    CHECK_FALSE(r1.IsRunning());
    CHECK(r1.IsDone());

    TimeMock::set_millis(2);
    auto r2 = jled.Update();  // no further kDone
    CHECK_FALSE(r2.IsRunning());
    CHECK_FALSE(r2.IsDone());
}

TEST_CASE("OnDone callback fires once after Stop()", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20, 30});
    TestJLed jled = TestJLed(1).UserFunc(&eval);

    int doneCount = 0;
    TimeMock::set_millis(0);
    jled.Update();
    jled.Stop();

    for (uint32_t t = 1; t < 5; t++) {
        TimeMock::set_millis(t);
        jled.Update().OnDone([&](TestJLed&) { doneCount++; });
    }
    CHECK(doneCount == 1);
}

TEST_CASE("natural completion still fires kDone exactly once (regression)", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(1).UserFunc(&eval);

    int doneCount = 0;
    for (uint32_t t = 0; t < 5; t++) {
        TimeMock::set_millis(t);
        jled.Update().OnDone([&](TestJLed&) { doneCount++; });
    }
    CHECK(doneCount == 1);
}

TEST_CASE("Reset() re-arms kDone after a Stop()", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20, 30});
    TestJLed jled = TestJLed(1).UserFunc(&eval);

    TimeMock::set_millis(0);
    jled.Update();
    jled.Stop();
    TimeMock::set_millis(1);
    CHECK(jled.Update().IsDone());  // first done

    jled.Reset();
    TimeMock::set_millis(2);
    auto r = jled.Update();
    CHECK(r.IsRunning());
    CHECK(r.IsStarted());
    CHECK_FALSE(r.IsDone());  // fresh run, not done yet
}

TEST_CASE("Stop() on an effect-less LED fires no kDone", "[jled]") {
    TestJLed jled = TestJLed(1);  // no UserFunc/effect set
    jled.Stop();
    TimeMock::set_millis(0);
    auto r = jled.Update();
    CHECK_FALSE(r.IsRunning());
    CHECK_FALSE(r.IsDone());
}

TEST_CASE("Pause() idle modes", "[jled]") {
    using P = std::pair<jled::eIdleMode, int>;
    auto tc = GENERATE(values<P>({
        {jled::eIdleMode::TO_MIN_BRIGHTNESS, 50},
        {jled::eIdleMode::FULL_OFF, 0},
        {jled::eIdleMode::KEEP_CURRENT, 130},
    }));
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{100, 0});
    TestJLed jled = TestJLed(10).UserFunc(&eval).MinBrightness(50);
    jled.Update();
    REQUIRE(130 == static_cast<int>(jled.GetHal().Value()));  // 100 scaled to [50,255]
    TimeMock::set_millis(1);
    jled.Pause(tc.first);
    CHECK(tc.second == static_cast<int>(jled.GetHal().Value()));
}

TEST_CASE("Pause() default mode is TO_MIN_BRIGHTNESS", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{100, 0});
    TestJLed jled = TestJLed(10).UserFunc(&eval).MinBrightness(50);
    jled.Update();
    TimeMock::set_millis(1);
    jled.Pause();
    CHECK(50 == static_cast<int>(jled.GetHal().Value()));
}

TEST_CASE("LowActive() inverts signal", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{0, 255});
    TestJLed jled = TestJLed(1).UserFunc(&eval).LowActive();

    CHECK(jled.IsLowActive());

    jled.Update(0);
    CHECK(0 == jled.GetHal().Value());
    CHECK(jled.GetHal().Invert());

    jled.Update(1);
    CHECK(255 == jled.GetHal().Value());
    CHECK(jled.GetHal().Invert());
}

TEST_CASE("WriteRaw() writes directly to the HAL, bypassing the effect", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{100});
    TestJLed jled = TestJLed(1).UserFunc(&eval);

    jled.WriteRaw(42);
    CHECK(42 == jled.GetHal().Value());

    // effect state is untouched: the next Update() still evaluates normally
    jled.Update(0);
    CHECK(100 == jled.GetHal().Value());
}

TEST_CASE("WriteRaw() applies LowActive() inversion", "[jled]") {
    TestJLed jled = TestJLed(1).LowActive();

    jled.WriteRaw(0);
    CHECK(0 == jled.GetHal().Value());
    CHECK(jled.GetHal().Invert());

    jled.WriteRaw(255);
    CHECK(255 == jled.GetHal().Value());
    CHECK(jled.GetHal().Invert());
}

TEST_CASE("LowActive() calls the HAL's SetLowActive() hook", "[jled]") {
    TestJLed jled(1);
    CHECK(0 == jled.GetHal().SetLowActiveCallCount());

    jled.LowActive();

    CHECK(1 == jled.GetHal().SetLowActiveCallCount());
    CHECK(jled.GetHal().SetLowActiveValue());
}

TEST_CASE("LowActive(false) restores normal, high active output", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{0, 255});
    TestJLed jled = TestJLed(1).UserFunc(&eval).LowActive().LowActive(false);

    CHECK_FALSE(jled.IsLowActive());
    CHECK(2 == jled.GetHal().SetLowActiveCallCount());
    CHECK_FALSE(jled.GetHal().SetLowActiveValue());

    jled.Update(0);
    CHECK(0 == jled.GetHal().Value());
    CHECK_FALSE(jled.GetHal().Invert());

    jled.Update(1);
    CHECK(255 == jled.GetHal().Value());
    CHECK_FALSE(jled.GetHal().Invert());
}

TEST_CASE("effect with repeat 2 repeats sequence once", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(10).UserFunc(&eval).Repeat(2);

    typedef ExpectedUpdate u;
    const ExpectedUpdates expected = {
        u{true, 10}, u{true, 20}, u{true, 10}, u{false, 20}, u{false, 20}, u{false, 20}};

    check_led(&jled, expected);
}

TEST_CASE("effect with delay after delays start of next iteration", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(10).UserFunc(&eval).Repeat(2).DelayAfter(2);

    typedef ExpectedUpdate u;
    const ExpectedUpdates expected = {u{true, 10},
                                      u{true, 20},
                                      u{true, 20},
                                      u{true, 20},
                                      u{true, 10},
                                      u{true, 20},
                                      u{true, 20},
                                      u{false, 20},
                                      u{false, 20},
                                      u{false, 20}};

    check_led(&jled, expected);
}

TEST_CASE("effect with delay before has delayed start ", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(10).UserFunc(&eval).DelayBefore(2);

    typedef ExpectedUpdate u;
    const ExpectedUpdates expected = {
        u{true, 0}, u{true, 0}, u{true, 10}, u{false, 20}, u{false, 20}, u{false, 20}};

    check_led(&jled, expected);
}

TEST_CASE("After calling Forever() the effect is repeated over and over again ", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(10).UserFunc(&eval).Forever();

    typedef ExpectedUpdate u;
    const ExpectedUpdates expected = {
        u{true, 10}, u{true, 20}, u{true, 10}, u{true, 20}, u{true, 10}, u{true, 20}};

    check_led(&jled, expected);
}

TEST_CASE("The Hal object provided in the ctor is used during update", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(123).UserFunc(&eval);

    CHECK(jled.GetHal().Pin() == 123);
}

TEST_CASE("Update returns true while updating, else false", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(10).UserFunc(&eval);

    // Update returns FALSE on last step and beyond, else TRUE
    CHECK(jled.Update(0));

    // when effect is done, we expect still false to be returned
    CHECK_FALSE(jled.Update(1));
    CHECK_FALSE(jled.Update(2));
}

TEST_CASE("After Reset() the effect can be restarted", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(10).UserFunc(&eval);

    typedef ExpectedUpdate u;

    const ExpectedUpdates expected = {u{true, 10}, u{false, 20}, u{false, 20}, u{false, 20}};

    check_led(&jled, expected);

    // after Reset() effect starts over
    jled.Reset();

    check_led(&jled, expected);
}

TEST_CASE("Changing the effect resets object and starts over", "[jled]") {
    auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{10, 20});
    TestJLed jled = TestJLed(10).UserFunc(&eval);

    typedef ExpectedUpdate u;
    const ExpectedUpdates expected = {u{true, 10}, u{false, 20}, u{false, 20}};

    check_led(&jled, expected);

    // expect to start over after changing effect.
    jled.UserFunc(&eval);
    check_led(&jled, expected);
}

TEST_CASE("brightness level accessors", "[jled]") {
    SECTION("MaxBrightness is initialized to 255") {
        CHECK(255 == TestJLed(10).MaxBrightness());
    }
    SECTION("MaxBrightness can be set and read back") {
        CHECK(100 == TestJLed(10).MaxBrightness(100).MaxBrightness());
    }
    SECTION("MinBrightness is initialized to 0") {
        CHECK(0 == TestJLed(10).MinBrightness());
    }
    SECTION("MinBrightness can be set and read back") {
        CHECK(100 == TestJLed(10).MinBrightness(100).MinBrightness());
    }
}

TEST_CASE("Setting min and max brightness levels scales evaluated effect values", "[jled]") {
    class TestableJLed : public TestJLed {
     public:
        using TestJLed::TestJLed;
        static void test() {
            TestableJLed jled(1);
            auto eval = MockBrightnessEvaluator(std::vector<uint8_t>{0, 128, 255});
            jled.UserFunc(&eval).MinBrightness(100).MaxBrightness(200);

            jled.Update(0);
            CHECK(100 == jled.GetHal().Value());

            jled.Update(2);
            CHECK(200 == jled.GetHal().Value());
        }
    };
    TestableJLed::test();
};

TEST_CASE("EvalStorage dispatches IsSet/Period/Eval to the active evaluator", "[jled]") {
    using jled::EvalStorage;
    using jled::EvalType;

    // the user evaluator must outlive the storage that points to it
    auto userEval = MockBrightnessEvaluator(std::vector<uint8_t>{99});

    struct TestCase {
        const char* name;
        std::function<void(EvalStorage<uint8_t>&)> setup;
        bool expected_is_set;
        uint16_t expected_period;
        uint8_t expected_eval0;
    };

    // Each case selects a different EvalType and populates the matching union
    // member with values that make the dispatched Period()/Eval() unambiguous.
    const std::vector<TestCase> cases = {
        {"NONE is not set and evaluates to zero",
         [](EvalStorage<uint8_t>& s) { s.type = EvalType::NONE; },
         false,
         0,
         0},
        {"CONSTANT dispatches to ConstantBrightnessEvaluator",
         [](EvalStorage<uint8_t>& s) {
             s.type = EvalType::CONSTANT;
             s.data.constant = ConstantBrightnessEvaluator{42, 11};
         },
         true,
         11,
         42},
        {"BLINK dispatches to BlinkBrightnessEvaluator",
         [](EvalStorage<uint8_t>& s) {
             s.type = EvalType::BLINK;
             s.data.blink = BlinkBrightnessEvaluator{5, 7, 1};
         },
         true,
         12,
         255},
        {"BREATHE dispatches to BreatheBrightnessEvaluator",
         [](EvalStorage<uint8_t>& s) {
             s.type = EvalType::BREATHE;
             s.data.breathe = BreatheBrightnessEvaluator{10, 20, 30, 0, 255};
         },
         true,
         60,
         0},
        {"CANDLE dispatches to CandleBrightnessEvaluator",
         [](EvalStorage<uint8_t>& s) {
             s.type = EvalType::CANDLE;
             s.data.candle = CandleBrightnessEvaluator(0, 0, 1000);
         },
         true,
         1000,
         255},
        {"USER dispatches through the user pointer",
         [&userEval](EvalStorage<uint8_t>& s) {
             s.type = EvalType::USER;
             s.data.user = &userEval;
         },
         true,
         1,
         99},
    };

    for (const auto& tc : cases) {
        DYNAMIC_SECTION(tc.name) {
            EvalStorage<uint8_t> storage;
            tc.setup(storage);
            CHECK(tc.expected_is_set == storage.IsSet());
            CHECK(tc.expected_period == storage.Period());
            CHECK((int)tc.expected_eval0 == (int)storage.Eval(0));
        }
    }
}

TEST_CASE("scale8", "[scale8]") {
    struct Case {
        uint8_t val;
        uint8_t factor;
        uint8_t expected;
    };
    auto tc = GENERATE(values<Case>({
        {0, 0, 0},
        {255, 0, 0},
        {0, 128, 0},
        {100, 128, 50},
        {255, 128, 128},
        {0, 255, 0},
        {127, 255, 127},
        {255, 255, 255},
    }));
    CHECK(tc.expected == jled::scale8(tc.val, tc.factor));
}

TEST_CASE("lerp8by8 interpolates a byte into the given interval", "[lerp8by8]") {
    CHECK(0 == (int)(jled::lerp8by8(0, 0, 255)));
    CHECK(0 == (int)(jled::lerp8by8(255, 0, 0)));
    CHECK(255 == (int)(jled::lerp8by8(255, 0, 255)));

    CHECK(100 == (int)(jled::lerp8by8(0, 100, 255)));
    CHECK(100 == (int)(jled::lerp8by8(0, 100, 110)));

    CHECK(255 == (int)(jled::lerp8by8(255, 100, 255)));
    CHECK(200 == (int)(jled::lerp8by8(255, 100, 200)));
}

TEST_CASE("Pause() during ST_RUNNING sets LED to minBrightness", "[jled]") {
    TestJLed jled(1);
    jled.Blink(4, 4);  // on for t_cycle=0..3, off for t_cycle=4..7, done at t=8

    // Run to t=2 (mid-blink, brightness=255)
    jled.Update(0);
    jled.Update(2);
    CHECK(255 == jled.GetHal().Value());  // mid-blink = on = 255

    TimeMock::set_millis(2);
    jled.Pause();
    CHECK(jled.IsPaused());

    // Further updates must not change brightness and must return true
    CHECK(jled.Update(3));
    CHECK(jled.GetHal().Value() == 0);
    CHECK(jled.Update(100));
    CHECK(jled.GetHal().Value() == 0);
}

TEST_CASE("Resume() continues effect from freeze point", "[jled]") {
    TestJLed jled(1);
    jled.Blink(4, 4);  // on=[0..3], off=[4..7], period=8

    // Advance to t=2 (elapsed=2, on-phase)
    jled.Update(0);
    jled.Update(2);

    // Pause at t=2 (elapsed_so_far=2), resume at t=50
    // After resume: effective epoch = 50-2 = 48
    TimeMock::set_millis(2);
    jled.Pause();
    TimeMock::set_millis(50);
    jled.Resume();
    CHECK_FALSE(jled.IsPaused());

    // At t=51: elapsed = 51-48 = 3 → t_cycle=3, on-phase → 255
    CHECK(jled.Update(51));
    CHECK(jled.GetHal().Value() == 255);

    // At t=52: elapsed = 52-48 = 4 → t_cycle=4, off-phase → 0
    CHECK(jled.Update(52));
    CHECK(jled.GetHal().Value() == 0);
}

TEST_CASE("Pause() in ST_STOPPED is a no-op", "[jled]") {
    TestJLed jled(1);
    jled.Blink(2, 2);
    jled.Update(0);
    jled.Stop();
    TimeMock::set_millis(5);
    jled.Pause();
    CHECK_FALSE(jled.IsPaused());
    CHECK_FALSE(jled.Update(6));
}

TEST_CASE("Pause() in ST_INIT delays effect start until Resume()", "[jled]") {
    TestJLed jled(1);
    jled.Blink(2, 2);  // on=[0,1], off=[2,3], period=4

    TimeMock::set_millis(0);
    jled.Pause();
    CHECK(jled.IsPaused());

    // Updates must not start the effect
    CHECK(jled.Update(0));
    CHECK(jled.GetHal().Value() == 0);  // nothing written yet
    CHECK(jled.Update(5));
    CHECK(jled.GetHal().Value() == 0);

    // After Resume the effect starts normally on next Update
    TimeMock::set_millis(10);
    jled.Resume();
    CHECK_FALSE(jled.IsPaused());
    CHECK(jled.Update(10));
    CHECK(jled.GetHal().Value() == 255);  // t_cycle=0, on-phase
}

TEST_CASE("Pause() is idempotent", "[jled]") {
    TestJLed jled(1);
    jled.Blink(4, 4);
    jled.Update(0);  // time_start_=0

    TimeMock::set_millis(1);
    jled.Pause();  // time_start_ = 1-0 = 1 (elapsed=1 encoded)
    TimeMock::set_millis(99);
    jled.Pause();  // second call - must be no-op, not re-encode
    TimeMock::set_millis(50);
    jled.Resume();  // time_start_ = 50-1 = 49 (epoch restored)

    // At t=51: elapsed = 51-49 = 2 → on-phase → 255
    CHECK(jled.Update(51));
    CHECK(jled.GetHal().Value() == 255);
}

TEST_CASE("Resume() is idempotent", "[jled]") {
    TestJLed jled(1);
    jled.Blink(4, 4);
    jled.Update(0);
    TimeMock::set_millis(1);
    jled.Pause();
    TimeMock::set_millis(10);
    jled.Resume();  // time_start_ = 10-1 = 9 (epoch)
    TimeMock::set_millis(99);
    jled.Resume();  // second call - must be no-op
    CHECK_FALSE(jled.IsPaused());

    // At t=11: elapsed = 11-9 = 2 → on-phase → 255
    CHECK(jled.Update(11));
    CHECK(jled.GetHal().Value() == 255);
}

TEST_CASE("copy of paused JLed preserves pause state", "[jled]") {
    TestJLed jled(1);
    jled.Blink(4, 4);
    jled.Update(0);
    jled.Update(2);
    TimeMock::set_millis(2);
    jled.Pause();  // time_start_ = 2-0 = 2 (elapsed=2 encoded)

    TestJLed copy = jled;
    CHECK(copy.IsPaused());

    // Copy resumes correctly: time_start_ = 50-2 = 48 (epoch)
    TimeMock::set_millis(50);
    copy.Resume();
    // At t=51: elapsed = 51-48 = 3 → on-phase → 255
    CHECK(copy.Update(51));
    CHECK(copy.GetHal().Value() == 255);
}

TEST_CASE("Reset() clears pause state", "[jled]") {
    TestJLed jled(1);
    jled.Blink(4, 4);
    jled.Update(0);
    TimeMock::set_millis(1);
    jled.Pause();
    CHECK(jled.IsPaused());

    jled.Reset();
    CHECK_FALSE(jled.IsPaused());

    // After Reset, Update should start the effect normally
    CHECK(jled.Update(10));
    CHECK(jled.GetHal().Value() == 255);  // t_cycle=0, on-phase
}

TEST_CASE("Stop() clears pause state", "[jled]") {
    TestJLed jled(1);
    jled.Blink(4, 4);
    jled.Update(0);
    TimeMock::set_millis(1);
    jled.Pause();
    REQUIRE(jled.IsPaused());

    jled.Stop();
    // Stopping a paused LED must leave it stopped, not paused.
    CHECK_FALSE(jled.IsPaused());
    // Stopped LED reports not-running, even though it was paused before.
    CHECK_FALSE(jled.Update(6));
}