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

test: added meta_func

Browse Source
This commit is contained in:
Michele Caini
2020-06-10 17:37:21 +02:00
parent e8ea8f91c3
commit 08d9cfe82c
3 changed files with 313 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test/CMakeLists.txt
View File

@@ -183,6 +183,7 @@ 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_data entt/meta/meta_data.cpp)
SETUP_BASIC_TEST(meta_func entt/meta/meta_func.cpp)
SETUP_BASIC_TEST(meta_prop entt/meta/meta_prop.cpp)
list(APPEND TEST_META_SOURCES entt/meta/meta.cpp entt/meta/fixture.cpp)

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

@@ -9,238 +9,6 @@
#include <entt/meta/resolve.hpp>
#include "fixture.h"
TEST_F(Meta, MetaFunc) {
auto func = entt::resolve<func_type>().func("f2"_hs);
func_type instance{};
ASSERT_TRUE(func);
ASSERT_EQ(func.parent(), entt::resolve_id("func"_hs));
ASSERT_EQ(func.id(), "f2"_hs);
ASSERT_EQ(func.size(), 2u);
ASSERT_FALSE(func.is_const());
ASSERT_FALSE(func.is_static());
ASSERT_EQ(func.ret(), entt::resolve<int>());
ASSERT_EQ(func.arg(0u), entt::resolve<int>());
ASSERT_EQ(func.arg(1u), entt::resolve<int>());
ASSERT_FALSE(func.arg(2u));
auto any = func.invoke(instance, 3, 2);
auto empty = func.invoke(instance);
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 4);
ASSERT_EQ(func_type::value, 3);
func.prop([](auto prop) {
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(func.prop(props::prop_int));
auto prop = func.prop(props::prop_bool);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().cast<bool>());
}
TEST_F(Meta, MetaFuncConst) {
auto func = entt::resolve<func_type>().func("f1"_hs);
func_type instance{};
ASSERT_TRUE(func);
ASSERT_EQ(func.parent(), entt::resolve_id("func"_hs));
ASSERT_EQ(func.id(), "f1"_hs);
ASSERT_EQ(func.size(), 1u);
ASSERT_TRUE(func.is_const());
ASSERT_FALSE(func.is_static());
ASSERT_EQ(func.ret(), entt::resolve<int>());
ASSERT_EQ(func.arg(0u), entt::resolve<int>());
ASSERT_FALSE(func.arg(1u));
auto any = func.invoke(instance, 4);
auto empty = func.invoke(instance, 'c');
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 16);
func.prop([](auto prop) {
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(func.prop(props::prop_int));
auto prop = func.prop(props::prop_bool);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().cast<bool>());
}
TEST_F(Meta, MetaFuncRetVoid) {
auto func = entt::resolve<func_type>().func("g"_hs);
func_type instance{};
ASSERT_TRUE(func);
ASSERT_EQ(func.parent(), entt::resolve_id("func"_hs));
ASSERT_EQ(func.id(), "g"_hs);
ASSERT_EQ(func.size(), 1u);
ASSERT_FALSE(func.is_const());
ASSERT_FALSE(func.is_static());
ASSERT_EQ(func.ret(), entt::resolve<void>());
ASSERT_EQ(func.arg(0u), entt::resolve<int>());
ASSERT_FALSE(func.arg(1u));
auto any = func.invoke(instance, 5);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<void>());
ASSERT_EQ(func_type::value, 25);
func.prop([](auto prop) {
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(func.prop(props::prop_int));
auto prop = func.prop(props::prop_bool);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().cast<bool>());
}
TEST_F(Meta, MetaFuncStatic) {
auto func = entt::resolve<func_type>().func("h"_hs);
func_type::value = 2;
ASSERT_TRUE(func);
ASSERT_EQ(func.parent(), entt::resolve_id("func"_hs));
ASSERT_EQ(func.id(), "h"_hs);
ASSERT_EQ(func.size(), 1u);
ASSERT_FALSE(func.is_const());
ASSERT_TRUE(func.is_static());
ASSERT_EQ(func.ret(), entt::resolve<int>());
ASSERT_EQ(func.arg(0u), entt::resolve<int>());
ASSERT_FALSE(func.arg(1u));
auto any = func.invoke({}, 3);
auto empty = func.invoke({}, 'c');
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 6);
func.prop([](auto prop) {
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(func.prop(props::prop_int));
auto prop = func.prop(props::prop_bool);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().cast<bool>());
}
TEST_F(Meta, MetaFuncStaticRetVoid) {
auto func = entt::resolve<func_type>().func("k"_hs);
ASSERT_TRUE(func);
ASSERT_EQ(func.parent(), entt::resolve_id("func"_hs));
ASSERT_EQ(func.id(), "k"_hs);
ASSERT_EQ(func.size(), 1u);
ASSERT_FALSE(func.is_const());
ASSERT_TRUE(func.is_static());
ASSERT_EQ(func.ret(), entt::resolve<void>());
ASSERT_EQ(func.arg(0u), entt::resolve<int>());
ASSERT_FALSE(func.arg(1u));
auto any = func.invoke({}, 42);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<void>());
ASSERT_EQ(func_type::value, 42);
func.prop([](auto prop) {
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(func.prop(props::prop_int));
auto prop = func.prop(props::prop_bool);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), props::prop_bool);
ASSERT_FALSE(prop.value().cast<bool>());
}
TEST_F(Meta, MetaFuncMetaAnyArgs) {
func_type instance;
auto any = entt::resolve<func_type>().func("f1"_hs).invoke(instance, 3);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 9);
}
TEST_F(Meta, MetaFuncInvalidArgs) {
empty_type instance;
ASSERT_FALSE(entt::resolve<func_type>().func("f1"_hs).invoke(instance, 'c'));
}
TEST_F(Meta, MetaFuncCastAndConvert) {
func_type instance;
auto any = entt::resolve<func_type>().func("f3"_hs).invoke(instance, derived_type{}, 0, 3.);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 9);
}
TEST_F(Meta, MetaFuncAsVoid) {
auto func = entt::resolve<func_type>().func("v"_hs);
func_type instance{};
ASSERT_EQ(func.invoke(instance, 42), entt::meta_any{std::in_place_type<void>});
ASSERT_EQ(func.ret(), entt::resolve<void>());
ASSERT_EQ(instance.value, 42);
}
TEST_F(Meta, MetaFuncAsAlias) {
func_type instance{};
auto func = entt::resolve<func_type>().func("a"_hs);
func.invoke(instance).cast<int>() = 3;
ASSERT_EQ(func.ret(), entt::resolve<int>());
ASSERT_EQ(instance.value, 3);
}
TEST_F(Meta, MetaFuncByReference) {
auto func = entt::resolve<func_type>().func("h"_hs);
func_type::value = 2;
entt::meta_any any{3};
int value = 4;
ASSERT_EQ(func.invoke({}, std::ref(value)).cast<int>(), 8);
ASSERT_EQ(func.invoke({}, *any).cast<int>(), 6);
ASSERT_EQ(any.cast<int>(), 6);
ASSERT_EQ(value, 8);
}
TEST_F(Meta, MetaType) {
auto type = entt::resolve<derived_type>();

312
test/entt/meta/meta_func.cpp Normal file
View File

@@ -0,0 +1,312 @@
#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 {
virtual ~base_t() = default;
static void destroy(base_t &) {
++counter;
}
inline static int counter = 0;
};
struct derived_t: base_t {};
struct func_t {
int f(const base_t &, int a, int b) {
return f(a, b);
}
int f(int a, int b) {
value = a;
return b*b;
}
int f(int v) const {
return v*v;
}
void g(int v) {
value = v*v;
}
static int h(int &v) {
return (v *= value);
}
static void k(int v) {
value = v;
}
int v(int v) const {
return (value = v);
}
int & a() const {
return value;
}
inline static int value = 0;
};
struct Meta: ::testing::Test {
static void SetUpTestCase() {
entt::meta<double>().conv<int>();
entt::meta<base_t>().dtor<&base_t::destroy>();
entt::meta<derived_t>().base<base_t>().dtor<&derived_t::destroy>();
entt::meta<func_t>().type("func"_hs)
.func<entt::overload<int(const base_t &, int, int)>(&func_t::f)>("f3"_hs)
.func<entt::overload<int(int, int)>(&func_t::f)>("f2"_hs).prop(true, false)
.func<entt::overload<int(int) const>(&func_t::f)>("f1"_hs).prop(true, false)
.func<&func_t::g>("g"_hs).prop(true, false)
.func<&func_t::h>("h"_hs).prop(true, false)
.func<&func_t::k>("k"_hs).prop(true, false)
.func<&func_t::v, entt::as_void_t>("v"_hs)
.func<&func_t::a, entt::as_ref_t>("a"_hs);
}
void SetUp() override {
base_t::counter = 0;
}
};
TEST_F(Meta, MetaFunc) {
auto func = entt::resolve<func_t>().func("f2"_hs);
func_t instance{};
ASSERT_TRUE(func);
ASSERT_EQ(func.parent(), entt::resolve_id("func"_hs));
ASSERT_EQ(func.id(), "f2"_hs);
ASSERT_EQ(func.size(), 2u);
ASSERT_FALSE(func.is_const());
ASSERT_FALSE(func.is_static());
ASSERT_EQ(func.ret(), entt::resolve<int>());
ASSERT_EQ(func.arg(0u), entt::resolve<int>());
ASSERT_EQ(func.arg(1u), entt::resolve<int>());
ASSERT_FALSE(func.arg(2u));
auto any = func.invoke(instance, 3, 2);
auto empty = func.invoke(instance);
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 4);
ASSERT_EQ(func_t::value, 3);
func.prop([](auto prop) {
ASSERT_EQ(prop.key(), true);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(func.prop(false));
ASSERT_FALSE(func.prop('c'));
auto prop = func.prop(true);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), true);
ASSERT_FALSE(prop.value().cast<bool>());
}
TEST_F(Meta, MetaFuncConst) {
auto func = entt::resolve<func_t>().func("f1"_hs);
func_t instance{};
ASSERT_TRUE(func);
ASSERT_EQ(func.parent(), entt::resolve_id("func"_hs));
ASSERT_EQ(func.id(), "f1"_hs);
ASSERT_EQ(func.size(), 1u);
ASSERT_TRUE(func.is_const());
ASSERT_FALSE(func.is_static());
ASSERT_EQ(func.ret(), entt::resolve<int>());
ASSERT_EQ(func.arg(0u), entt::resolve<int>());
ASSERT_FALSE(func.arg(1u));
auto any = func.invoke(instance, 4);
auto empty = func.invoke(instance, 'c');
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 16);
func.prop([](auto prop) {
ASSERT_EQ(prop.key(), true);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(func.prop(false));
ASSERT_FALSE(func.prop('c'));
auto prop = func.prop(true);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), true);
ASSERT_FALSE(prop.value().cast<bool>());
}
TEST_F(Meta, MetaFuncRetVoid) {
auto func = entt::resolve<func_t>().func("g"_hs);
func_t instance{};
ASSERT_TRUE(func);
ASSERT_EQ(func.parent(), entt::resolve_id("func"_hs));
ASSERT_EQ(func.id(), "g"_hs);
ASSERT_EQ(func.size(), 1u);
ASSERT_FALSE(func.is_const());
ASSERT_FALSE(func.is_static());
ASSERT_EQ(func.ret(), entt::resolve<void>());
ASSERT_EQ(func.arg(0u), entt::resolve<int>());
ASSERT_FALSE(func.arg(1u));
auto any = func.invoke(instance, 5);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<void>());
ASSERT_EQ(func_t::value, 25);
func.prop([](auto prop) {
ASSERT_EQ(prop.key(), true);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(func.prop(false));
ASSERT_FALSE(func.prop('c'));
auto prop = func.prop(true);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), true);
ASSERT_FALSE(prop.value().cast<bool>());
}
TEST_F(Meta, MetaFuncStatic) {
auto func = entt::resolve<func_t>().func("h"_hs);
func_t::value = 2;
ASSERT_TRUE(func);
ASSERT_EQ(func.parent(), entt::resolve_id("func"_hs));
ASSERT_EQ(func.id(), "h"_hs);
ASSERT_EQ(func.size(), 1u);
ASSERT_FALSE(func.is_const());
ASSERT_TRUE(func.is_static());
ASSERT_EQ(func.ret(), entt::resolve<int>());
ASSERT_EQ(func.arg(0u), entt::resolve<int>());
ASSERT_FALSE(func.arg(1u));
auto any = func.invoke({}, 3);
auto empty = func.invoke({}, 'c');
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 6);
func.prop([](auto prop) {
ASSERT_EQ(prop.key(), true);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(func.prop(false));
ASSERT_FALSE(func.prop('c'));
auto prop = func.prop(true);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), true);
ASSERT_FALSE(prop.value().cast<bool>());
}
TEST_F(Meta, MetaFuncStaticRetVoid) {
auto func = entt::resolve<func_t>().func("k"_hs);
ASSERT_TRUE(func);
ASSERT_EQ(func.parent(), entt::resolve_id("func"_hs));
ASSERT_EQ(func.id(), "k"_hs);
ASSERT_EQ(func.size(), 1u);
ASSERT_FALSE(func.is_const());
ASSERT_TRUE(func.is_static());
ASSERT_EQ(func.ret(), entt::resolve<void>());
ASSERT_EQ(func.arg(0u), entt::resolve<int>());
ASSERT_FALSE(func.arg(1u));
auto any = func.invoke({}, 42);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<void>());
ASSERT_EQ(func_t::value, 42);
func.prop([](auto prop) {
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), true);
ASSERT_FALSE(prop.value().template cast<bool>());
});
ASSERT_FALSE(func.prop(false));
ASSERT_FALSE(func.prop('c'));
auto prop = func.prop(true);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.key(), true);
ASSERT_FALSE(prop.value().cast<bool>());
}
TEST_F(Meta, MetaFuncMetaAnyArgs) {
func_t instance;
auto any = entt::resolve<func_t>().func("f1"_hs).invoke(instance, 3);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 9);
}
TEST_F(Meta, MetaFuncInvalidArgs) {
int value = 3;
ASSERT_FALSE(entt::resolve<func_t>().func("f1"_hs).invoke(value, 'c'));
}
TEST_F(Meta, MetaFuncCastAndConvert) {
func_t instance;
auto any = entt::resolve<func_t>().func("f3"_hs).invoke(instance, derived_t{}, 0, 3.);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 9);
}
TEST_F(Meta, MetaFuncAsVoid) {
auto func = entt::resolve<func_t>().func("v"_hs);
func_t instance{};
ASSERT_EQ(func.invoke(instance, 42), entt::meta_any{std::in_place_type<void>});
ASSERT_EQ(func.ret(), entt::resolve<void>());
ASSERT_EQ(instance.value, 42);
}
TEST_F(Meta, MetaFuncAsAlias) {
func_t instance{};
auto func = entt::resolve<func_t>().func("a"_hs);
func.invoke(instance).cast<int>() = 3;
ASSERT_EQ(func.ret(), entt::resolve<int>());
ASSERT_EQ(instance.value, 3);
}
TEST_F(Meta, MetaFuncByReference) {
auto func = entt::resolve<func_t>().func("h"_hs);
func_t::value = 2;
entt::meta_any any{3};
int value = 4;
ASSERT_EQ(func.invoke({}, std::ref(value)).cast<int>(), 8);
ASSERT_EQ(func.invoke({}, *any).cast<int>(), 6);
ASSERT_EQ(any.cast<int>(), 6);
ASSERT_EQ(value, 8);
}