Function FL_TEST_FILE

tests/fl/task/executor.cpp:24–1072

#include "platforms/coroutine_runtime.h"  // for is_shutdown_requested()

FL_TEST_FILE(FL_FILEPATH) {

using namespace fl;
using fl::task::Executor;
using fl::task::Runner;
using fl::task::Scheduler;
using fl::task::run;
using fl::task::active_tasks;
using fl::task::has_tasks;
using fl::task::CoroutineConfig;

// Test helper: A simple test async runner
class TestAsyncRunner : public fl::task::Runner {
public:
    TestAsyncRunner() : update_count(0), active(false), task_count(0) {}

    void update() override {
        update_count++;
    }

    bool has_active_tasks() const override {
        return active;
    }

    size_t active_task_count() const override {
        return task_count;
    }

    void set_active(bool value) { active = value; }
    void set_task_count(size_t count) { task_count = count; }

    int update_count;

private:
    bool active;
    size_t task_count;
};

FL_TEST_CASE("fl::task::Runner interface") {
    FL_SUBCASE("basic implementation") {
        TestAsyncRunner runner;

        FL_CHECK_EQ(runner.update_count, 0);
        FL_CHECK_EQ(runner.has_active_tasks(), false);
        FL_CHECK_EQ(runner.active_task_count(), 0);

        runner.update();
        FL_CHECK_EQ(runner.update_count, 1);

        runner.set_active(true);
        runner.set_task_count(5);
        FL_CHECK_EQ(runner.has_active_tasks(), true);
        FL_CHECK_EQ(runner.active_task_count(), 5);
    }
}

FL_TEST_CASE("fl::task::Executor") {
    FL_SUBCASE("singleton instance") {