Function FL_TEST_FILE

tests/fl/stl/condition_variable.cpp:17–131

#include "fl/stl/vector.h"

FL_TEST_FILE(FL_FILEPATH) {

#if FASTLED_MULTITHREADED


FL_TEST_CASE("fl::condition_variable basic operations") {
    fl::mutex mtx;
    fl::condition_variable cv;
    fl::atomic<bool> ready(false);
    fl::atomic<bool> processed(false);

    FL_SUBCASE("notify_one wakes waiting thread") {
        std::thread worker([&]() {  // okay std namespace - fl::thread not available
            fl::unique_lock<fl::mutex> lock(mtx);
            ready.store(true);
            cv.notify_one();  // Signal main thread

            // Wait for main thread to process
            cv.wait(lock, [&]() { return processed.load(); });
        });

        // Wait for worker to be ready
        fl::unique_lock<fl::mutex> lock(mtx);
        cv.wait(lock, [&]() { return ready.load(); });

        // Signal we've processed
        processed.store(true);
        cv.notify_one();

        lock.unlock();
        worker.join();

        FL_CHECK(ready.load() == true);
        FL_CHECK(processed.load() == true);
    }

    FL_SUBCASE("notify_all wakes multiple threads") {
        constexpr int num_threads = 3;
        fl::atomic<int> wake_count(0);
        fl::vector<std::thread> threads;  // okay std namespace - fl::thread not available

        for (int i = 0; i < num_threads; ++i) {
            threads.push_back(std::thread([&]() {  // okay std namespace
                fl::unique_lock<fl::mutex> lock(mtx);
                cv.wait(lock, [&]() { return ready.load(); });
                wake_count.fetch_add(1);
            }));
        }

        // Give threads time to start waiting (reduced from 10ms to 5ms for performance)
        fl::delay(5);

        // Wake all threads
        {
            fl::unique_lock<fl::mutex> lock(mtx);
            ready.store(true);
        }
        cv.notify_all();