#include "render_3D/detail/Gpu_Completion_Service.h"
#include "render_3D/detail/Render_Domain.h"
#include <gtest/gtest.h>
#include <atomic>
#include <utility>
namespace renderive::render_3d::detail {
namespace {
static_assert(noexcept(std::declval<Gpu_Completion_Service::Reservation&>().watch(VK_NULL_HANDLE, VK_NULL_HANDLE)));
static_assert(noexcept(std::declval<Render_Domain&>().post(std::declval<Render_Domain::Prepared_Task>())));
TEST(GpuCompletionService, UsesOneProcessWideService) {
    EXPECT_EQ(&Gpu_Completion_Service::instance(), &Gpu_Completion_Service::instance());
}
TEST(GpuCompletionService, AbandonedReservationDoesNotComplete) {
    std::atomic<int> completion_count{};
    {
        auto reservation = Gpu_Completion_Service::instance().prepare(
            [&](Gpu_Completion_Service::Result) {
                completion_count.fetch_add(1, std::memory_order_relaxed);
            }, false);
    }
    EXPECT_EQ(completion_count.load(std::memory_order_relaxed), 0);
}
TEST(RenderDomain, SharesDomainPerGpuIndex) {
    auto first = Render_Domain::acquire(0);
    auto second = Render_Domain::acquire(0);
    auto other = Render_Domain::acquire(1);
    EXPECT_EQ(first, second);
    EXPECT_NE(first, other);
}
TEST(RenderDomain, PreparedTaskRunsAfterNoThrowHandoff) {
    auto domain = Render_Domain::acquire(0);
    std::atomic<bool> executed{};
    auto task = domain->prepare([&] {
        executed.store(true, std::memory_order_release);
    });
    domain->post(std::move(task));
    domain->invoke([] {});
    EXPECT_TRUE(executed.load(std::memory_order_acquire));
}
TEST(RenderDomain, AbandonedPreparedTasksReleaseReservedCapacity) {
    auto domain = Render_Domain::acquire(2);
    for (std::size_t index = 0; index < 128; ++index) {
        auto task = domain->prepare([] {});
    }
    domain->invoke([] {});
}
}
}