Scarfski/entt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: added meta_ctor

Browse Source
This commit is contained in:
Michele Caini
2020-06-10 16:43:02 +02:00
parent b0b504d002
commit e7cfa7fda5
3 changed files with 150 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test/CMakeLists.txt
View File

@@ -181,6 +181,7 @@ SETUP_BASIC_TEST(meta_any entt/meta/meta_any.cpp)
SETUP_BASIC_TEST(meta_base entt/meta/meta_base.cpp)
SETUP_BASIC_TEST(meta_basic entt/meta/meta_basic.cpp)
SETUP_BASIC_TEST(meta_conv entt/meta/meta_conv.cpp)
SETUP_BASIC_TEST(meta_ctor entt/meta/meta_ctor.cpp)
SETUP_BASIC_TEST(meta_prop entt/meta/meta_prop.cpp)
list(APPEND TEST_META_SOURCES entt/meta/meta.cpp entt/meta/fixture.cpp)

107
test/entt/meta/meta.cpp
View File

@@ -9,113 +9,6 @@
#include <entt/meta/resolve.hpp>
#include "fixture.h"
TEST_F(Meta, MetaCtor) {
auto ctor = entt::resolve<derived_type>().ctor<const base_type &, int, char>();
ASSERT_TRUE(ctor);
ASSERT_EQ(ctor.parent(), entt::resolve_id("derived"_hs));
ASSERT_EQ(ctor.size(), 3u);
ASSERT_EQ(ctor.arg(0u), entt::resolve<base_type>());
ASSERT_EQ(ctor.arg(1u), entt::resolve<int>());
ASSERT_EQ(ctor.arg(2u), entt::resolve<char>());
ASSERT_FALSE(ctor.arg(3u));
auto any = ctor.invoke(base_type{}, 42, 'c');
auto empty = ctor.invoke();
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<derived_type>().i, 42);
ASSERT_EQ(any.cast<derived_type>().c, 'c');
ctor.prop([](auto prop) {
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(ctor.prop(props::prop_int));
auto prop = ctor.prop(props::prop_bool);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().template cast<bool>());
}
TEST_F(Meta, MetaCtorFunc) {
auto ctor = entt::resolve<derived_type>().ctor<const base_type &, int>();
ASSERT_TRUE(ctor);
ASSERT_EQ(ctor.parent(), entt::resolve_id("derived"_hs));
ASSERT_EQ(ctor.size(), 2u);
ASSERT_EQ(ctor.arg(0u), entt::resolve<base_type>());
ASSERT_EQ(ctor.arg(1u), entt::resolve<int>());
ASSERT_FALSE(ctor.arg(2u));
auto any = ctor.invoke(derived_type{}, 42);
auto empty = ctor.invoke(3, 'c');
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<derived_type>().i, 42);
ASSERT_EQ(any.cast<derived_type>().c, 'c');
ctor.prop([](auto prop) {
ASSERT_EQ(prop.key(), props::prop_int);
ASSERT_EQ(prop.value(), 42);
});
ASSERT_FALSE(ctor.prop(props::prop_bool));
auto prop = ctor.prop(props::prop_int);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), props::prop_int);
ASSERT_EQ(prop.value(), 42);
}
TEST_F(Meta, MetaCtorMetaAnyArgs) {
auto any = entt::resolve<derived_type>().ctor<const base_type &, int, char>().invoke(base_type{}, 42, 'c');
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<derived_type>().i, 42);
ASSERT_EQ(any.cast<derived_type>().c, 'c');
}
TEST_F(Meta, MetaCtorInvalidArgs) {
auto ctor = entt::resolve<derived_type>().ctor<const base_type &, int, char>();
ASSERT_FALSE(ctor.invoke(base_type{}, 'c', 42));
}
TEST_F(Meta, MetaCtorCastAndConvert) {
auto any = entt::resolve<derived_type>().ctor<const base_type &, int, char>().invoke(derived_type{}, 42., 'c');
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<derived_type>().i, 42);
ASSERT_EQ(any.cast<derived_type>().c, 'c');
}
TEST_F(Meta, MetaCtorFuncMetaAnyArgs) {
auto any = entt::resolve<derived_type>().ctor<const base_type &, int>().invoke(base_type{}, 42);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<derived_type>().i, 42);
ASSERT_EQ(any.cast<derived_type>().c, 'c');
}
TEST_F(Meta, MetaCtorFuncInvalidArgs) {
auto ctor = entt::resolve<derived_type>().ctor<const base_type &, int>();
ASSERT_FALSE(ctor.invoke(base_type{}, 'c'));
}
TEST_F(Meta, MetaCtorFuncCastAndConvert) {
auto any = entt::resolve<derived_type>().ctor<const base_type &, int>().invoke(derived_type{}, 42.);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<derived_type>().i, 42);
ASSERT_EQ(any.cast<derived_type>().c, 'c');
}
TEST_F(Meta, MetaData) {
auto data = entt::resolve<data_type>().data("i"_hs);
data_type instance{};

149
test/entt/meta/meta_ctor.cpp Normal file
View File

@@ -0,0 +1,149 @@
#include <gtest/gtest.h>
#include <entt/core/hashed_string.hpp>
#include <entt/core/utility.hpp>
#include <entt/meta/factory.hpp>
#include <entt/meta/meta.hpp>
#include <entt/meta/resolve.hpp>
struct base_t { char value{}; };
struct derived_t: base_t {};
struct clazz_t {
clazz_t(const base_t &other, int iv)
: clazz_t{iv, other.value}
{}
clazz_t(const int &iv, char cv)
: i{iv}, c{cv}
{}
static clazz_t factory(int value) {
return {value, 'c'};
}
static clazz_t factory(base_t other, int value, int mul) {
return {value * mul, other.value};
}
int i{};
char c{};
};
struct Meta: ::testing::Test {
static void SetUpTestCase() {
entt::meta<double>().conv<int>();
entt::meta<derived_t>().base<base_t>();
entt::meta<clazz_t>().type("clazz"_hs)
.ctor<const base_t &, int>()
.ctor<const int &, char>().prop(3, false)
.ctor<entt::overload<clazz_t(int)>(&clazz_t::factory)>().prop('c', 42)
.ctor<entt::overload<clazz_t(base_t, int, int)>(&clazz_t::factory)>();
}
};
TEST_F(Meta, MetaCtor) {
auto ctor = entt::resolve<clazz_t>().ctor<const int &, char>();
ASSERT_TRUE(ctor);
ASSERT_EQ(ctor.parent(), entt::resolve_id("clazz"_hs));
ASSERT_EQ(ctor.size(), 2u);
ASSERT_EQ(ctor.arg(0u), entt::resolve<int>());
ASSERT_EQ(ctor.arg(1u), entt::resolve<char>());
ASSERT_FALSE(ctor.arg(2u));
auto any = ctor.invoke(42, 'c');
auto empty = ctor.invoke();
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 42);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ctor.prop([](auto prop) {
ASSERT_EQ(prop.key(), 3);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(ctor.prop(2));
ASSERT_FALSE(ctor.prop('c'));
auto prop = ctor.prop(3);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), 3);
ASSERT_FALSE(prop.value().template cast<bool>());
}
TEST_F(Meta, MetaCtorFunc) {
auto ctor = entt::resolve<clazz_t>().ctor<int>();
ASSERT_TRUE(ctor);
ASSERT_EQ(ctor.parent(), entt::resolve_id("clazz"_hs));
ASSERT_EQ(ctor.size(), 1u);
ASSERT_EQ(ctor.arg(0u), entt::resolve<int>());
ASSERT_FALSE(ctor.arg(1u));
auto any = ctor.invoke(42);
auto empty = ctor.invoke(3, 'c');
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 42);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ctor.prop([](auto prop) {
ASSERT_EQ(prop.key(), 'c');
ASSERT_EQ(prop.value(), 42);
});
ASSERT_FALSE(ctor.prop('d'));
ASSERT_FALSE(ctor.prop(3));
auto prop = ctor.prop('c');
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), 'c');
ASSERT_EQ(prop.value(), 42);
}
TEST_F(Meta, MetaCtorMetaAnyArgs) {
auto any = entt::resolve<clazz_t>().ctor<int, char>().invoke(entt::meta_any{42}, entt::meta_any{'c'});
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 42);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
}
TEST_F(Meta, MetaCtorInvalidArgs) {
auto ctor = entt::resolve<clazz_t>().ctor<int, char>();
ASSERT_FALSE(ctor.invoke('c', 42));
}
TEST_F(Meta, MetaCtorCastAndConvert) {
auto any = entt::resolve<clazz_t>().ctor<const base_t &, int>().invoke(derived_t{{'c'}}, 42.);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 42);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
}
TEST_F(Meta, MetaCtorFuncMetaAnyArgs) {
auto any = entt::resolve<clazz_t>().ctor<base_t, int>().invoke(entt::meta_any{base_t{'c'}}, entt::meta_any{42});
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 42);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
}
TEST_F(Meta, MetaCtorFuncInvalidArgs) {
auto ctor = entt::resolve<clazz_t>().ctor<const base_t &, int>();
ASSERT_FALSE(ctor.invoke(base_t{}, 'c'));
}
TEST_F(Meta, MetaCtorFuncCastAndConvert) {
auto any = entt::resolve<clazz_t>().ctor<base_t, int, int>().invoke(derived_t{{'c'}}, 3., 3);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 9);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
}