Squashed 'external/entt/entt/' content from commit fef92113

git-subtree-dir: external/entt/entt
git-subtree-split: fef921132cae7588213d0f9bcd2fb9c8ffd8b7fc

test/entt/process/process.cpp

@@ -0,0 +1,269 @@
+#include <cstdint>
+#include <gtest/gtest.h>
+#include <entt/process/process.hpp>
+
+struct fake_delta {};
+
+template<typename Delta>
+struct fake_process: entt::process<fake_process<Delta>, Delta> {
+    using process_type = entt::process<fake_process<Delta>, Delta>;
+    using delta_type = typename process_type::delta_type;
+
+    fake_process()
+        : init_invoked{false},
+          update_invoked{false},
+          succeeded_invoked{false},
+          failed_invoked{false},
+          aborted_invoked{false} {}
+
+    void succeed() noexcept {
+        process_type::succeed();
+    }
+
+    void fail() noexcept {
+        process_type::fail();
+    }
+
+    void pause() noexcept {
+        process_type::pause();
+    }
+
+    void unpause() noexcept {
+        process_type::unpause();
+    }
+
+    void init() {
+        init_invoked = true;
+    }
+
+    void succeeded() {
+        succeeded_invoked = true;
+    }
+
+    void failed() {
+        failed_invoked = true;
+    }
+
+    void aborted() {
+        aborted_invoked = true;
+    }
+
+    void update(typename entt::process<fake_process<Delta>, Delta>::delta_type, void *data) {
+        if(data) {
+            (*static_cast<int *>(data))++;
+        }
+
+        update_invoked = true;
+    }
+
+    bool init_invoked;
+    bool update_invoked;
+    bool succeeded_invoked;
+    bool failed_invoked;
+    bool aborted_invoked;
+};
+
+TEST(Process, Basics) {
+    fake_process<int> process{};
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
+
+    process.succeed();
+    process.fail();
+    process.abort();
+    process.pause();
+    process.unpause();
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
+
+    process.tick(0);
+
+    ASSERT_TRUE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
+
+    process.pause();
+
+    ASSERT_TRUE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_TRUE(process.paused());
+    ASSERT_FALSE(process.rejected());
+
+    process.unpause();
+
+    ASSERT_TRUE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
+
+    process.fail();
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
+
+    process.tick(0);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_TRUE(process.rejected());
+}
+
+TEST(Process, Succeeded) {
+    fake_process<fake_delta> process{};
+
+    process.tick({});
+    process.tick({});
+    process.succeed();
+    process.tick({});
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_TRUE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
+
+    ASSERT_TRUE(process.init_invoked);
+    ASSERT_TRUE(process.update_invoked);
+    ASSERT_TRUE(process.succeeded_invoked);
+    ASSERT_FALSE(process.failed_invoked);
+    ASSERT_FALSE(process.aborted_invoked);
+}
+
+TEST(Process, Fail) {
+    fake_process<int> process{};
+
+    process.tick(0);
+    process.tick(0);
+    process.fail();
+    process.tick(0);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_TRUE(process.rejected());
+
+    ASSERT_TRUE(process.init_invoked);
+    ASSERT_TRUE(process.update_invoked);
+    ASSERT_FALSE(process.succeeded_invoked);
+    ASSERT_TRUE(process.failed_invoked);
+    ASSERT_FALSE(process.aborted_invoked);
+}
+
+TEST(Process, Data) {
+    fake_process<fake_delta> process{};
+    int value = 0;
+
+    process.tick({});
+    process.tick({}, &value);
+    process.succeed();
+    process.tick({}, &value);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_TRUE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
+
+    ASSERT_EQ(value, 1);
+    ASSERT_TRUE(process.init_invoked);
+    ASSERT_TRUE(process.update_invoked);
+    ASSERT_TRUE(process.succeeded_invoked);
+    ASSERT_FALSE(process.failed_invoked);
+    ASSERT_FALSE(process.aborted_invoked);
+}
+
+TEST(Process, AbortNextTick) {
+    fake_process<int> process{};
+
+    process.tick(0);
+    process.abort();
+    process.tick(0);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_TRUE(process.rejected());
+
+    ASSERT_TRUE(process.init_invoked);
+    ASSERT_FALSE(process.update_invoked);
+    ASSERT_FALSE(process.succeeded_invoked);
+    ASSERT_FALSE(process.failed_invoked);
+    ASSERT_TRUE(process.aborted_invoked);
+}
+
+TEST(Process, AbortImmediately) {
+    fake_process<fake_delta> process{};
+
+    process.tick({});
+    process.abort(true);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_TRUE(process.rejected());
+
+    ASSERT_TRUE(process.init_invoked);
+    ASSERT_FALSE(process.update_invoked);
+    ASSERT_FALSE(process.succeeded_invoked);
+    ASSERT_FALSE(process.failed_invoked);
+    ASSERT_TRUE(process.aborted_invoked);
+}
+
+TEST(ProcessAdaptor, Resolved) {
+    bool updated = false;
+    auto lambda = [&updated](std::uint64_t, void *, auto resolve, auto) {
+        ASSERT_FALSE(updated);
+        updated = true;
+        resolve();
+    };
+
+    auto process = entt::process_adaptor<decltype(lambda), std::uint64_t>{lambda};
+
+    process.tick(0);
+    process.tick(0);
+
+    ASSERT_TRUE(process.finished());
+    ASSERT_TRUE(updated);
+}
+
+TEST(ProcessAdaptor, Rejected) {
+    bool updated = false;
+    auto lambda = [&updated](std::uint64_t, void *, auto, auto rejected) {
+        ASSERT_FALSE(updated);
+        updated = true;
+        rejected();
+    };
+
+    auto process = entt::process_adaptor<decltype(lambda), std::uint64_t>{lambda};
+
+    process.tick(0);
+    process.tick(0);
+
+    ASSERT_TRUE(process.rejected());
+    ASSERT_TRUE(updated);
+}
+
+TEST(ProcessAdaptor, Data) {
+    int value = 0;
+
+    auto lambda = [](std::uint64_t, void *data, auto resolve, auto) {
+        *static_cast<int *>(data) = 42;
+        resolve();
+    };
+
+    auto process = entt::process_adaptor<decltype(lambda), std::uint64_t>{lambda};
+
+    process.tick(0);
+    process.tick(0, &value);
+
+    ASSERT_TRUE(process.finished());
+    ASSERT_EQ(value, 42);
+}

