test_case.h

#pragma once
 
#include <functional>
#include <future>
#include <memory>
#include <string_view>
#include <thread>
#include <type_traits>
#include <utility>
 
namespace hegel::impl::test_case {
    struct TestCaseData;
}
 
namespace hegel::generators {
    template <typename T> class Generator;
}
 
namespace hegel {

    class TestCase {
      public:
        TestCase(const TestCase&) = delete;
        TestCase& operator=(const TestCase&) = delete;
        TestCase(TestCase&&) noexcept;
        TestCase& operator=(TestCase&&) noexcept;
        ~TestCase();

        template <typename T> T draw(const generators::Generator<T>& gen) const;

        template <typename T>
        T draw(std::string_view name, const generators::Generator<T>& gen,
               bool repeatable = false) const;

        void assume(bool condition) const;

        [[noreturn]] void reject() const;

        void target(double score, std::string_view label = "") const;

        void repeat(const std::function<void()>& body) const;

        void note(std::string_view message) const;

        TestCase clone() const;

        template <typename F> auto spawn(F fn) const;

        explicit TestCase(std::unique_ptr<impl::test_case::TestCaseData> data);
 
        // Generators reach through this accessor to talk to the backend.
        // Not part of the user-facing API.
        impl::test_case::TestCaseData* data() const { return data_.get(); }
 
      private:
        std::unique_ptr<impl::test_case::TestCaseData> data_;
    };

    template <typename T> class Worker {
      public:
        Worker(std::thread thread, std::future<T> future)
            : thread_(std::move(thread)), future_(std::move(future)) {}
        Worker(Worker&&) noexcept = default;
        Worker(const Worker&) = delete;
        Worker& operator=(const Worker&) = delete;
        ~Worker() {
            if (thread_.joinable()) {
                thread_.join();
            }
        }

        T join() {
            if (thread_.joinable()) {
                thread_.join();
            }
            return future_.get();
        }
 
      private:
        std::thread thread_;
        std::future<T> future_;
    };
 
    template <typename F> auto TestCase::spawn(F fn) const {
        using R = std::invoke_result_t<F, TestCase&>;
        std::packaged_task<R()> task(
            [fn = std::move(fn), cloned_tc = clone()]() mutable {
                return fn(cloned_tc);
            });
        std::future<R> future = task.get_future();
        return Worker<R>(std::thread(std::move(task)), std::move(future));
    }
 
} // namespace hegel