zecsy/tests/zecsy.cpp

#include <catch2/catch_test_macros.hpp>
#include <concepts>
#include <string>
#define CATCH_CONFIG_MAIN
#include <catch2/catch_all.hpp>

#include "../zecsy.hpp"

using namespace zecsy;

TEST_CASE("Create a single entity and verify its existence")
{
    world w;
 
    auto e = w.make_entity();
    
    REQUIRE(w.is_alive(e));
    REQUIRE(e.is_alive());
}

TEST_CASE("Destroy an entity and ensure it no longer exists in the world")
{
    world w;
    
    auto e = w.make_entity();
    w.destroy_entity(e);
    
    REQUIRE_FALSE(w.is_alive(e));
    REQUIRE_FALSE(e.is_alive());
}

TEST_CASE("Entity #0 should be reserved and never used")
{
    world w;
    
    auto e = w.make_entity();

    REQUIRE(e != 0);
    REQUIRE(entity() == 0);
    REQUIRE_FALSE(entity().is_alive());
}

struct ChoosenOne
{

};

TEST_CASE("Entity shouldn't have a component that wasn't attached to it")
{
    world w;

    auto e = w.make_entity();

    REQUIRE_FALSE(w.has<ChoosenOne>(e));
    REQUIRE_FALSE(e.has<ChoosenOne>());
}

TEST_CASE("Attempt of getting non-owned component should throw")
{
    world w;

    auto e = w.make_entity();

    REQUIRE_THROWS(w.get<ChoosenOne>(e));
    REQUIRE_THROWS(e.get<ChoosenOne>());
}

TEST_CASE("Attach a simple component to an entity and verify it is correctly associated")
{
    world w;

    auto e1 = w.make_entity();
    e1.set(ChoosenOne{});

    REQUIRE(e1.has<ChoosenOne>());
    REQUIRE(w.has<ChoosenOne>(e1));

    auto e2 = w.make_entity();
    w.set(e2, ChoosenOne{});

    REQUIRE(e2.has<ChoosenOne>());
    REQUIRE(w.has<ChoosenOne>(e2));
}
 
struct Name 
{
    std::string value;
};

TEST_CASE("Retrieve a component from an entity and verify its data matches what was set")
{
    world w;

    auto e = w.make_entity();
    e.set(Name{"zecsy!"});

    REQUIRE(e.get<Name>().value == "zecsy!");

    e.get<Name>().value = "super-zecsy!";

    REQUIRE(e.get<Name>().value == "super-zecsy!");
}

TEST_CASE("Remove a component from an entity and verify it is no longer attached")
{
    world w;

    auto e = w.make_entity();
    e.set(ChoosenOne{});
    REQUIRE_NOTHROW(e.remove<ChoosenOne>());

    REQUIRE_FALSE(e.has<ChoosenOne>());

    e.set(ChoosenOne{});
    REQUIRE_NOTHROW(w.remove<ChoosenOne>(e));

    REQUIRE_FALSE(w.has<ChoosenOne>(e));
}

TEST_CASE("Addresses of removed components should be reused")
{
    world w; 
    std::vector<entity> entities;
    std::vector<ChoosenOne*> addr;

    const int N = 4;

    for(int i = 0; i < 2; ++i)
    {
        for(int j = 0; j < N; ++j)
        {
            entities.emplace_back(w.make_entity());
            entities.back().set<ChoosenOne>();
        }

        if(addr.empty())
        {
            for(int j = 0; j < N; ++j)
            {
                addr.emplace_back(&entities[j].get<ChoosenOne>());
            }
        }
        else 
        {
            for(int j = 0; j < N; ++j)
            {
                REQUIRE(&entities[j].get<ChoosenOne>() == addr[j]);
            }
        }

        for(auto e: entities)
        {
            e.remove<ChoosenOne>();
        }
        entities.clear();
    }
}

TEST_CASE("Attach multiple components to an entity and verify all are correctly stored and retrievable")
{
    world w;

    auto e = w.make_entity();
    e.set(ChoosenOne{}, Name{"zecsy"});

    REQUIRE(e.has<ChoosenOne, Name>());
    REQUIRE(w.has<ChoosenOne, Name>(e));

    e.remove<ChoosenOne, Name>();

    REQUIRE_FALSE(e.has<ChoosenOne, Name>());
    REQUIRE_FALSE(w.has<ChoosenOne, Name>(e));
    REQUIRE_FALSE(e.has<ChoosenOne>());
    REQUIRE_FALSE(e.has<Name>());
}

TEST_CASE("Create a simple system that processes entities with a specific component and verify it executes correctly")
{
    struct Component 
    {
        int value = 0;
    };

    world w;
    auto e0 = w.make_entity(), e1 = w.make_entity();

    e0.set<Component>(); //or e0.set(Component{})
    e1.set(Component{20});

    REQUIRE(e0.get<Component>().value == 0);
    REQUIRE(e1.get<Component>().value == 20);
   
    /*
     * Really wanna deduce it to w.query([](Component&){}),
     * but I have some troubles with it
     */
    w.query<Component>([](Component& c) 
    {
        c.value++;
    });

    REQUIRE(e0.get<Component>().value == 1);
    REQUIRE(e1.get<Component>().value == 21);
}

TEST_CASE("Test a system’s ability to query and process only entities with a specific combination of components")
{
    struct C0 
    {
        int value = 0;
    };

    struct C1
    {
        int value = 10;
    };

    world w;

    auto e0 = w.make_entity();
    e0.set(C0{}, C1{});

    auto e1 = w.make_entity();
    e1.set(C0{});

    auto e2 = w.make_entity();
    e2.set(C1{});

    int count = 0;

    REQUIRE(e0.get<C0>().value == 0);
    REQUIRE(e0.get<C1>().value == 10);

    w.query<C0, C1>([&count](C0& c0, C1& c1)
    {
        c0.value++;
        c1.value++;
    });

    REQUIRE(e0.get<C0>().value == 1);
    REQUIRE(e0.get<C1>().value == 11);

    REQUIRE(e1.get<C0>().value == 0);
    REQUIRE(e2.get<C1>().value == 10);

    REQUIRE_FALSE(e1.has<C1>());
    REQUIRE_FALSE(e2.has<C0>());
}