test/entt/process/scheduler.cpp

@@ -0,0 +1,154 @@
+#include <functional>
+#include <utility>
+#include <gtest/gtest.h>
+#include <entt/process/process.hpp>
+#include <entt/process/scheduler.hpp>
+
+struct foo_process: entt::process<foo_process, int> {
+    foo_process(std::function<void()> upd, std::function<void()> abort)
+        : on_update{upd}, on_aborted{abort} {}
+
+    void update(delta_type, void *) {
+        on_update();
+    }
+
+    void aborted() {
+        on_aborted();
+    }
+
+    std::function<void()> on_update;
+    std::function<void()> on_aborted;
+};
+
+struct succeeded_process: entt::process<succeeded_process, int> {
+    void update(delta_type, void *) {
+        ++invoked;
+        succeed();
+    }
+
+    static inline unsigned int invoked;
+};
+
+struct failed_process: entt::process<failed_process, int> {
+    void update(delta_type, void *) {
+        ++invoked;
+        fail();
+    }
+
+    static inline unsigned int invoked;
+};
+
+struct Scheduler: ::testing::Test {
+    void SetUp() override {
+        succeeded_process::invoked = 0u;
+        failed_process::invoked = 0u;
+    }
+};
+
+TEST_F(Scheduler, Functionalities) {
+    entt::scheduler<int> scheduler{};
+
+    bool updated = false;
+    bool aborted = false;
+
+    ASSERT_EQ(scheduler.size(), 0u);
+    ASSERT_TRUE(scheduler.empty());
+
+    scheduler.attach<foo_process>(
+        [&updated]() { updated = true; },
+        [&aborted]() { aborted = true; });
+
+    ASSERT_NE(scheduler.size(), 0u);
+    ASSERT_FALSE(scheduler.empty());
+
+    scheduler.update(0);
+    scheduler.abort(true);
+
+    ASSERT_TRUE(updated);
+    ASSERT_TRUE(aborted);
+
+    ASSERT_NE(scheduler.size(), 0u);
+    ASSERT_FALSE(scheduler.empty());
+
+    scheduler.clear();
+
+    ASSERT_EQ(scheduler.size(), 0u);
+    ASSERT_TRUE(scheduler.empty());
+}
+
+TEST_F(Scheduler, Then) {
+    entt::scheduler<int> scheduler;
+
+    // failing process with successor
+    scheduler.attach<succeeded_process>()
+        .then<succeeded_process>()
+        .then<failed_process>()
+        .then<succeeded_process>();
+
+    // failing process without successor
+    scheduler.attach<succeeded_process>()
+        .then<succeeded_process>()
+        .then<failed_process>();
+
+    // non-failing process
+    scheduler.attach<succeeded_process>()
+        .then<succeeded_process>();
+
+    ASSERT_EQ(succeeded_process::invoked, 0u);
+    ASSERT_EQ(failed_process::invoked, 0u);
+
+    while(!scheduler.empty()) {
+        scheduler.update(0);
+    }
+
+    ASSERT_EQ(succeeded_process::invoked, 6u);
+    ASSERT_EQ(failed_process::invoked, 2u);
+}
+
+TEST_F(Scheduler, Functor) {
+    entt::scheduler<int> scheduler;
+
+    bool first_functor = false;
+    bool second_functor = false;
+
+    auto attach = [&first_functor](auto, void *, auto resolve, auto) {
+        ASSERT_FALSE(first_functor);
+        first_functor = true;
+        resolve();
+    };
+
+    auto then = [&second_functor](auto, void *, auto, auto reject) {
+        ASSERT_FALSE(second_functor);
+        second_functor = true;
+        reject();
+    };
+
+    scheduler.attach(std::move(attach)).then(std::move(then)).then([](auto...) { FAIL(); });
+
+    while(!scheduler.empty()) {
+        scheduler.update(0);
+    }
+
+    ASSERT_TRUE(first_functor);
+    ASSERT_TRUE(second_functor);
+    ASSERT_TRUE(scheduler.empty());
+}
+
+TEST_F(Scheduler, SpawningProcess) {
+    entt::scheduler<int> scheduler;
+
+    scheduler.attach([&scheduler](auto, void *, auto resolve, auto) {
+        scheduler.attach<succeeded_process>().then<failed_process>();
+        resolve();
+    });
+
+    ASSERT_EQ(succeeded_process::invoked, 0u);
+    ASSERT_EQ(failed_process::invoked, 0u);
+
+    while(!scheduler.empty()) {
+        scheduler.update(0);
+    }
+
+    ASSERT_EQ(succeeded_process::invoked, 1u);
+    ASSERT_EQ(failed_process::invoked, 1u);
+}