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

test: avoid _t types

Browse Source
This commit is contained in:
Michele Caini
2024-02-16 10:35:54 +01:00
parent 6cab881c51
commit eb531fd7ba
11 changed files with 754 additions and 759 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
test/entt/core/compressed_pair.cpp
View File

@@ -10,15 +10,10 @@
#include <entt/core/compressed_pair.hpp>
TEST(CompressedPair, Size) {
struct local {
int value;
test::empty empty;
};
ASSERT_EQ(sizeof(entt::compressed_pair<int, int>), sizeof(int) * 2u);
ASSERT_EQ(sizeof(entt::compressed_pair<test::empty, int>), sizeof(int));
ASSERT_EQ(sizeof(entt::compressed_pair<int, test::empty>), sizeof(int));
ASSERT_LT(sizeof(entt::compressed_pair<int, test::empty>), sizeof(local));
ASSERT_LT(sizeof(entt::compressed_pair<int, test::empty>), sizeof(std::tuple<int, test::empty>));
ASSERT_LT(sizeof(entt::compressed_pair<int, test::empty>), sizeof(std::pair<int, test::empty>));
}

426
test/entt/meta/meta_any.cpp
View File

@@ -12,7 +12,7 @@
#include <entt/meta/meta.hpp>
#include <entt/meta/resolve.hpp>
struct clazz_t {
struct clazz {
void member(int i) {
value = i;
}
@@ -29,17 +29,17 @@ struct clazz_t {
int value{0};
};
struct empty_t {
empty_t() = default;
struct empty {
empty() = default;
empty_t(const empty_t &) = default;
empty_t &operator=(const empty_t &) = default;
empty(const empty &) = default;
empty &operator=(const empty &) = default;
virtual ~empty_t() {
virtual ~empty() {
++destructor_counter;
}
static void destroy(empty_t &) {
static void destroy(empty &) {
++destroy_counter;
}
@@ -47,19 +47,19 @@ struct empty_t {
inline static int destructor_counter = 0; // NOLINT
};
struct fat_t: empty_t {
fat_t()
struct fat: empty {
fat()
: value{.0, .0, .0, .0} {}
fat_t(double v1, double v2, double v3, double v4)
fat(double v1, double v2, double v3, double v4)
: value{v1, v2, v3, v4} {}
~fat_t() override = default;
~fat() override = default;
fat_t(const fat_t &) = default;
fat_t &operator=(const fat_t &) = default;
fat(const fat &) = default;
fat &operator=(const fat &) = default;
bool operator==(const fat_t &other) const {
bool operator==(const fat &other) const {
return (value == other.value);
}
@@ -71,17 +71,17 @@ enum class enum_class : unsigned short int {
bar = 1u
};
struct unmanageable_t {
unmanageable_t()
struct unmanageable {
unmanageable()
: value{std::make_unique<int>(3)} {}
~unmanageable_t() = default;
~unmanageable() = default;
unmanageable_t(const unmanageable_t &) = delete;
unmanageable_t(unmanageable_t &&) = delete;
unmanageable(const unmanageable &) = delete;
unmanageable(unmanageable &&) = delete;
unmanageable_t &operator=(const unmanageable_t &) = delete;
unmanageable_t &operator=(unmanageable_t &&) = delete;
unmanageable &operator=(const unmanageable &) = delete;
unmanageable &operator=(unmanageable &&) = delete;
std::unique_ptr<int> value;
};
@@ -90,24 +90,24 @@ struct MetaAny: ::testing::Test {
void SetUp() override {
using namespace entt::literals;
entt::meta<empty_t>()
entt::meta<empty>()
.type("empty"_hs)
.dtor<empty_t::destroy>();
.dtor<empty::destroy>();
entt::meta<fat_t>()
entt::meta<fat>()
.type("fat"_hs)
.base<empty_t>()
.dtor<fat_t::destroy>();
.base<empty>()
.dtor<fat::destroy>();
entt::meta<clazz_t>()
entt::meta<clazz>()
.type("clazz"_hs)
.data<&clazz_t::value>("value"_hs)
.func<&clazz_t::member>("member"_hs)
.func<clazz_t::func>("func"_hs)
.data<&clazz::value>("value"_hs)
.func<&clazz::member>("member"_hs)
.func<clazz::func>("func"_hs)
.conv<int>();
empty_t::destroy_counter = 0;
empty_t::destructor_counter = 0;
empty::destroy_counter = 0;
empty::destructor_counter = 0;
}
void TearDown() override {
@@ -130,16 +130,16 @@ TEST_F(MetaAny, SBO) {
}
TEST_F(MetaAny, NoSBO) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
entt::meta_any any{instance};
ASSERT_TRUE(any);
ASSERT_EQ(any.policy(), entt::meta_any_policy::owner);
ASSERT_FALSE(any.try_cast<std::size_t>());
ASSERT_EQ(any.cast<fat_t>(), instance);
ASSERT_EQ(any.cast<fat>(), instance);
ASSERT_NE(any.data(), nullptr);
ASSERT_EQ(any, entt::meta_any{instance});
ASSERT_NE(any, fat_t{});
ASSERT_NE(any, fat{});
}
TEST_F(MetaAny, Empty) {
@@ -320,7 +320,7 @@ TEST_F(MetaAny, SBODirectAssignment) {
TEST_F(MetaAny, SBOAssignValue) {
entt::meta_any any{3};
const entt::meta_any other{1};
const entt::meta_any invalid{empty_t{}};
const entt::meta_any invalid{empty{}};
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<int>(), 3);
@@ -333,7 +333,7 @@ TEST_F(MetaAny, SBOAssignValue) {
TEST_F(MetaAny, SBOConvertAssignValue) {
entt::meta_any any{3};
const entt::meta_any other{1.5};
const entt::meta_any invalid{empty_t{}};
const entt::meta_any invalid{empty{}};
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<int>(), 3);
@@ -347,7 +347,7 @@ TEST_F(MetaAny, SBOAsRefAssignValue) {
int value = 3;
entt::meta_any any{entt::forward_as_meta(value)};
const entt::meta_any other{1};
const entt::meta_any invalid{empty_t{}};
const entt::meta_any invalid{empty{}};
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<int>(), 3);
@@ -362,7 +362,7 @@ TEST_F(MetaAny, SBOAsConstRefAssignValue) {
const int value = 3;
entt::meta_any any{entt::forward_as_meta(value)};
const entt::meta_any other{1};
const entt::meta_any invalid{empty_t{}};
const entt::meta_any invalid{empty{}};
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<int>(), 3);
@@ -380,7 +380,7 @@ TEST_F(MetaAny, SBOTransferValue) {
ASSERT_EQ(any.cast<int>(), 3);
ASSERT_TRUE(any.assign(1));
ASSERT_FALSE(any.assign(empty_t{}));
ASSERT_FALSE(any.assign(empty{}));
ASSERT_EQ(any.cast<int>(), 1);
}
@@ -402,7 +402,7 @@ TEST_F(MetaAny, SBOConvertTransferValue) {
ASSERT_EQ(any.cast<int>(), 3);
ASSERT_TRUE(any.assign(1.5));
ASSERT_FALSE(any.assign(empty_t{}));
ASSERT_FALSE(any.assign(empty{}));
ASSERT_EQ(any.cast<int>(), 1);
}
@@ -414,7 +414,7 @@ TEST_F(MetaAny, SBOAsRefTransferValue) {
ASSERT_EQ(any.cast<int>(), 3);
ASSERT_TRUE(any.assign(1));
ASSERT_FALSE(any.assign(empty_t{}));
ASSERT_FALSE(any.assign(empty{}));
ASSERT_EQ(any.cast<int>(), 1);
ASSERT_EQ(value, 1);
}
@@ -427,114 +427,114 @@ TEST_F(MetaAny, SBOAsConstRefTransferValue) {
ASSERT_EQ(any.cast<int>(), 3);
ASSERT_FALSE(any.assign(1));
ASSERT_FALSE(any.assign(empty_t{}));
ASSERT_FALSE(any.assign(empty{}));
ASSERT_EQ(any.cast<int>(), 3);
ASSERT_EQ(value, 3);
}
TEST_F(MetaAny, NoSBOInPlaceTypeConstruction) {
const fat_t instance{.1, .2, .3, .4};
entt::meta_any any{std::in_place_type<fat_t>, instance};
const fat instance{.1, .2, .3, .4};
entt::meta_any any{std::in_place_type<fat>, instance};
ASSERT_TRUE(any);
ASSERT_FALSE(any.try_cast<std::size_t>());
ASSERT_EQ(any.cast<fat_t>(), instance);
ASSERT_EQ(any.cast<fat>(), instance);
ASSERT_NE(any.data(), nullptr);
ASSERT_EQ(any, (entt::meta_any{std::in_place_type<fat_t>, instance}));
ASSERT_EQ(any, (entt::meta_any{std::in_place_type<fat>, instance}));
ASSERT_EQ(any, entt::meta_any{instance});
ASSERT_NE(entt::meta_any{fat_t{}}, any);
ASSERT_NE(entt::meta_any{fat{}}, any);
}
TEST_F(MetaAny, NoSBOAsRefConstruction) {
fat_t instance{.1, .2, .3, .4};
fat instance{.1, .2, .3, .4};
auto any = entt::forward_as_meta(instance);
ASSERT_TRUE(any);
ASSERT_EQ(any.policy(), entt::meta_any_policy::ref);
ASSERT_EQ(any.type(), entt::resolve<fat_t>());
ASSERT_EQ(any.type(), entt::resolve<fat>());
ASSERT_FALSE(any.try_cast<std::size_t>());
ASSERT_EQ(any.cast<fat_t &>(), instance);
ASSERT_EQ(any.cast<const fat_t &>(), instance);
ASSERT_EQ(any.cast<fat_t>(), instance);
ASSERT_EQ(any.cast<fat &>(), instance);
ASSERT_EQ(any.cast<const fat &>(), instance);
ASSERT_EQ(any.cast<fat>(), instance);
ASSERT_EQ(any.data(), &instance);
ASSERT_EQ(std::as_const(any).data(), &instance);
ASSERT_EQ(any, entt::forward_as_meta(instance));
ASSERT_EQ(any, entt::meta_any{instance});
ASSERT_NE(entt::meta_any{fat_t{}}, any);
ASSERT_NE(entt::meta_any{fat{}}, any);
any = entt::forward_as_meta(instance);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<fat_t>());
ASSERT_EQ(any.type(), entt::resolve<fat>());
ASSERT_EQ(std::as_const(any).data(), &instance);
auto other = any.as_ref();
ASSERT_TRUE(other);
ASSERT_EQ(any.type(), entt::resolve<fat_t>());
ASSERT_EQ(any.type(), entt::resolve<fat>());
ASSERT_EQ(any, entt::meta_any{instance});
ASSERT_EQ(other.data(), any.data());
}
TEST_F(MetaAny, NoSBOAsConstRefConstruction) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
auto any = entt::forward_as_meta(instance);
ASSERT_TRUE(any);
ASSERT_EQ(any.policy(), entt::meta_any_policy::cref);
ASSERT_EQ(any.type(), entt::resolve<fat_t>());
ASSERT_EQ(any.type(), entt::resolve<fat>());
ASSERT_FALSE(any.try_cast<std::size_t>());
ASSERT_EQ(any.cast<const fat_t &>(), instance);
ASSERT_EQ(any.cast<fat_t>(), instance);
ASSERT_EQ(any.cast<const fat &>(), instance);
ASSERT_EQ(any.cast<fat>(), instance);
ASSERT_EQ(any.data(), nullptr);
ASSERT_EQ(std::as_const(any).data(), &instance);
ASSERT_EQ(any, entt::forward_as_meta(instance));
ASSERT_EQ(any, entt::meta_any{instance});
ASSERT_NE(entt::meta_any{fat_t{}}, any);
ASSERT_NE(entt::meta_any{fat{}}, any);
any = entt::forward_as_meta(std::as_const(instance));
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<fat_t>());
ASSERT_EQ(any.type(), entt::resolve<fat>());
ASSERT_EQ(std::as_const(any).data(), &instance);
auto other = any.as_ref();
ASSERT_TRUE(other);
ASSERT_EQ(any.type(), entt::resolve<fat_t>());
ASSERT_EQ(any.type(), entt::resolve<fat>());
ASSERT_EQ(any, entt::meta_any{instance});
ASSERT_EQ(other.data(), any.data());
}
ENTT_DEBUG_TEST_F(MetaAnyDeathTest, NoSBOAsConstRefConstruction) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
auto any = entt::forward_as_meta(instance);
ASSERT_TRUE(any);
ASSERT_DEATH(any.cast<fat_t &>() = {}, "");
ASSERT_DEATH(any.cast<fat &>() = {}, "");
}
TEST_F(MetaAny, NoSBOCopyConstruction) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
const entt::meta_any any{instance};
entt::meta_any other{any};
ASSERT_TRUE(any);
ASSERT_TRUE(other);
ASSERT_FALSE(other.try_cast<std::size_t>());
ASSERT_EQ(other.cast<fat_t>(), instance);
ASSERT_EQ(other.cast<fat>(), instance);
ASSERT_EQ(other, entt::meta_any{instance});
ASSERT_NE(other, fat_t{});
ASSERT_NE(other, fat{});
}
TEST_F(MetaAny, NoSBOCopyAssignment) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
const entt::meta_any any{instance};
entt::meta_any other{3};
@@ -543,13 +543,13 @@ TEST_F(MetaAny, NoSBOCopyAssignment) {
ASSERT_TRUE(any);
ASSERT_TRUE(other);
ASSERT_FALSE(other.try_cast<std::size_t>());
ASSERT_EQ(other.cast<fat_t>(), instance);
ASSERT_EQ(other.cast<fat>(), instance);
ASSERT_EQ(other, entt::meta_any{instance});
ASSERT_NE(other, fat_t{});
ASSERT_NE(other, fat{});
}
TEST_F(MetaAny, NoSBOMoveConstruction) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
entt::meta_any any{instance};
entt::meta_any other{std::move(any)};
@@ -558,13 +558,13 @@ TEST_F(MetaAny, NoSBOMoveConstruction) {
ASSERT_FALSE(any);
ASSERT_TRUE(other);
ASSERT_FALSE(other.try_cast<std::size_t>());
ASSERT_EQ(other.cast<fat_t>(), instance);
ASSERT_EQ(other.cast<fat>(), instance);
ASSERT_EQ(other, entt::meta_any{instance});
ASSERT_NE(other, fat_t{});
ASSERT_NE(other, fat{});
}
TEST_F(MetaAny, NoSBOMoveAssignment) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
entt::meta_any any{instance};
entt::meta_any other{3};
@@ -574,41 +574,41 @@ TEST_F(MetaAny, NoSBOMoveAssignment) {
ASSERT_FALSE(any);
ASSERT_TRUE(other);
ASSERT_FALSE(other.try_cast<std::size_t>());
ASSERT_EQ(other.cast<fat_t>(), instance);
ASSERT_EQ(other.cast<fat>(), instance);
ASSERT_EQ(other, entt::meta_any{instance});
ASSERT_NE(other, fat_t{});
ASSERT_NE(other, fat{});
}
TEST_F(MetaAny, NoSBODirectAssignment) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
entt::meta_any any{};
any = instance;
ASSERT_FALSE(any.try_cast<std::size_t>());
ASSERT_EQ(any.cast<fat_t>(), instance);
ASSERT_EQ(any, (entt::meta_any{fat_t{.1, .2, .3, .4}}));
ASSERT_NE(any, fat_t{});
ASSERT_EQ(any.cast<fat>(), instance);
ASSERT_EQ(any, (entt::meta_any{fat{.1, .2, .3, .4}}));
ASSERT_NE(any, fat{});
}
TEST_F(MetaAny, NoSBOAssignValue) {
entt::meta_any any{fat_t{.1, .2, .3, .4}};
const entt::meta_any other{fat_t{.0, .1, .2, .3}};
entt::meta_any any{fat{.1, .2, .3, .4}};
const entt::meta_any other{fat{.0, .1, .2, .3}};
const entt::meta_any invalid{'c'};
const void *addr = std::as_const(any).data();
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
ASSERT_TRUE(any.assign(other));
ASSERT_FALSE(any.assign(invalid));
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.0, .1, .2, .3}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.0, .1, .2, .3}));
ASSERT_EQ(addr, std::as_const(any).data());
}
TEST_F(MetaAny, NoSBOConvertAssignValue) {
entt::meta_any any{empty_t{}};
const entt::meta_any other{fat_t{.0, .1, .2, .3}};
entt::meta_any any{empty{}};
const entt::meta_any other{fat{.0, .1, .2, .3}};
const entt::meta_any invalid{'c'};
const void *addr = std::as_const(any).data();
@@ -620,103 +620,103 @@ TEST_F(MetaAny, NoSBOConvertAssignValue) {
}
TEST_F(MetaAny, NoSBOAsRefAssignValue) {
fat_t instance{.1, .2, .3, .4};
fat instance{.1, .2, .3, .4};
entt::meta_any any{entt::forward_as_meta(instance)};
const entt::meta_any other{fat_t{.0, .1, .2, .3}};
const entt::meta_any other{fat{.0, .1, .2, .3}};
const entt::meta_any invalid{'c'};
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
ASSERT_TRUE(any.assign(other));
ASSERT_FALSE(any.assign(invalid));
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.0, .1, .2, .3}));
ASSERT_EQ(instance, (fat_t{.0, .1, .2, .3}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.0, .1, .2, .3}));
ASSERT_EQ(instance, (fat{.0, .1, .2, .3}));
}
TEST_F(MetaAny, NoSBOAsConstRefAssignValue) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
entt::meta_any any{entt::forward_as_meta(instance)};
const entt::meta_any other{fat_t{.0, .1, .2, .3}};
const entt::meta_any other{fat{.0, .1, .2, .3}};
const entt::meta_any invalid{'c'};
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
ASSERT_FALSE(any.assign(other));
ASSERT_FALSE(any.assign(invalid));
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(instance, (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
ASSERT_EQ(instance, (fat{.1, .2, .3, .4}));
}
TEST_F(MetaAny, NoSBOTransferValue) {
entt::meta_any any{fat_t{.1, .2, .3, .4}};
entt::meta_any any{fat{.1, .2, .3, .4}};
const void *addr = std::as_const(any).data();
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
ASSERT_TRUE(any.assign(fat_t{.0, .1, .2, .3}));
ASSERT_TRUE(any.assign(fat{.0, .1, .2, .3}));
ASSERT_FALSE(any.assign('c'));
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.0, .1, .2, .3}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.0, .1, .2, .3}));
ASSERT_EQ(addr, std::as_const(any).data());
}
TEST_F(MetaAny, NoSBOTransferConstValue) {
const fat_t instance{.0, .1, .2, .3};
entt::meta_any any{fat_t{.1, .2, .3, .4}};
const fat instance{.0, .1, .2, .3};
entt::meta_any any{fat{.1, .2, .3, .4}};
const void *addr = std::as_const(any).data();
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
ASSERT_TRUE(any.assign(entt::forward_as_meta(instance)));
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.0, .1, .2, .3}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.0, .1, .2, .3}));
ASSERT_EQ(addr, std::as_const(any).data());
}
TEST_F(MetaAny, NoSBOConvertTransferValue) {
entt::meta_any any{empty_t{}};
entt::meta_any any{empty{}};
const void *addr = std::as_const(any).data();
ASSERT_TRUE(any);
ASSERT_TRUE(any.assign(fat_t{.0, .1, .2, .3}));
ASSERT_TRUE(any.assign(fat{.0, .1, .2, .3}));
ASSERT_FALSE(any.assign('c'));
ASSERT_EQ(addr, std::as_const(any).data());
}
TEST_F(MetaAny, NoSBOAsRefTransferValue) {
fat_t instance{.1, .2, .3, .4};
fat instance{.1, .2, .3, .4};
entt::meta_any any{entt::forward_as_meta(instance)};
const void *addr = std::as_const(any).data();
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
ASSERT_TRUE(any.assign(fat_t{.0, .1, .2, .3}));
ASSERT_TRUE(any.assign(fat{.0, .1, .2, .3}));
ASSERT_FALSE(any.assign('c'));
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.0, .1, .2, .3}));
ASSERT_EQ(instance, (fat_t{.0, .1, .2, .3}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.0, .1, .2, .3}));
ASSERT_EQ(instance, (fat{.0, .1, .2, .3}));
ASSERT_EQ(addr, std::as_const(any).data());
}
TEST_F(MetaAny, NoSBOAsConstRefTransferValue) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
entt::meta_any any{entt::forward_as_meta(instance)};
const void *addr = std::as_const(any).data();
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
ASSERT_FALSE(any.assign(fat_t{.0, .1, .2, .3}));
ASSERT_FALSE(any.assign(fat{.0, .1, .2, .3}));
ASSERT_FALSE(any.assign('c'));
ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(instance, (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
ASSERT_EQ(instance, (fat{.1, .2, .3, .4}));
ASSERT_EQ(addr, std::as_const(any).data());
}
@@ -795,7 +795,7 @@ TEST_F(MetaAny, SBOMoveInvalidate) {
}
TEST_F(MetaAny, NoSBOMoveInvalidate) {
const fat_t instance{.1, .2, .3, .4};
const fat instance{.1, .2, .3, .4};
entt::meta_any any{instance};
entt::meta_any other{std::move(any)};
const entt::meta_any valid = std::move(other);
@@ -823,28 +823,28 @@ TEST_F(MetaAny, VoidMoveInvalidate) {
TEST_F(MetaAny, SBODestruction) {
{
entt::meta_any any{std::in_place_type<empty_t>};
any.emplace<empty_t>();
any = empty_t{};
entt::meta_any any{std::in_place_type<empty>};
any.emplace<empty>();
any = empty{};
entt::meta_any other{std::move(any)};
any = std::move(other);
}
ASSERT_EQ(empty_t::destroy_counter, 3);
ASSERT_EQ(empty_t::destructor_counter, 6);
ASSERT_EQ(empty::destroy_counter, 3);
ASSERT_EQ(empty::destructor_counter, 6);
}
TEST_F(MetaAny, NoSBODestruction) {
{
entt::meta_any any{std::in_place_type<fat_t>, 1., 2., 3., 4.};
any.emplace<fat_t>(1., 2., 3., 4.);
any = fat_t{1., 2., 3., 4.};
entt::meta_any any{std::in_place_type<fat>, 1., 2., 3., 4.};
any.emplace<fat>(1., 2., 3., 4.);
any = fat{1., 2., 3., 4.};
entt::meta_any other{std::move(any)};
any = std::move(other);
}
ASSERT_EQ(fat_t::destroy_counter, 3);
ASSERT_EQ(empty_t::destructor_counter, 4);
ASSERT_EQ(fat::destroy_counter, 3);
ASSERT_EQ(empty::destructor_counter, 4);
}
TEST_F(MetaAny, VoidDestruction) {
@@ -900,13 +900,13 @@ TEST_F(MetaAny, SBOSwap) {
}
TEST_F(MetaAny, NoSBOSwap) {
entt::meta_any lhs{fat_t{.1, .2, .3, .4}};
entt::meta_any rhs{fat_t{.4, .3, .2, .1}};
entt::meta_any lhs{fat{.1, .2, .3, .4}};
entt::meta_any rhs{fat{.4, .3, .2, .1}};
std::swap(lhs, rhs);
ASSERT_EQ(lhs.cast<fat_t>(), (fat_t{.4, .3, .2, .1}));
ASSERT_EQ(rhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(lhs.cast<fat>(), (fat{.4, .3, .2, .1}));
ASSERT_EQ(rhs.cast<fat>(), (fat{.1, .2, .3, .4}));
}
TEST_F(MetaAny, VoidSwap) {
@@ -920,15 +920,15 @@ TEST_F(MetaAny, VoidSwap) {
}
TEST_F(MetaAny, SBOWithNoSBOSwap) {
entt::meta_any lhs{fat_t{.1, .2, .3, .4}};
entt::meta_any lhs{fat{.1, .2, .3, .4}};
entt::meta_any rhs{'c'};
std::swap(lhs, rhs);
ASSERT_FALSE(lhs.try_cast<fat_t>());
ASSERT_FALSE(lhs.try_cast<fat>());
ASSERT_EQ(lhs.cast<char>(), 'c');
ASSERT_FALSE(rhs.try_cast<char>());
ASSERT_EQ(rhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(rhs.cast<fat>(), (fat{.1, .2, .3, .4}));
}
TEST_F(MetaAny, SBOWithEmptySwap) {
@@ -957,33 +957,33 @@ TEST_F(MetaAny, SBOWithVoidSwap) {
}
TEST_F(MetaAny, NoSBOWithEmptySwap) {
entt::meta_any lhs{fat_t{.1, .2, .3, .4}};
entt::meta_any lhs{fat{.1, .2, .3, .4}};
entt::meta_any rhs{};
std::swap(lhs, rhs);
ASSERT_FALSE(lhs);
ASSERT_EQ(rhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(rhs.cast<fat>(), (fat{.1, .2, .3, .4}));
std::swap(lhs, rhs);
ASSERT_FALSE(rhs);
ASSERT_EQ(lhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(lhs.cast<fat>(), (fat{.1, .2, .3, .4}));
}
TEST_F(MetaAny, NoSBOWithVoidSwap) {
entt::meta_any lhs{fat_t{.1, .2, .3, .4}};
entt::meta_any lhs{fat{.1, .2, .3, .4}};
entt::meta_any rhs{std::in_place_type<void>};
std::swap(lhs, rhs);
ASSERT_EQ(lhs.type(), entt::resolve<void>());
ASSERT_EQ(rhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(rhs.cast<fat>(), (fat{.1, .2, .3, .4}));
std::swap(lhs, rhs);
ASSERT_EQ(rhs.type(), entt::resolve<void>());
ASSERT_EQ(lhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
ASSERT_EQ(lhs.cast<fat>(), (fat{.1, .2, .3, .4}));
}
TEST_F(MetaAny, AsRef) {
@@ -1107,74 +1107,74 @@ TEST_F(MetaAny, CompareVoid) {
}
TEST_F(MetaAny, TryCast) {
entt::meta_any any{fat_t{}};
entt::meta_any any{fat{}};
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<fat_t>());
ASSERT_EQ(any.type(), entt::resolve<fat>());
ASSERT_EQ(any.try_cast<void>(), nullptr);
ASSERT_NE(any.try_cast<empty_t>(), nullptr);
ASSERT_EQ(any.try_cast<fat_t>(), any.data());
ASSERT_EQ(std::as_const(any).try_cast<empty_t>(), any.try_cast<empty_t>());
ASSERT_EQ(std::as_const(any).try_cast<fat_t>(), any.data());
ASSERT_NE(any.try_cast<empty>(), nullptr);
ASSERT_EQ(any.try_cast<fat>(), any.data());
ASSERT_EQ(std::as_const(any).try_cast<empty>(), any.try_cast<empty>());
ASSERT_EQ(std::as_const(any).try_cast<fat>(), any.data());
ASSERT_EQ(std::as_const(any).try_cast<int>(), nullptr);
}
TEST_F(MetaAny, Cast) {
entt::meta_any any{fat_t{}};
entt::meta_any any{fat{}};
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<fat_t>());
ASSERT_EQ(std::as_const(any).cast<const fat_t &>(), fat_t{});
ASSERT_EQ(any.cast<const fat_t>(), fat_t{});
ASSERT_EQ(any.cast<fat_t &>(), fat_t{});
ASSERT_EQ(any.cast<fat_t>(), fat_t{});
ASSERT_EQ(any.type(), entt::resolve<fat>());
ASSERT_EQ(std::as_const(any).cast<const fat &>(), fat{});
ASSERT_EQ(any.cast<const fat>(), fat{});
ASSERT_EQ(any.cast<fat &>(), fat{});
ASSERT_EQ(any.cast<fat>(), fat{});
ASSERT_EQ(any.cast<fat_t>().value[0u], 0.);
ASSERT_EQ(any.cast<fat>().value[0u], 0.);
any.cast<fat_t &>().value[0u] = 3.;
any.cast<fat &>().value[0u] = 3.;
ASSERT_EQ(any.cast<fat_t>().value[0u], 3.);
ASSERT_EQ(any.cast<fat>().value[0u], 3.);
}
TEST_F(MetaAny, AllowCast) {
entt::meta_any clazz{clazz_t{}};
entt::meta_any fat{fat_t{}};
entt::meta_any instance{clazz{}};
entt::meta_any other{fat{}};
entt::meta_any arithmetic{3};
auto as_cref = entt::forward_as_meta(arithmetic.cast<const int &>());
ASSERT_TRUE(clazz);
ASSERT_TRUE(fat);
ASSERT_TRUE(instance);
ASSERT_TRUE(other);
ASSERT_TRUE(arithmetic);
ASSERT_TRUE(as_cref);
ASSERT_TRUE(clazz.allow_cast<clazz_t>());
ASSERT_TRUE(clazz.allow_cast<clazz_t &>());
ASSERT_TRUE(clazz.allow_cast<const clazz_t &>());
ASSERT_EQ(clazz.type(), entt::resolve<clazz_t>());
ASSERT_TRUE(instance.allow_cast<clazz>());
ASSERT_TRUE(instance.allow_cast<clazz &>());
ASSERT_TRUE(instance.allow_cast<const clazz &>());
ASSERT_EQ(instance.type(), entt::resolve<clazz>());
ASSERT_TRUE(clazz.allow_cast<const int &>());
ASSERT_EQ(clazz.type(), entt::resolve<int>());
ASSERT_TRUE(clazz.allow_cast<int>());
ASSERT_TRUE(clazz.allow_cast<int &>());
ASSERT_TRUE(clazz.allow_cast<const int &>());
ASSERT_TRUE(instance.allow_cast<const int &>());
ASSERT_EQ(instance.type(), entt::resolve<int>());
ASSERT_TRUE(instance.allow_cast<int>());
ASSERT_TRUE(instance.allow_cast<int &>());
ASSERT_TRUE(instance.allow_cast<const int &>());
ASSERT_TRUE(fat.allow_cast<fat_t>());
ASSERT_TRUE(fat.allow_cast<fat_t &>());
ASSERT_TRUE(fat.allow_cast<const empty_t &>());
ASSERT_EQ(fat.type(), entt::resolve<fat_t>());
ASSERT_FALSE(fat.allow_cast<int>());
ASSERT_TRUE(other.allow_cast<fat>());
ASSERT_TRUE(other.allow_cast<fat &>());
ASSERT_TRUE(other.allow_cast<const empty &>());
ASSERT_EQ(other.type(), entt::resolve<fat>());
ASSERT_FALSE(other.allow_cast<int>());
ASSERT_TRUE(std::as_const(fat).allow_cast<fat_t>());
ASSERT_FALSE(std::as_const(fat).allow_cast<fat_t &>());
ASSERT_TRUE(std::as_const(fat).allow_cast<const empty_t &>());
ASSERT_EQ(fat.type(), entt::resolve<fat_t>());
ASSERT_FALSE(fat.allow_cast<int>());
ASSERT_TRUE(std::as_const(other).allow_cast<fat>());
ASSERT_FALSE(std::as_const(other).allow_cast<fat &>());
ASSERT_TRUE(std::as_const(other).allow_cast<const empty &>());
ASSERT_EQ(other.type(), entt::resolve<fat>());
ASSERT_FALSE(other.allow_cast<int>());
ASSERT_TRUE(arithmetic.allow_cast<int>());
ASSERT_TRUE(arithmetic.allow_cast<int &>());
ASSERT_TRUE(arithmetic.allow_cast<const int &>());
ASSERT_EQ(arithmetic.type(), entt::resolve<int>());
ASSERT_FALSE(arithmetic.allow_cast<fat_t>());
ASSERT_FALSE(arithmetic.allow_cast<fat>());
ASSERT_TRUE(arithmetic.allow_cast<double &>());
ASSERT_EQ(arithmetic.type(), entt::resolve<double>());
@@ -1188,43 +1188,43 @@ TEST_F(MetaAny, AllowCast) {
ASSERT_FALSE(as_cref.allow_cast<int &>());
ASSERT_TRUE(as_cref.allow_cast<const int &>());
ASSERT_EQ(as_cref.type(), entt::resolve<int>());
ASSERT_FALSE(as_cref.allow_cast<fat_t>());
ASSERT_FALSE(as_cref.allow_cast<fat>());
ASSERT_TRUE(as_cref.allow_cast<double &>());
ASSERT_EQ(as_cref.type(), entt::resolve<double>());
}
TEST_F(MetaAny, OpaqueAllowCast) {
entt::meta_any clazz{clazz_t{}};
entt::meta_any fat{fat_t{}};
entt::meta_any instance{clazz{}};
entt::meta_any other{fat{}};
entt::meta_any arithmetic{3};
auto as_cref = entt::forward_as_meta(arithmetic.cast<const int &>());
ASSERT_TRUE(clazz);
ASSERT_TRUE(fat);
ASSERT_TRUE(instance);
ASSERT_TRUE(other);
ASSERT_TRUE(arithmetic);
ASSERT_TRUE(as_cref);
ASSERT_TRUE(clazz.allow_cast(entt::resolve<clazz_t>()));
ASSERT_EQ(clazz.type(), entt::resolve<clazz_t>());
ASSERT_TRUE(instance.allow_cast(entt::resolve<clazz>()));
ASSERT_EQ(instance.type(), entt::resolve<clazz>());
ASSERT_TRUE(clazz.allow_cast(entt::resolve<int>()));
ASSERT_EQ(clazz.type(), entt::resolve<int>());
ASSERT_TRUE(clazz.allow_cast(entt::resolve<int>()));
ASSERT_TRUE(instance.allow_cast(entt::resolve<int>()));
ASSERT_EQ(instance.type(), entt::resolve<int>());
ASSERT_TRUE(instance.allow_cast(entt::resolve<int>()));
ASSERT_TRUE(fat.allow_cast(entt::resolve<fat_t>()));
ASSERT_TRUE(fat.allow_cast(entt::resolve<empty_t>()));
ASSERT_EQ(fat.type(), entt::resolve<fat_t>());
ASSERT_FALSE(fat.allow_cast(entt::resolve<int>()));
ASSERT_TRUE(other.allow_cast(entt::resolve<fat>()));
ASSERT_TRUE(other.allow_cast(entt::resolve<empty>()));
ASSERT_EQ(other.type(), entt::resolve<fat>());
ASSERT_FALSE(other.allow_cast(entt::resolve<int>()));
ASSERT_TRUE(std::as_const(fat).allow_cast(entt::resolve<fat_t>()));
ASSERT_TRUE(std::as_const(fat).allow_cast(entt::resolve<empty_t>()));
ASSERT_EQ(fat.type(), entt::resolve<fat_t>());
ASSERT_FALSE(fat.allow_cast(entt::resolve<int>()));
ASSERT_TRUE(std::as_const(other).allow_cast(entt::resolve<fat>()));
ASSERT_TRUE(std::as_const(other).allow_cast(entt::resolve<empty>()));
ASSERT_EQ(other.type(), entt::resolve<fat>());
ASSERT_FALSE(other.allow_cast(entt::resolve<int>()));
ASSERT_TRUE(arithmetic.allow_cast(entt::resolve<int>()));
ASSERT_EQ(arithmetic.type(), entt::resolve<int>());
ASSERT_FALSE(arithmetic.allow_cast(entt::resolve<fat_t>()));
ASSERT_FALSE(arithmetic.allow_cast(entt::resolve<fat>()));
ASSERT_TRUE(arithmetic.allow_cast(entt::resolve<double>()));
ASSERT_EQ(arithmetic.type(), entt::resolve<double>());
@@ -1236,7 +1236,7 @@ TEST_F(MetaAny, OpaqueAllowCast) {
ASSERT_TRUE(as_cref.allow_cast(entt::resolve<int>()));
ASSERT_EQ(as_cref.type(), entt::resolve<int>());
ASSERT_FALSE(as_cref.allow_cast(entt::resolve<fat_t>()));
ASSERT_FALSE(as_cref.allow_cast(entt::resolve<fat>()));
ASSERT_TRUE(as_cref.allow_cast(entt::resolve<double>()));
ASSERT_EQ(as_cref.type(), entt::resolve<double>());
@@ -1246,14 +1246,14 @@ TEST_F(MetaAny, OpaqueAllowCast) {
}
TEST_F(MetaAny, Convert) {
entt::meta_any any{clazz_t{}};
any.cast<clazz_t &>().value = 3;
entt::meta_any any{clazz{}};
any.cast<clazz &>().value = 3;
auto as_int = std::as_const(any).allow_cast<int>();
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<clazz_t>());
ASSERT_TRUE(any.allow_cast<clazz_t>());
ASSERT_EQ(any.type(), entt::resolve<clazz_t>());
ASSERT_EQ(any.type(), entt::resolve<clazz>());
ASSERT_TRUE(any.allow_cast<clazz>());
ASSERT_EQ(any.type(), entt::resolve<clazz>());
ASSERT_TRUE(any.allow_cast<int>());
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 3);
@@ -1322,7 +1322,7 @@ TEST_F(MetaAny, EnumConversion) {
}
TEST_F(MetaAny, UnmanageableType) {
unmanageable_t instance{};
unmanageable instance{};
auto any = entt::forward_as_meta(instance);
entt::meta_any other = any.as_ref();
@@ -1331,22 +1331,22 @@ TEST_F(MetaAny, UnmanageableType) {
ASSERT_TRUE(any);
ASSERT_TRUE(other);
ASSERT_EQ(any.type(), entt::resolve<unmanageable_t>());
ASSERT_EQ(any.type(), entt::resolve<unmanageable>());
ASSERT_NE(any.data(), nullptr);
ASSERT_EQ(any.try_cast<int>(), nullptr);
ASSERT_NE(any.try_cast<unmanageable_t>(), nullptr);
ASSERT_NE(any.try_cast<unmanageable>(), nullptr);
ASSERT_TRUE(any.allow_cast<unmanageable_t>());
ASSERT_TRUE(any.allow_cast<unmanageable>());
ASSERT_FALSE(any.allow_cast<int>());
ASSERT_TRUE(std::as_const(any).allow_cast<unmanageable_t>());
ASSERT_TRUE(std::as_const(any).allow_cast<unmanageable>());
ASSERT_FALSE(std::as_const(any).allow_cast<int>());
}
TEST_F(MetaAny, Invoke) {
using namespace entt::literals;
clazz_t instance;
clazz instance;
auto any = entt::forward_as_meta(instance);
ASSERT_TRUE(any.invoke("func"_hs));
@@ -1355,14 +1355,14 @@ TEST_F(MetaAny, Invoke) {
ASSERT_FALSE(std::as_const(any).as_ref().invoke("member"_hs, 3));
ASSERT_FALSE(any.invoke("non_existent"_hs, 3));
ASSERT_EQ(clazz_t::c, 'd');
ASSERT_EQ(clazz::c, 'd');
ASSERT_EQ(instance.value, 3);
}
TEST_F(MetaAny, SetGet) {
using namespace entt::literals;
clazz_t instance;
clazz instance;
auto any = entt::forward_as_meta(instance);
ASSERT_TRUE(any.set("value"_hs, 3));

86
test/entt/meta/meta_base.cpp
View File

@@ -8,13 +8,13 @@
#include <entt/meta/node.hpp>
#include <entt/meta/resolve.hpp>
struct base_1_t {
base_1_t() = default;
struct base_1 {
base_1() = default;
int value_1{};
};
struct base_2_t {
base_2_t() = default;
struct base_2 {
base_2() = default;
operator int() const {
return value_2;
@@ -23,13 +23,13 @@ struct base_2_t {
int value_2{};
};
struct base_3_t: base_2_t {
base_3_t() = default;
struct base_3: base_2 {
base_3() = default;
int value_3{};
};
struct derived_t: base_1_t, base_3_t {
derived_t() = default;
struct derived: base_1, base_3 {
derived() = default;
int value{};
};
@@ -37,22 +37,22 @@ struct MetaBase: ::testing::Test {
void SetUp() override {
using namespace entt::literals;
entt::meta<base_1_t>()
.data<&base_1_t::value_1>("value_1"_hs);
entt::meta<base_1>()
.data<&base_1::value_1>("value_1"_hs);
entt::meta<base_2_t>()
entt::meta<base_2>()
.conv<int>()
.data<&base_2_t::value_2>("value_2"_hs);
.data<&base_2::value_2>("value_2"_hs);
entt::meta<base_3_t>()
.base<base_2_t>()
.data<&base_3_t::value_3>("value_3"_hs);
entt::meta<base_3>()
.base<base_2>()
.data<&base_3::value_3>("value_3"_hs);
entt::meta<derived_t>()
entt::meta<derived>()
.type("derived"_hs)
.base<base_1_t>()
.base<base_3_t>()
.data<&derived_t::value>("value"_hs);
.base<base_1>()
.base<base_3>()
.data<&derived::value>("value"_hs);
}
void TearDown() override {
@@ -61,34 +61,34 @@ struct MetaBase: ::testing::Test {
};
TEST_F(MetaBase, Functionalities) {
auto any = entt::resolve<derived_t>().construct();
any.cast<derived_t &>().value_1 = 2;
auto any = entt::resolve<derived>().construct();
any.cast<derived &>().value_1 = 2;
auto as_derived = any.as_ref();
ASSERT_TRUE(any.allow_cast<base_1_t &>());
ASSERT_TRUE(any.allow_cast<base_1 &>());
ASSERT_FALSE(any.allow_cast<char>());
ASSERT_FALSE(as_derived.allow_cast<char>());
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<base_1_t &>().value_1, as_derived.cast<derived_t &>().value_1);
ASSERT_EQ(any.cast<base_1 &>().value_1, as_derived.cast<derived &>().value_1);
any.cast<base_1_t &>().value_1 = 3;
any.cast<base_1 &>().value_1 = 3;
ASSERT_EQ(any.cast<const base_1_t &>().value_1, as_derived.cast<const derived_t &>().value_1);
ASSERT_EQ(any.cast<const base_1 &>().value_1, as_derived.cast<const derived &>().value_1);
}
TEST_F(MetaBase, SetGetWithMutatingThis) {
using namespace entt::literals;
derived_t instance;
derived instance;
auto any = entt::forward_as_meta(instance);
auto as_cref = std::as_const(any).as_ref();
ASSERT_NE(static_cast<const void *>(static_cast<const base_1_t *>(&instance)), static_cast<const void *>(static_cast<const base_2_t *>(&instance)));
ASSERT_NE(static_cast<const void *>(static_cast<const base_1_t *>(&instance)), static_cast<const void *>(static_cast<const base_3_t *>(&instance)));
ASSERT_EQ(static_cast<const void *>(static_cast<const base_2_t *>(&instance)), static_cast<const void *>(static_cast<const base_3_t *>(&instance)));
ASSERT_EQ(static_cast<const void *>(&instance), static_cast<const void *>(static_cast<const base_1_t *>(&instance)));
ASSERT_NE(static_cast<const void *>(static_cast<const base_1 *>(&instance)), static_cast<const void *>(static_cast<const base_2 *>(&instance)));
ASSERT_NE(static_cast<const void *>(static_cast<const base_1 *>(&instance)), static_cast<const void *>(static_cast<const base_3 *>(&instance)));
ASSERT_EQ(static_cast<const void *>(static_cast<const base_2 *>(&instance)), static_cast<const void *>(static_cast<const base_3 *>(&instance)));
ASSERT_EQ(static_cast<const void *>(&instance), static_cast<const void *>(static_cast<const base_1 *>(&instance)));
ASSERT_TRUE(any.set("value"_hs, 0));
ASSERT_TRUE(any.set("value_1"_hs, 1));
@@ -117,8 +117,8 @@ TEST_F(MetaBase, SetGetWithMutatingThis) {
}
TEST_F(MetaBase, ConvWithMutatingThis) {
entt::meta_any any{derived_t{}};
auto &&ref = any.cast<derived_t &>();
entt::meta_any any{derived{}};
auto &&ref = any.cast<derived &>();
auto as_cref = std::as_const(any).as_ref();
ref.value_2 = 2;
@@ -138,9 +138,9 @@ TEST_F(MetaBase, ConvWithMutatingThis) {
}
TEST_F(MetaBase, OpaqueConvWithMutatingThis) {
entt::meta_any any{derived_t{}};
entt::meta_any any{derived{}};
auto as_cref = std::as_const(any).as_ref();
any.cast<derived_t &>().value_2 = 2;
any.cast<derived &>().value_2 = 2;
auto conv = std::as_const(any).allow_cast(entt::resolve<int>());
auto from_cref = std::as_const(as_cref).allow_cast(entt::resolve<int>());
@@ -160,11 +160,11 @@ TEST_F(MetaBase, OpaqueConvWithMutatingThis) {
TEST_F(MetaBase, AssignWithMutatingThis) {
using namespace entt::literals;
entt::meta_any dst{base_2_t{}};
entt::meta_any src{derived_t{}};
entt::meta_any dst{base_2{}};
entt::meta_any src{derived{}};
dst.cast<base_2_t &>().value_2 = 0;
src.cast<derived_t &>().value_2 = 1;
dst.cast<base_2 &>().value_2 = 0;
src.cast<derived &>().value_2 = 1;
ASSERT_TRUE(dst.assign(src));
ASSERT_EQ(dst.get("value_2"_hs).cast<int>(), 1);
@@ -173,11 +173,11 @@ TEST_F(MetaBase, AssignWithMutatingThis) {
TEST_F(MetaBase, TransferWithMutatingThis) {
using namespace entt::literals;
entt::meta_any dst{base_2_t{}};
entt::meta_any src{derived_t{}};
entt::meta_any dst{base_2{}};
entt::meta_any src{derived{}};
dst.cast<base_2_t &>().value_2 = 0;
src.cast<derived_t &>().value_2 = 1;
dst.cast<base_2 &>().value_2 = 0;
src.cast<derived &>().value_2 = 1;
ASSERT_TRUE(dst.assign(std::move(src)));
ASSERT_EQ(dst.get("value_2"_hs).cast<int>(), 1);
@@ -186,7 +186,7 @@ TEST_F(MetaBase, TransferWithMutatingThis) {
TEST_F(MetaBase, ReRegistration) {
SetUp();
auto &&node = entt::internal::resolve<derived_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
auto &&node = entt::internal::resolve<derived>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
ASSERT_TRUE(node.details);
ASSERT_FALSE(node.details->base.empty());

22
test/entt/meta/meta_conv.cpp
View File

@@ -8,8 +8,8 @@
#include <entt/meta/node.hpp>
#include <entt/meta/resolve.hpp>
struct clazz_t {
clazz_t() = default;
struct clazz {
clazz() = default;
operator int() const {
return value;
@@ -22,7 +22,7 @@ struct clazz_t {
int value{};
};
double conv_to_double(const clazz_t &instance) {
double conv_to_double(const clazz &instance) {
return instance.value * 2.;
}
@@ -30,10 +30,10 @@ struct MetaConv: ::testing::Test {
void SetUp() override {
using namespace entt::literals;
entt::meta<clazz_t>()
entt::meta<clazz>()
.type("clazz"_hs)
.conv<int>()
.conv<&clazz_t::to_bool>()
.conv<&clazz::to_bool>()
.conv<conv_to_double>();
}
@@ -43,8 +43,8 @@ struct MetaConv: ::testing::Test {
};
TEST_F(MetaConv, Functionalities) {
auto any = entt::resolve<clazz_t>().construct();
any.cast<clazz_t &>().value = 2;
auto any = entt::resolve<clazz>().construct();
any.cast<clazz &>().value = 2;
const auto as_int = std::as_const(any).allow_cast<int>();
const auto as_bool = std::as_const(any).allow_cast<bool>();
@@ -56,15 +56,15 @@ TEST_F(MetaConv, Functionalities) {
ASSERT_TRUE(as_bool);
ASSERT_TRUE(as_double);
ASSERT_EQ(as_int.cast<int>(), any.cast<clazz_t &>().operator int());
ASSERT_EQ(as_bool.cast<bool>(), any.cast<clazz_t &>().to_bool());
ASSERT_EQ(as_double.cast<double>(), conv_to_double(any.cast<clazz_t &>()));
ASSERT_EQ(as_int.cast<int>(), any.cast<clazz &>().operator int());
ASSERT_EQ(as_bool.cast<bool>(), any.cast<clazz &>().to_bool());
ASSERT_EQ(as_double.cast<double>(), conv_to_double(any.cast<clazz &>()));
}
TEST_F(MetaConv, ReRegistration) {
SetUp();
auto &&node = entt::internal::resolve<clazz_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
auto &&node = entt::internal::resolve<clazz>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
ASSERT_TRUE(node.details);
ASSERT_FALSE(node.details->conv.empty());

118
test/entt/meta/meta_ctor.cpp
View File

@@ -10,31 +10,31 @@
#include <entt/meta/policy.hpp>
#include <entt/meta/resolve.hpp>
struct base_t {
struct base {
char value{'c'};
};
struct derived_t: base_t {
derived_t()
: base_t{} {}
struct derived: base {
derived()
: base{} {}
};
struct clazz_t {
clazz_t(const base_t &other, int &iv)
: clazz_t{iv, other.value} {}
struct clazz {
clazz(const base &other, int &iv)
: clazz{iv, other.value} {}
clazz_t(const int &iv, char cv)
clazz(const int &iv, char cv)
: i{iv}, c{cv} {}
operator int() const {
return i;
}
static clazz_t factory(int value) {
static clazz factory(int value) {
return {value, 'c'};
}
static clazz_t factory(base_t other, int value, int mul) {
static clazz factory(base other, int value, int mul) {
return {value * mul, other.value};
}
@@ -54,17 +54,17 @@ struct MetaCtor: ::testing::Test {
.type("double"_hs)
.ctor<double_factory>();
entt::meta<derived_t>()
entt::meta<derived>()
.type("derived"_hs)
.base<base_t>();
.base<base>();
entt::meta<clazz_t>()
entt::meta<clazz>()
.type("clazz"_hs)
.ctor<&entt::registry::emplace_or_replace<clazz_t, const int &, const char &>, entt::as_ref_t>()
.ctor<const base_t &, int &>()
.ctor<&entt::registry::emplace_or_replace<clazz, const int &, const char &>, entt::as_ref_t>()
.ctor<const base &, int &>()
.ctor<const int &, char>()
.ctor<entt::overload<clazz_t(int)>(clazz_t::factory)>()
.ctor<entt::overload<clazz_t(base_t, int, int)>(clazz_t::factory)>()
.ctor<entt::overload<clazz(int)>(clazz::factory)>()
.ctor<entt::overload<clazz(base, int, int)>(clazz::factory)>()
.conv<int>();
}
@@ -74,117 +74,117 @@ struct MetaCtor: ::testing::Test {
};
TEST_F(MetaCtor, Functionalities) {
auto any = entt::resolve<clazz_t>().construct(1, 'c');
auto any = entt::resolve<clazz>().construct(1, 'c');
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ASSERT_EQ(any.cast<clazz>().i, 1);
ASSERT_EQ(any.cast<clazz>().c, 'c');
}
TEST_F(MetaCtor, Func) {
auto any = entt::resolve<clazz_t>().construct(1);
auto any = entt::resolve<clazz>().construct(1);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ASSERT_EQ(any.cast<clazz>().i, 1);
ASSERT_EQ(any.cast<clazz>().c, 'c');
}
TEST_F(MetaCtor, MetaAnyArgs) {
auto any = entt::resolve<clazz_t>().construct(entt::meta_any{1}, entt::meta_any{'c'});
auto any = entt::resolve<clazz>().construct(entt::meta_any{1}, entt::meta_any{'c'});
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ASSERT_EQ(any.cast<clazz>().i, 1);
ASSERT_EQ(any.cast<clazz>().c, 'c');
}
TEST_F(MetaCtor, InvalidArgs) {
ASSERT_FALSE(entt::resolve<clazz_t>().construct(entt::meta_any{}, derived_t{}));
ASSERT_FALSE(entt::resolve<clazz>().construct(entt::meta_any{}, derived{}));
}
TEST_F(MetaCtor, CastAndConvert) {
auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{1, 'd'});
auto any = entt::resolve<clazz>().construct(derived{}, clazz{1, 'd'});
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ASSERT_EQ(any.cast<clazz>().i, 1);
ASSERT_EQ(any.cast<clazz>().c, 'c');
}
TEST_F(MetaCtor, ArithmeticConversion) {
auto any = entt::resolve<clazz_t>().construct(true, 4.2);
auto any = entt::resolve<clazz>().construct(true, 4.2);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz_t>().c, char{4});
ASSERT_EQ(any.cast<clazz>().i, 1);
ASSERT_EQ(any.cast<clazz>().c, char{4});
}
TEST_F(MetaCtor, ConstNonConstRefArgs) {
int ivalue = 1;
const char cvalue = 'c';
auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(ivalue), entt::forward_as_meta(cvalue));
auto any = entt::resolve<clazz>().construct(entt::forward_as_meta(ivalue), entt::forward_as_meta(cvalue));
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ASSERT_EQ(any.cast<clazz>().i, 1);
ASSERT_EQ(any.cast<clazz>().c, 'c');
}
TEST_F(MetaCtor, WrongConstness) {
int value = 1;
auto any = entt::resolve<clazz_t>().construct(derived_t{}, entt::forward_as_meta(value));
auto other = entt::resolve<clazz_t>().construct(derived_t{}, entt::forward_as_meta(std::as_const(value)));
auto any = entt::resolve<clazz>().construct(derived{}, entt::forward_as_meta(value));
auto other = entt::resolve<clazz>().construct(derived{}, entt::forward_as_meta(std::as_const(value)));
ASSERT_TRUE(any);
ASSERT_FALSE(other);
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ASSERT_EQ(any.cast<clazz>().i, 1);
ASSERT_EQ(any.cast<clazz>().c, 'c');
}
TEST_F(MetaCtor, FuncMetaAnyArgs) {
auto any = entt::resolve<clazz_t>().construct(entt::meta_any{1});
auto any = entt::resolve<clazz>().construct(entt::meta_any{1});
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ASSERT_EQ(any.cast<clazz>().i, 1);
ASSERT_EQ(any.cast<clazz>().c, 'c');
}
TEST_F(MetaCtor, FuncCastAndConvert) {
auto any = entt::resolve<clazz_t>().construct(derived_t{}, 3., clazz_t{3, 'd'});
auto any = entt::resolve<clazz>().construct(derived{}, 3., clazz{3, 'd'});
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 9);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ASSERT_EQ(any.cast<clazz>().i, 9);
ASSERT_EQ(any.cast<clazz>().c, 'c');
}
TEST_F(MetaCtor, FuncArithmeticConversion) {
auto any = entt::resolve<clazz_t>().construct(4.2);
auto any = entt::resolve<clazz>().construct(4.2);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().i, 4);
ASSERT_EQ(any.cast<clazz_t>().c, 'c');
ASSERT_EQ(any.cast<clazz>().i, 4);
ASSERT_EQ(any.cast<clazz>().c, 'c');
}
TEST_F(MetaCtor, FuncConstNonConstRefArgs) {
int ivalue = 1;
auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(ivalue));
auto other = entt::resolve<clazz_t>().construct(entt::forward_as_meta(std::as_const(ivalue)));
auto any = entt::resolve<clazz>().construct(entt::forward_as_meta(ivalue));
auto other = entt::resolve<clazz>().construct(entt::forward_as_meta(std::as_const(ivalue)));
ASSERT_TRUE(any);
ASSERT_TRUE(other);
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(other.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz>().i, 1);
ASSERT_EQ(other.cast<clazz>().i, 1);
}
TEST_F(MetaCtor, ExternalMemberFunction) {
entt::registry registry;
const auto entity = registry.create();
ASSERT_FALSE(registry.all_of<clazz_t>(entity));
ASSERT_FALSE(registry.all_of<clazz>(entity));
const auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(registry), entity, 3, 'c');
const auto any = entt::resolve<clazz>().construct(entt::forward_as_meta(registry), entity, 3, 'c');
ASSERT_TRUE(any);
ASSERT_TRUE(registry.all_of<clazz_t>(entity));
ASSERT_EQ(registry.get<clazz_t>(entity).i, 3);
ASSERT_EQ(registry.get<clazz_t>(entity).c, 'c');
ASSERT_TRUE(registry.all_of<clazz>(entity));
ASSERT_EQ(registry.get<clazz>(entity).i, 3);
ASSERT_EQ(registry.get<clazz>(entity).c, 'c');
}
TEST_F(MetaCtor, OverrideImplicitlyGeneratedDefaultConstructor) {
@@ -197,7 +197,7 @@ TEST_F(MetaCtor, OverrideImplicitlyGeneratedDefaultConstructor) {
}
TEST_F(MetaCtor, NonDefaultConstructibleType) {
auto type = entt::resolve<clazz_t>();
auto type = entt::resolve<clazz>();
// no implicitly generated default constructor
ASSERT_FALSE(type.construct());
}

278
test/entt/meta/meta_data.cpp
View File

@@ -14,10 +14,10 @@
#include <entt/meta/range.hpp>
#include <entt/meta/resolve.hpp>
struct base_t {
virtual ~base_t() = default;
struct base {
virtual ~base() = default;
static void destroy(base_t &) {
static void destroy(base &) {
++counter;
}
@@ -25,23 +25,23 @@ struct base_t {
int value{3};
};
struct derived_t: base_t {
derived_t() = default;
struct derived: base {
derived() = default;
};
struct clazz_t {
struct clazz {
operator int() const {
return h;
}
int i{0};
const int j{1}; // NOLINT
base_t base{};
base base{};
inline static int h{2}; // NOLINT
inline static const int k{3}; // NOLINT
};
struct setter_getter_t {
struct setter_getter {
int setter(double val) {
return value = static_cast<int>(val);
}
@@ -58,18 +58,18 @@ struct setter_getter_t {
return value;
}
static int static_setter(setter_getter_t &type, int value) {
static int static_setter(setter_getter &type, int value) {
return type.value = value;
}
static int static_getter(const setter_getter_t &type) {
static int static_getter(const setter_getter &type) {
return type.value;
}
int value{0};
};
struct multi_setter_t {
struct multi_setter {
void from_double(double val) {
value = static_cast<int>(val);
}
@@ -81,12 +81,12 @@ struct multi_setter_t {
int value{0};
};
struct array_t {
struct array {
inline static int global[2]; // NOLINT
int local[4]; // NOLINT
};
enum class property_t : entt::id_type {
enum class property_type : entt::id_type {
random,
value
};
@@ -95,51 +95,51 @@ struct MetaData: ::testing::Test {
void SetUp() override {
using namespace entt::literals;
entt::meta<base_t>()
entt::meta<base>()
.type("base"_hs)
.dtor<base_t::destroy>()
.data<&base_t::value>("value"_hs);
.dtor<base::destroy>()
.data<&base::value>("value"_hs);
entt::meta<derived_t>()
entt::meta<derived>()
.type("derived"_hs)
.base<base_t>()
.dtor<derived_t::destroy>()
.data<&base_t::value>("value_from_base"_hs);
.base<base>()
.dtor<derived::destroy>()
.data<&base::value>("value_from_base"_hs);
entt::meta<clazz_t>()
entt::meta<clazz>()
.type("clazz"_hs)
.data<&clazz_t::i, entt::as_ref_t>("i"_hs)
.data<&clazz::i, entt::as_ref_t>("i"_hs)
.prop(3u, 0)
.data<&clazz_t::i, entt::as_cref_t>("ci"_hs)
.data<&clazz_t::j>("j"_hs)
.data<&clazz::i, entt::as_cref_t>("ci"_hs)
.data<&clazz::j>("j"_hs)
.prop("true"_hs, 1)
.data<&clazz_t::h>("h"_hs)
.prop(static_cast<entt::id_type>(property_t::random), 2)
.data<&clazz_t::k>("k"_hs)
.prop(static_cast<entt::id_type>(property_t::value), 3)
.data<&clazz_t::base>("base"_hs)
.data<&clazz_t::i, entt::as_void_t>("void"_hs)
.data<&clazz::h>("h"_hs)
.prop(static_cast<entt::id_type>(property_type::random), 2)
.data<&clazz::k>("k"_hs)
.prop(static_cast<entt::id_type>(property_type::value), 3)
.data<&clazz::base>("base"_hs)
.data<&clazz::i, entt::as_void_t>("void"_hs)
.conv<int>();
entt::meta<setter_getter_t>()
entt::meta<setter_getter>()
.type("setter_getter"_hs)
.data<&setter_getter_t::static_setter, &setter_getter_t::static_getter>("x"_hs)
.data<&setter_getter_t::setter, &setter_getter_t::getter>("y"_hs)
.data<&setter_getter_t::static_setter, &setter_getter_t::getter>("z"_hs)
.data<&setter_getter_t::setter_with_ref, &setter_getter_t::getter_with_ref>("w"_hs)
.data<nullptr, &setter_getter_t::getter>("z_ro"_hs)
.data<nullptr, &setter_getter_t::value>("value"_hs);
.data<&setter_getter::static_setter, &setter_getter::static_getter>("x"_hs)
.data<&setter_getter::setter, &setter_getter::getter>("y"_hs)
.data<&setter_getter::static_setter, &setter_getter::getter>("z"_hs)
.data<&setter_getter::setter_with_ref, &setter_getter::getter_with_ref>("w"_hs)
.data<nullptr, &setter_getter::getter>("z_ro"_hs)
.data<nullptr, &setter_getter::value>("value"_hs);
entt::meta<multi_setter_t>()
entt::meta<multi_setter>()
.type("multi_setter"_hs)
.data<entt::value_list<&multi_setter_t::from_double, &multi_setter_t::from_string>, &multi_setter_t::value>("value"_hs);
.data<entt::value_list<&multi_setter::from_double, &multi_setter::from_string>, &multi_setter::value>("value"_hs);
entt::meta<array_t>()
entt::meta<array>()
.type("array"_hs)
.data<&array_t::global>("global"_hs)
.data<&array_t::local>("local"_hs);
.data<&array::global>("global"_hs)
.data<&array::local>("local"_hs);
base_t::counter = 0;
base::counter = 0;
}
void TearDown() override {
@@ -152,8 +152,8 @@ using MetaDataDeathTest = MetaData;
TEST_F(MetaData, Functionalities) {
using namespace entt::literals;
auto data = entt::resolve<clazz_t>().data("i"_hs);
clazz_t instance{};
auto data = entt::resolve<clazz>().data("i"_hs);
clazz instance{};
ASSERT_TRUE(data);
@@ -188,8 +188,8 @@ TEST_F(MetaData, Functionalities) {
TEST_F(MetaData, Const) {
using namespace entt::literals;
auto data = entt::resolve<clazz_t>().data("j"_hs);
clazz_t instance{};
auto data = entt::resolve<clazz>().data("j"_hs);
clazz instance{};
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -218,7 +218,7 @@ TEST_F(MetaData, Const) {
TEST_F(MetaData, Static) {
using namespace entt::literals;
auto data = entt::resolve<clazz_t>().data("h"_hs);
auto data = entt::resolve<clazz>().data("h"_hs);
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -231,14 +231,14 @@ TEST_F(MetaData, Static) {
ASSERT_EQ(data.get({}).cast<int>(), 1);
for(auto curr: data.prop()) {
ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_t::random));
ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_type::random));
ASSERT_EQ(curr.second.value(), 2);
}
ASSERT_FALSE(data.prop(static_cast<entt::id_type>(property_t::value)));
ASSERT_FALSE(data.prop(static_cast<entt::id_type>(property_type::value)));
ASSERT_FALSE(data.prop('c'));
auto prop = data.prop(static_cast<entt::id_type>(property_t::random));
auto prop = data.prop(static_cast<entt::id_type>(property_type::random));
ASSERT_TRUE(prop);
ASSERT_EQ(prop.value(), 2);
@@ -247,7 +247,7 @@ TEST_F(MetaData, Static) {
TEST_F(MetaData, ConstStatic) {
using namespace entt::literals;
auto data = entt::resolve<clazz_t>().data("k"_hs);
auto data = entt::resolve<clazz>().data("k"_hs);
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -260,14 +260,14 @@ TEST_F(MetaData, ConstStatic) {
ASSERT_EQ(data.get({}).cast<int>(), 3);
for(auto curr: data.prop()) {
ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_t::value));
ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_type::value));
ASSERT_EQ(curr.second.value(), 3);
}
ASSERT_FALSE(data.prop(static_cast<entt::id_type>(property_t::random)));
ASSERT_FALSE(data.prop(static_cast<entt::id_type>(property_type::random)));
ASSERT_FALSE(data.prop('c'));
auto prop = data.prop(static_cast<entt::id_type>(property_t::value));
auto prop = data.prop(static_cast<entt::id_type>(property_type::value));
ASSERT_TRUE(prop);
ASSERT_EQ(prop.value(), 3);
@@ -276,9 +276,9 @@ TEST_F(MetaData, ConstStatic) {
TEST_F(MetaData, GetMetaAnyArg) {
using namespace entt::literals;
entt::meta_any any{clazz_t{}};
any.cast<clazz_t &>().i = 3;
const auto value = entt::resolve<clazz_t>().data("i"_hs).get(any);
entt::meta_any any{clazz{}};
any.cast<clazz &>().i = 3;
const auto value = entt::resolve<clazz>().data("i"_hs).get(any);
ASSERT_TRUE(value);
ASSERT_TRUE(static_cast<bool>(value.cast<int>()));
@@ -289,86 +289,86 @@ TEST_F(MetaData, GetInvalidArg) {
using namespace entt::literals;
auto instance = 0;
ASSERT_FALSE(entt::resolve<clazz_t>().data("i"_hs).get(instance));
ASSERT_FALSE(entt::resolve<clazz>().data("i"_hs).get(instance));
}
TEST_F(MetaData, SetMetaAnyArg) {
using namespace entt::literals;
entt::meta_any any{clazz_t{}};
entt::meta_any any{clazz{}};
const entt::meta_any value{1};
ASSERT_EQ(any.cast<clazz_t>().i, 0);
ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, value));
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz>().i, 0);
ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(any, value));
ASSERT_EQ(any.cast<clazz>().i, 1);
}
TEST_F(MetaData, SetInvalidArg) {
using namespace entt::literals;
ASSERT_FALSE(entt::resolve<clazz_t>().data("i"_hs).set({}, 'c'));
ASSERT_FALSE(entt::resolve<clazz>().data("i"_hs).set({}, 'c'));
}
TEST_F(MetaData, SetCast) {
using namespace entt::literals;
clazz_t instance{};
clazz instance{};
ASSERT_EQ(base_t::counter, 0);
ASSERT_TRUE(entt::resolve<clazz_t>().data("base"_hs).set(instance, derived_t{}));
ASSERT_EQ(base_t::counter, 1);
ASSERT_EQ(base::counter, 0);
ASSERT_TRUE(entt::resolve<clazz>().data("base"_hs).set(instance, derived{}));
ASSERT_EQ(base::counter, 1);
}
TEST_F(MetaData, SetConvert) {
using namespace entt::literals;
clazz_t instance{};
clazz instance{};
instance.h = 1;
ASSERT_EQ(instance.i, 0);
ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(instance, instance));
ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(instance, instance));
ASSERT_EQ(instance.i, 1);
}
TEST_F(MetaData, SetByRef) {
using namespace entt::literals;
entt::meta_any any{clazz_t{}};
entt::meta_any any{clazz{}};
int value{1};
ASSERT_EQ(any.cast<clazz_t>().i, 0);
ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::forward_as_meta(value)));
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz>().i, 0);
ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(any, entt::forward_as_meta(value)));
ASSERT_EQ(any.cast<clazz>().i, 1);
value = 3;
auto wrapper = entt::forward_as_meta(value);
ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, wrapper.as_ref()));
ASSERT_EQ(any.cast<clazz_t>().i, 3);
ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(any, wrapper.as_ref()));
ASSERT_EQ(any.cast<clazz>().i, 3);
}
TEST_F(MetaData, SetByConstRef) {
using namespace entt::literals;
entt::meta_any any{clazz_t{}};
entt::meta_any any{clazz{}};
int value{1};
ASSERT_EQ(any.cast<clazz_t>().i, 0);
ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::forward_as_meta(std::as_const(value))));
ASSERT_EQ(any.cast<clazz_t>().i, 1);
ASSERT_EQ(any.cast<clazz>().i, 0);
ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(any, entt::forward_as_meta(std::as_const(value))));
ASSERT_EQ(any.cast<clazz>().i, 1);
value = 3;
auto wrapper = entt::forward_as_meta(std::as_const(value));
ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, wrapper.as_ref()));
ASSERT_EQ(any.cast<clazz_t>().i, 3);
ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(any, wrapper.as_ref()));
ASSERT_EQ(any.cast<clazz>().i, 3);
}
TEST_F(MetaData, SetterGetterAsFreeFunctions) {
using namespace entt::literals;
auto data = entt::resolve<setter_getter_t>().data("x"_hs);
setter_getter_t instance{};
auto data = entt::resolve<setter_getter>().data("x"_hs);
setter_getter instance{};
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -384,8 +384,8 @@ TEST_F(MetaData, SetterGetterAsFreeFunctions) {
TEST_F(MetaData, SetterGetterAsMemberFunctions) {
using namespace entt::literals;
auto data = entt::resolve<setter_getter_t>().data("y"_hs);
setter_getter_t instance{};
auto data = entt::resolve<setter_getter>().data("y"_hs);
setter_getter instance{};
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -403,8 +403,8 @@ TEST_F(MetaData, SetterGetterAsMemberFunctions) {
TEST_F(MetaData, SetterGetterWithRefAsMemberFunctions) {
using namespace entt::literals;
auto data = entt::resolve<setter_getter_t>().data("w"_hs);
setter_getter_t instance{};
auto data = entt::resolve<setter_getter>().data("w"_hs);
setter_getter instance{};
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -420,8 +420,8 @@ TEST_F(MetaData, SetterGetterWithRefAsMemberFunctions) {
TEST_F(MetaData, SetterGetterMixed) {
using namespace entt::literals;
auto data = entt::resolve<setter_getter_t>().data("z"_hs);
setter_getter_t instance{};
auto data = entt::resolve<setter_getter>().data("z"_hs);
setter_getter instance{};
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -437,8 +437,8 @@ TEST_F(MetaData, SetterGetterMixed) {
TEST_F(MetaData, SetterGetterReadOnly) {
using namespace entt::literals;
auto data = entt::resolve<setter_getter_t>().data("z_ro"_hs);
setter_getter_t instance{};
auto data = entt::resolve<setter_getter>().data("z_ro"_hs);
setter_getter instance{};
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 0u);
@@ -454,8 +454,8 @@ TEST_F(MetaData, SetterGetterReadOnly) {
TEST_F(MetaData, SetterGetterReadOnlyDataMember) {
using namespace entt::literals;
auto data = entt::resolve<setter_getter_t>().data("value"_hs);
setter_getter_t instance{};
auto data = entt::resolve<setter_getter>().data("value"_hs);
setter_getter instance{};
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 0u);
@@ -471,8 +471,8 @@ TEST_F(MetaData, SetterGetterReadOnlyDataMember) {
TEST_F(MetaData, MultiSetter) {
using namespace entt::literals;
auto data = entt::resolve<multi_setter_t>().data("value"_hs);
multi_setter_t instance{};
auto data = entt::resolve<multi_setter>().data("value"_hs);
multi_setter instance{};
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 2u);
@@ -495,34 +495,34 @@ TEST_F(MetaData, MultiSetter) {
TEST_F(MetaData, ConstInstance) {
using namespace entt::literals;
clazz_t instance{};
clazz instance{};
ASSERT_NE(entt::resolve<clazz_t>().data("i"_hs).get(instance).try_cast<int>(), nullptr);
ASSERT_NE(entt::resolve<clazz_t>().data("i"_hs).get(instance).try_cast<const int>(), nullptr);
ASSERT_EQ(entt::resolve<clazz_t>().data("i"_hs).get(std::as_const(instance)).try_cast<int>(), nullptr);
ASSERT_NE(entt::resolve<clazz>().data("i"_hs).get(instance).try_cast<int>(), nullptr);
ASSERT_NE(entt::resolve<clazz>().data("i"_hs).get(instance).try_cast<const int>(), nullptr);
ASSERT_EQ(entt::resolve<clazz>().data("i"_hs).get(std::as_const(instance)).try_cast<int>(), nullptr);
// as_ref_t adapts to the constness of the passed object and returns const references in case
ASSERT_NE(entt::resolve<clazz_t>().data("i"_hs).get(std::as_const(instance)).try_cast<const int>(), nullptr);
ASSERT_NE(entt::resolve<clazz>().data("i"_hs).get(std::as_const(instance)).try_cast<const int>(), nullptr);
ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).get(instance));
ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(instance, 3));
ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).get(std::as_const(instance)));
ASSERT_FALSE(entt::resolve<clazz_t>().data("i"_hs).set(std::as_const(instance), 3));
ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).get(instance));
ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(instance, 3));
ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).get(std::as_const(instance)));
ASSERT_FALSE(entt::resolve<clazz>().data("i"_hs).set(std::as_const(instance), 3));
ASSERT_TRUE(entt::resolve<clazz_t>().data("ci"_hs).get(instance));
ASSERT_TRUE(entt::resolve<clazz_t>().data("ci"_hs).set(instance, 3));
ASSERT_TRUE(entt::resolve<clazz_t>().data("ci"_hs).get(std::as_const(instance)));
ASSERT_FALSE(entt::resolve<clazz_t>().data("ci"_hs).set(std::as_const(instance), 3));
ASSERT_TRUE(entt::resolve<clazz>().data("ci"_hs).get(instance));
ASSERT_TRUE(entt::resolve<clazz>().data("ci"_hs).set(instance, 3));
ASSERT_TRUE(entt::resolve<clazz>().data("ci"_hs).get(std::as_const(instance)));
ASSERT_FALSE(entt::resolve<clazz>().data("ci"_hs).set(std::as_const(instance), 3));
ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs).get(instance));
ASSERT_FALSE(entt::resolve<clazz_t>().data("j"_hs).set(instance, 3));
ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs).get(std::as_const(instance)));
ASSERT_FALSE(entt::resolve<clazz_t>().data("j"_hs).set(std::as_const(instance), 3));
ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs).get(instance));
ASSERT_FALSE(entt::resolve<clazz>().data("j"_hs).set(instance, 3));
ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs).get(std::as_const(instance)));
ASSERT_FALSE(entt::resolve<clazz>().data("j"_hs).set(std::as_const(instance), 3));
}
TEST_F(MetaData, ArrayStatic) {
using namespace entt::literals;
auto data = entt::resolve<array_t>().data("global"_hs);
auto data = entt::resolve<array>().data("global"_hs);
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -539,8 +539,8 @@ TEST_F(MetaData, ArrayStatic) {
TEST_F(MetaData, Array) {
using namespace entt::literals;
auto data = entt::resolve<array_t>().data("local"_hs);
array_t instance{};
auto data = entt::resolve<array>().data("local"_hs);
array instance{};
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -557,8 +557,8 @@ TEST_F(MetaData, Array) {
TEST_F(MetaData, AsVoid) {
using namespace entt::literals;
auto data = entt::resolve<clazz_t>().data("void"_hs);
clazz_t instance{};
auto data = entt::resolve<clazz>().data("void"_hs);
clazz instance{};
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -572,8 +572,8 @@ TEST_F(MetaData, AsVoid) {
TEST_F(MetaData, AsRef) {
using namespace entt::literals;
clazz_t instance{};
auto data = entt::resolve<clazz_t>().data("i"_hs);
clazz instance{};
auto data = entt::resolve<clazz>().data("i"_hs);
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
@@ -590,8 +590,8 @@ TEST_F(MetaData, AsRef) {
TEST_F(MetaData, AsConstRef) {
using namespace entt::literals;
clazz_t instance{};
auto data = entt::resolve<clazz_t>().data("ci"_hs);
clazz instance{};
auto data = entt::resolve<clazz>().data("ci"_hs);
ASSERT_EQ(instance.i, 0);
ASSERT_EQ(data.arity(), 1u);
@@ -606,8 +606,8 @@ TEST_F(MetaData, AsConstRef) {
ENTT_DEBUG_TEST_F(MetaDataDeathTest, AsConstRef) {
using namespace entt::literals;
clazz_t instance{};
auto data = entt::resolve<clazz_t>().data("ci"_hs);
clazz instance{};
auto data = entt::resolve<clazz>().data("ci"_hs);
ASSERT_DEATH(data.get(instance).cast<int &>() = 3, "");
}
@@ -615,8 +615,8 @@ ENTT_DEBUG_TEST_F(MetaDataDeathTest, AsConstRef) {
TEST_F(MetaData, SetGetBaseData) {
using namespace entt::literals;
auto type = entt::resolve<derived_t>();
derived_t instance{};
auto type = entt::resolve<derived>();
derived instance{};
ASSERT_TRUE(type.data("value"_hs));
@@ -629,8 +629,8 @@ TEST_F(MetaData, SetGetBaseData) {
TEST_F(MetaData, SetGetFromBase) {
using namespace entt::literals;
auto type = entt::resolve<derived_t>();
derived_t instance{};
auto type = entt::resolve<derived>();
derived instance{};
ASSERT_TRUE(type.data("value_from_base"_hs));
@@ -645,15 +645,15 @@ TEST_F(MetaData, ReRegistration) {
SetUp();
auto &&node = entt::internal::resolve<base_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
auto type = entt::resolve<base_t>();
auto &&node = entt::internal::resolve<base>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
auto type = entt::resolve<base>();
ASSERT_TRUE(node.details);
ASSERT_FALSE(node.details->data.empty());
ASSERT_EQ(node.details->data.size(), 1u);
ASSERT_TRUE(type.data("value"_hs));
entt::meta<base_t>().data<&base_t::value>("field"_hs);
entt::meta<base>().data<&base::value>("field"_hs);
ASSERT_TRUE(node.details);
ASSERT_EQ(node.details->data.size(), 2u);
@@ -664,14 +664,14 @@ TEST_F(MetaData, ReRegistration) {
TEST_F(MetaData, CollisionAndReuse) {
using namespace entt::literals;
ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs));
ASSERT_FALSE(entt::resolve<clazz_t>().data("cj"_hs));
ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs).is_const());
ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs));
ASSERT_FALSE(entt::resolve<clazz>().data("cj"_hs));
ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs).is_const());
ASSERT_NO_THROW(entt::meta<clazz_t>().data<&clazz_t::i>("j"_hs));
ASSERT_NO_THROW(entt::meta<clazz_t>().data<&clazz_t::j>("cj"_hs));
ASSERT_NO_THROW(entt::meta<clazz>().data<&clazz::i>("j"_hs));
ASSERT_NO_THROW(entt::meta<clazz>().data<&clazz::j>("cj"_hs));
ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs));
ASSERT_TRUE(entt::resolve<clazz_t>().data("cj"_hs));
ASSERT_FALSE(entt::resolve<clazz_t>().data("j"_hs).is_const());
ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs));
ASSERT_TRUE(entt::resolve<clazz>().data("cj"_hs));
ASSERT_FALSE(entt::resolve<clazz>().data("j"_hs).is_const());
}

20
test/entt/meta/meta_dtor.cpp
View File

@@ -8,13 +8,13 @@
#include <entt/meta/node.hpp>
#include <entt/meta/resolve.hpp>
struct clazz_t {
clazz_t(int &cnt)
struct clazz {
clazz(int &cnt)
: counter{&cnt} {
++(*counter);
}
static void destroy_decr(clazz_t &instance) {
static void destroy_decr(clazz &instance) {
--(*instance.counter);
}
@@ -29,10 +29,10 @@ struct MetaDtor: ::testing::Test {
void SetUp() override {
using namespace entt::literals;
entt::meta<clazz_t>()
entt::meta<clazz>()
.type("clazz"_hs)
.ctor<int &>()
.dtor<clazz_t::destroy_decr>();
.dtor<clazz::destroy_decr>();
}
void TearDown() override {
@@ -43,7 +43,7 @@ struct MetaDtor: ::testing::Test {
TEST_F(MetaDtor, Functionalities) {
int counter{};
auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(counter));
auto any = entt::resolve<clazz>().construct(entt::forward_as_meta(counter));
auto cref = std::as_const(any).as_ref();
auto ref = any.as_ref();
@@ -74,7 +74,7 @@ TEST_F(MetaDtor, Functionalities) {
TEST_F(MetaDtor, AsRefConstruction) {
int counter{};
clazz_t instance{counter};
clazz instance{counter};
auto any = entt::forward_as_meta(instance);
auto cany = entt::forward_as_meta(std::as_const(instance));
auto cref = cany.as_ref();
@@ -104,12 +104,12 @@ TEST_F(MetaDtor, ReRegistration) {
SetUp();
int counter{};
auto &&node = entt::internal::resolve<clazz_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
auto &&node = entt::internal::resolve<clazz>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
ASSERT_NE(node.dtor.dtor, nullptr);
entt::meta<clazz_t>().dtor<&clazz_t::destroy_incr>();
entt::resolve<clazz_t>().construct(entt::forward_as_meta(counter)).reset();
entt::meta<clazz>().dtor<&clazz::destroy_incr>();
entt::resolve<clazz>().construct(entt::forward_as_meta(counter)).reset();
ASSERT_EQ(counter, 2);
}

178
test/entt/meta/meta_func.cpp
View File

@@ -11,11 +11,11 @@
#include <entt/meta/range.hpp>
#include <entt/meta/resolve.hpp>
struct base_t {
base_t() = default;
virtual ~base_t() = default;
struct base {
base() = default;
virtual ~base() = default;
static void destroy(base_t &) {
static void destroy(base &) {
++counter;
}
@@ -27,7 +27,7 @@ struct base_t {
return value;
}
static void static_setter(base_t &ref, int v) {
static void static_setter(base &ref, int v) {
ref.value = v;
}
@@ -35,21 +35,21 @@ struct base_t {
int value{3};
};
void fake_member(base_t &instance, int value) {
void fake_member(base &instance, int value) {
instance.value = value;
}
[[nodiscard]] int fake_const_member(const base_t &instance) {
[[nodiscard]] int fake_const_member(const base &instance) {
return instance.value;
}
struct derived_t: base_t {
derived_t()
: base_t{} {}
struct derived: base {
derived()
: base{} {}
};
struct func_t {
[[nodiscard]] int f(const base_t &, int a, int b) {
struct function {
[[nodiscard]] int f(const base &, int a, int b) {
return f(a, b);
}
@@ -101,41 +101,41 @@ struct MetaFunc: ::testing::Test {
.type("double"_hs)
.func<&double_member>("member"_hs);
entt::meta<base_t>()
entt::meta<base>()
.type("base"_hs)
.dtor<base_t::destroy>()
.func<&base_t::setter>("setter"_hs)
.dtor<base::destroy>()
.func<&base::setter>("setter"_hs)
.func<fake_member>("fake_member"_hs)
.func<fake_const_member>("fake_const_member"_hs);
entt::meta<derived_t>()
entt::meta<derived>()
.type("derived"_hs)
.base<base_t>()
.func<&base_t::setter>("setter_from_base"_hs)
.func<&base_t::getter>("getter_from_base"_hs)
.func<&base_t::static_setter>("static_setter_from_base"_hs)
.dtor<derived_t::destroy>();
.base<base>()
.func<&base::setter>("setter_from_base"_hs)
.func<&base::getter>("getter_from_base"_hs)
.func<&base::static_setter>("static_setter_from_base"_hs)
.dtor<derived::destroy>();
entt::meta<func_t>()
entt::meta<function>()
.type("func"_hs)
.func<&entt::registry::emplace_or_replace<func_t>>("emplace"_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)
.func<&entt::registry::emplace_or_replace<function>>("emplace"_hs)
.func<entt::overload<int(const base &, int, int)>(&function::f)>("f3"_hs)
.func<entt::overload<int(int, int)>(&function::f)>("f2"_hs)
.prop("true"_hs, false)
.func<entt::overload<int(int) const>(&func_t::f)>("f1"_hs)
.func<entt::overload<int(int) const>(&function::f)>("f1"_hs)
.prop("true"_hs, false)
.func<&func_t::g>("g"_hs)
.func<&function::g>("g"_hs)
.prop("true"_hs, false)
.func<func_t::h>("h"_hs)
.func<function::h>("h"_hs)
.prop("true"_hs, false)
.func<func_t::k>("k"_hs)
.func<function::k>("k"_hs)
.prop("true"_hs, false)
.func<&func_t::v, entt::as_void_t>("v"_hs)
.func<&func_t::a, entt::as_ref_t>("a"_hs)
.func<&func_t::a, entt::as_cref_t>("ca"_hs)
.func<&function::v, entt::as_void_t>("v"_hs)
.func<&function::a, entt::as_ref_t>("a"_hs)
.func<&function::a, entt::as_cref_t>("ca"_hs)
.conv<int>();
base_t::counter = 0;
base::counter = 0;
}
void TearDown() override {
@@ -145,7 +145,7 @@ struct MetaFunc: ::testing::Test {
std::size_t reset_and_check() {
std::size_t count = 0;
for(auto func: entt::resolve<func_t>().func()) {
for(auto func: entt::resolve<function>().func()) {
for(auto curr = func.second; curr; curr = curr.next()) {
++count;
}
@@ -153,7 +153,7 @@ struct MetaFunc: ::testing::Test {
SetUp();
for(auto func: entt::resolve<func_t>().func()) {
for(auto func: entt::resolve<function>().func()) {
for(auto curr = func.second; curr; curr = curr.next()) {
--count;
}
@@ -168,8 +168,8 @@ using MetaFuncDeathTest = MetaFunc;
TEST_F(MetaFunc, Functionalities) {
using namespace entt::literals;
auto func = entt::resolve<func_t>().func("f2"_hs);
func_t instance{};
auto func = entt::resolve<function>().func("f2"_hs);
function instance{};
ASSERT_TRUE(func);
@@ -193,7 +193,7 @@ TEST_F(MetaFunc, Functionalities) {
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
ASSERT_EQ(any.cast<int>(), 4);
ASSERT_EQ(func_t::value, 3);
ASSERT_EQ(function::value, 3);
for(auto curr: func.prop()) {
ASSERT_EQ(curr.first, "true"_hs);
@@ -212,8 +212,8 @@ TEST_F(MetaFunc, Functionalities) {
TEST_F(MetaFunc, Const) {
using namespace entt::literals;
auto func = entt::resolve<func_t>().func("f1"_hs);
func_t instance{};
auto func = entt::resolve<function>().func("f1"_hs);
function instance{};
ASSERT_TRUE(func);
ASSERT_EQ(func.arity(), 1u);
@@ -224,7 +224,7 @@ TEST_F(MetaFunc, Const) {
ASSERT_FALSE(func.arg(1u));
auto any = func.invoke(instance, 4);
auto empty = func.invoke(instance, derived_t{});
auto empty = func.invoke(instance, derived{});
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
@@ -248,8 +248,8 @@ TEST_F(MetaFunc, Const) {
TEST_F(MetaFunc, RetVoid) {
using namespace entt::literals;
auto func = entt::resolve<func_t>().func("g"_hs);
func_t instance{};
auto func = entt::resolve<function>().func("g"_hs);
function instance{};
ASSERT_TRUE(func);
ASSERT_EQ(func.arity(), 1u);
@@ -263,7 +263,7 @@ TEST_F(MetaFunc, RetVoid) {
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<void>());
ASSERT_EQ(func_t::value, 16);
ASSERT_EQ(function::value, 16);
for(auto curr: func.prop()) {
ASSERT_EQ(curr.first, "true"_hs);
@@ -282,8 +282,8 @@ TEST_F(MetaFunc, RetVoid) {
TEST_F(MetaFunc, Static) {
using namespace entt::literals;
auto func = entt::resolve<func_t>().func("h"_hs);
func_t::value = 2;
auto func = entt::resolve<function>().func("h"_hs);
function::value = 2;
ASSERT_TRUE(func);
ASSERT_EQ(func.arity(), 1u);
@@ -294,7 +294,7 @@ TEST_F(MetaFunc, Static) {
ASSERT_FALSE(func.arg(1u));
auto any = func.invoke({}, 3);
auto empty = func.invoke({}, derived_t{});
auto empty = func.invoke({}, derived{});
ASSERT_FALSE(empty);
ASSERT_TRUE(any);
@@ -318,7 +318,7 @@ TEST_F(MetaFunc, Static) {
TEST_F(MetaFunc, StaticRetVoid) {
using namespace entt::literals;
auto func = entt::resolve<func_t>().func("k"_hs);
auto func = entt::resolve<function>().func("k"_hs);
ASSERT_TRUE(func);
ASSERT_EQ(func.arity(), 1u);
@@ -332,7 +332,7 @@ TEST_F(MetaFunc, StaticRetVoid) {
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<void>());
ASSERT_EQ(func_t::value, 3);
ASSERT_EQ(function::value, 3);
for(auto curr: func.prop()) {
ASSERT_EQ(curr.first, "true"_hs);
@@ -351,8 +351,8 @@ TEST_F(MetaFunc, StaticRetVoid) {
TEST_F(MetaFunc, StaticAsMember) {
using namespace entt::literals;
base_t instance{};
auto func = entt::resolve<base_t>().func("fake_member"_hs);
base instance{};
auto func = entt::resolve<base>().func("fake_member"_hs);
auto any = func.invoke(instance, 3);
ASSERT_TRUE(func);
@@ -376,8 +376,8 @@ TEST_F(MetaFunc, StaticAsMember) {
TEST_F(MetaFunc, StaticAsConstMember) {
using namespace entt::literals;
base_t instance{};
auto func = entt::resolve<base_t>().func("fake_const_member"_hs);
base instance{};
auto func = entt::resolve<base>().func("fake_const_member"_hs);
auto any = func.invoke(std::as_const(instance));
ASSERT_TRUE(func);
@@ -424,8 +424,8 @@ TEST_F(MetaFunc, NonClassTypeMember) {
TEST_F(MetaFunc, MetaAnyArgs) {
using namespace entt::literals;
func_t instance;
auto any = entt::resolve<func_t>().func("f1"_hs).invoke(instance, 3);
function instance;
auto any = entt::resolve<function>().func("f1"_hs).invoke(instance, 3);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
@@ -436,15 +436,15 @@ TEST_F(MetaFunc, InvalidArgs) {
using namespace entt::literals;
int value = 3;
ASSERT_FALSE(entt::resolve<func_t>().func("f1"_hs).invoke(value, 'c'));
ASSERT_FALSE(entt::resolve<function>().func("f1"_hs).invoke(value, 'c'));
}
TEST_F(MetaFunc, CastAndConvert) {
using namespace entt::literals;
func_t instance;
function instance;
instance.value = 3;
auto any = entt::resolve<func_t>().func("f3"_hs).invoke(instance, derived_t{}, 0, instance);
auto any = entt::resolve<function>().func("f3"_hs).invoke(instance, derived{}, 0, instance);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
@@ -455,8 +455,8 @@ TEST_F(MetaFunc, CastAndConvert) {
TEST_F(MetaFunc, ArithmeticConversion) {
using namespace entt::literals;
func_t instance;
auto any = entt::resolve<func_t>().func("f2"_hs).invoke(instance, true, 4.2);
function instance;
auto any = entt::resolve<function>().func("f2"_hs).invoke(instance, true, 4.2);
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<int>());
@@ -467,8 +467,8 @@ TEST_F(MetaFunc, ArithmeticConversion) {
TEST_F(MetaFunc, ArgsByRef) {
using namespace entt::literals;
auto func = entt::resolve<func_t>().func("h"_hs);
func_t::value = 2;
auto func = entt::resolve<function>().func("h"_hs);
function::value = 2;
entt::meta_any any{3};
int value = 4;
@@ -481,25 +481,25 @@ TEST_F(MetaFunc, ArgsByRef) {
TEST_F(MetaFunc, ArgsByConstRef) {
using namespace entt::literals;
func_t instance{};
auto func = entt::resolve<func_t>().func("g"_hs);
function instance{};
auto func = entt::resolve<function>().func("g"_hs);
entt::meta_any any{2};
int value = 3;
ASSERT_TRUE(func.invoke(instance, entt::forward_as_meta(std::as_const(value))));
ASSERT_EQ(func_t::value, 9);
ASSERT_EQ(function::value, 9);
ASSERT_TRUE(func.invoke(instance, std::as_const(any).as_ref()));
ASSERT_EQ(func_t::value, 4);
ASSERT_EQ(function::value, 4);
}
TEST_F(MetaFunc, ConstInstance) {
using namespace entt::literals;
func_t instance{};
auto any = entt::resolve<func_t>().func("f1"_hs).invoke(std::as_const(instance), 2);
function instance{};
auto any = entt::resolve<function>().func("f1"_hs).invoke(std::as_const(instance), 2);
ASSERT_FALSE(entt::resolve<func_t>().func("g"_hs).invoke(std::as_const(instance), 1));
ASSERT_FALSE(entt::resolve<function>().func("g"_hs).invoke(std::as_const(instance), 1));
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<int>(), 4);
}
@@ -507,8 +507,8 @@ TEST_F(MetaFunc, ConstInstance) {
TEST_F(MetaFunc, AsVoid) {
using namespace entt::literals;
auto func = entt::resolve<func_t>().func("v"_hs);
func_t instance{};
auto func = entt::resolve<function>().func("v"_hs);
function instance{};
ASSERT_EQ(func.invoke(instance, 1), entt::meta_any{std::in_place_type<void>});
ASSERT_EQ(func.ret(), entt::resolve<void>());
@@ -518,8 +518,8 @@ TEST_F(MetaFunc, AsVoid) {
TEST_F(MetaFunc, AsRef) {
using namespace entt::literals;
func_t instance{};
auto func = entt::resolve<func_t>().func("a"_hs);
function instance{};
auto func = entt::resolve<function>().func("a"_hs);
func.invoke(instance).cast<int &>() = 3;
ASSERT_EQ(func.ret(), entt::resolve<int>());
@@ -529,8 +529,8 @@ TEST_F(MetaFunc, AsRef) {
TEST_F(MetaFunc, AsConstRef) {
using namespace entt::literals;
func_t instance{};
auto func = entt::resolve<func_t>().func("ca"_hs);
function instance{};
auto func = entt::resolve<function>().func("ca"_hs);
ASSERT_EQ(func.ret(), entt::resolve<int>());
ASSERT_EQ(func.invoke(instance).cast<const int &>(), 3);
@@ -540,8 +540,8 @@ TEST_F(MetaFunc, AsConstRef) {
ENTT_DEBUG_TEST_F(MetaFuncDeathTest, AsConstRef) {
using namespace entt::literals;
func_t instance{};
auto func = entt::resolve<func_t>().func("ca"_hs);
function instance{};
auto func = entt::resolve<function>().func("ca"_hs);
ASSERT_DEATH((func.invoke(instance).cast<int &>() = 3), "");
}
@@ -549,8 +549,8 @@ ENTT_DEBUG_TEST_F(MetaFuncDeathTest, AsConstRef) {
TEST_F(MetaFunc, InvokeBaseFunction) {
using namespace entt::literals;
auto type = entt::resolve<derived_t>();
derived_t instance{};
auto type = entt::resolve<derived>();
derived instance{};
ASSERT_TRUE(type.func("setter"_hs));
ASSERT_EQ(instance.value, 3);
@@ -563,8 +563,8 @@ TEST_F(MetaFunc, InvokeBaseFunction) {
TEST_F(MetaFunc, InvokeFromBase) {
using namespace entt::literals;
auto type = entt::resolve<derived_t>();
derived_t instance{};
auto type = entt::resolve<derived>();
derived instance{};
auto setter_from_base = type.func("setter_from_base"_hs);
@@ -593,7 +593,7 @@ TEST_F(MetaFunc, InvokeFromBase) {
TEST_F(MetaFunc, ExternalMemberFunction) {
using namespace entt::literals;
auto func = entt::resolve<func_t>().func("emplace"_hs);
auto func = entt::resolve<function>().func("emplace"_hs);
ASSERT_TRUE(func);
ASSERT_EQ(func.arity(), 2u);
@@ -607,11 +607,11 @@ TEST_F(MetaFunc, ExternalMemberFunction) {
entt::registry registry;
const auto entity = registry.create();
ASSERT_FALSE(registry.all_of<func_t>(entity));
ASSERT_FALSE(registry.all_of<function>(entity));
func.invoke({}, entt::forward_as_meta(registry), entity);
ASSERT_TRUE(registry.all_of<func_t>(entity));
ASSERT_TRUE(registry.all_of<function>(entity));
}
TEST_F(MetaFunc, ReRegistration) {
@@ -619,8 +619,8 @@ TEST_F(MetaFunc, ReRegistration) {
ASSERT_EQ(reset_and_check(), 0u);
func_t instance{};
auto type = entt::resolve<func_t>();
function instance{};
auto type = entt::resolve<function>();
ASSERT_TRUE(type.func("f2"_hs));
ASSERT_FALSE(type.invoke("f2"_hs, instance, 0));
@@ -630,9 +630,9 @@ TEST_F(MetaFunc, ReRegistration) {
ASSERT_TRUE(type.invoke("f1"_hs, instance, 0));
ASSERT_FALSE(type.invoke("f1"_hs, instance, 0, 0));
entt::meta<func_t>()
.func<entt::overload<int(int, int)>(&func_t::f)>("f"_hs)
.func<entt::overload<int(int) const>(&func_t::f)>("f"_hs);
entt::meta<function>()
.func<entt::overload<int(int, int)>(&function::f)>("f"_hs)
.func<entt::overload<int(int) const>(&function::f)>("f"_hs);
ASSERT_TRUE(type.func("f1"_hs));
ASSERT_TRUE(type.func("f2"_hs));

10
test/entt/meta/meta_handle.cpp
View File

@@ -4,7 +4,7 @@
#include <entt/meta/factory.hpp>
#include <entt/meta/meta.hpp>
struct clazz_t {
struct clazz {
void incr() {
++value;
}
@@ -20,10 +20,10 @@ struct MetaHandle: ::testing::Test {
void SetUp() override {
using namespace entt::literals;
entt::meta<clazz_t>()
entt::meta<clazz>()
.type("clazz"_hs)
.func<&clazz_t::incr>("incr"_hs)
.func<&clazz_t::decr>("decr"_hs);
.func<&clazz::incr>("incr"_hs)
.func<&clazz::decr>("decr"_hs);
}
void TearDown() override {
@@ -34,7 +34,7 @@ struct MetaHandle: ::testing::Test {
TEST_F(MetaHandle, Functionalities) {
using namespace entt::literals;
clazz_t instance{};
clazz instance{};
entt::meta_handle handle{};
entt::meta_handle chandle{};

36
test/entt/meta/meta_prop.cpp
View File

@@ -8,34 +8,34 @@
#include <entt/meta/meta.hpp>
#include <entt/meta/resolve.hpp>
struct base_1_t {};
struct base_2_t {};
struct base_3_t {};
struct derived_t: base_1_t, base_2_t, base_3_t {};
struct base_1 {};
struct base_2 {};
struct base_3 {};
struct derived: base_1, base_2, base_3 {};
struct MetaProp: ::testing::Test {
void SetUp() override {
using namespace entt::literals;
entt::meta<base_1_t>()
entt::meta<base_1>()
.type("base_1"_hs)
.prop("int"_hs, 2);
entt::meta<base_2_t>()
entt::meta<base_2>()
.type("base_2"_hs)
.prop("bool"_hs, false)
.prop("char[]"_hs, "char[]");
entt::meta<base_3_t>()
entt::meta<base_3>()
.type("base_3"_hs)
.prop("key_only"_hs)
.prop("key"_hs, 2);
entt::meta<derived_t>()
entt::meta<derived>()
.type("derived"_hs)
.base<base_1_t>()
.base<base_2_t>()
.base<base_3_t>();
.base<base_1>()
.base<base_2>()
.base<base_3>();
}
void TearDown() override {
@@ -46,7 +46,7 @@ struct MetaProp: ::testing::Test {
TEST_F(MetaProp, Functionalities) {
using namespace entt::literals;
auto prop = entt::resolve<base_1_t>().prop("int"_hs);
auto prop = entt::resolve<base_1>().prop("int"_hs);
ASSERT_TRUE(prop);
@@ -71,7 +71,7 @@ TEST_F(MetaProp, Functionalities) {
TEST_F(MetaProp, FromBase) {
using namespace entt::literals;
auto type = entt::resolve<derived_t>();
auto type = entt::resolve<derived>();
auto prop_bool = type.prop("bool"_hs);
auto prop_int = type.prop("int"_hs);
auto key_only = type.prop("key_only"_hs);
@@ -91,7 +91,7 @@ TEST_F(MetaProp, FromBase) {
TEST_F(MetaProp, DeducedArrayType) {
using namespace entt::literals;
auto prop = entt::resolve<base_2_t>().prop("char[]"_hs);
auto prop = entt::resolve<base_2>().prop("char[]"_hs);
ASSERT_TRUE(prop);
ASSERT_EQ(prop.value().type(), entt::resolve<const char *>());
@@ -103,8 +103,8 @@ TEST_F(MetaProp, ReRegistration) {
SetUp();
auto &&node = entt::internal::resolve<base_1_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
auto type = entt::resolve<base_1_t>();
auto &&node = entt::internal::resolve<base_1>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
auto type = entt::resolve<base_1>();
ASSERT_TRUE(node.details);
ASSERT_FALSE(node.details->prop.empty());
@@ -113,8 +113,8 @@ TEST_F(MetaProp, ReRegistration) {
ASSERT_TRUE(type.prop("int"_hs));
ASSERT_EQ(type.prop("int"_hs).value().cast<int>(), 2);
entt::meta<base_1_t>().prop("int"_hs, 0);
entt::meta<base_1_t>().prop("double"_hs, 3.);
entt::meta<base_1>().prop("int"_hs, 0);
entt::meta<base_1>().prop("double"_hs, 3.);
ASSERT_TRUE(node.details);
ASSERT_FALSE(node.details->prop.empty());

332
test/entt/meta/meta_type.cpp
View File

@@ -29,35 +29,35 @@ Type get(Type &prop) {
return prop;
}
struct base_t {
struct base {
char value{'c'};
};
struct derived_t: base_t {
derived_t()
: base_t{} {}
struct derived: base {
derived()
: base{} {}
};
struct abstract_t {
virtual ~abstract_t() = default;
struct abstract {
virtual ~abstract() = default;
virtual void func(int) {}
void base_only(int) {}
};
struct concrete_t: base_t, abstract_t {
struct concrete: base, abstract {
void func(int v) override {
abstract_t::func(v);
abstract::func(v);
value = v;
}
int value{3};
};
struct clazz_t {
clazz_t() = default;
struct clazz {
clazz() = default;
clazz_t(const base_t &, int v)
clazz(const base &, int v)
: value{v} {}
void member() {}
@@ -70,12 +70,12 @@ struct clazz_t {
int value{};
};
struct overloaded_func_t {
struct overloaded_func {
[[nodiscard]] int e(int v) const {
return v + v;
}
[[nodiscard]] int f(const base_t &, int a, int b) {
[[nodiscard]] int f(const base &, int a, int b) {
return f(a, b);
}
@@ -104,7 +104,7 @@ struct overloaded_func_t {
int value{};
};
enum class property_t : entt::id_type {
enum class property_type : entt::id_type {
random,
value,
key_only,
@@ -124,59 +124,59 @@ struct MetaType: ::testing::Test {
.data<0u>("min"_hs)
.data<128u>("max"_hs);
entt::meta<base_t>()
entt::meta<base>()
.type("base"_hs)
.data<&base_t::value>("value"_hs);
.data<&base::value>("value"_hs);
entt::meta<derived_t>()
entt::meta<derived>()
.type("derived"_hs)
.base<base_t>();
.base<base>();
entt::meta<abstract_t>()
entt::meta<abstract>()
.type("abstract"_hs)
.func<&abstract_t::func>("func"_hs)
.func<&abstract_t::base_only>("base_only"_hs);
.func<&abstract::func>("func"_hs)
.func<&abstract::base_only>("base_only"_hs);
entt::meta<concrete_t>()
entt::meta<concrete>()
.type("concrete"_hs)
.base<base_t>()
.base<abstract_t>();
.base<base>()
.base<abstract>();
entt::meta<overloaded_func_t>()
entt::meta<overloaded_func>()
.type("overloaded_func"_hs)
.func<&overloaded_func_t::e>("e"_hs)
.func<entt::overload<int(const base_t &, int, int)>(&overloaded_func_t::f)>("f"_hs)
.func<entt::overload<int(int, int)>(&overloaded_func_t::f)>("f"_hs)
.func<entt::overload<int(int)>(&overloaded_func_t::f)>("f"_hs)
.func<entt::overload<int(int) const>(&overloaded_func_t::f)>("f"_hs)
.func<entt::overload<float(int, float)>(&overloaded_func_t::f)>("f"_hs)
.func<&overloaded_func_t::g>("g"_hs);
.func<&overloaded_func::e>("e"_hs)
.func<entt::overload<int(const base &, int, int)>(&overloaded_func::f)>("f"_hs)
.func<entt::overload<int(int, int)>(&overloaded_func::f)>("f"_hs)
.func<entt::overload<int(int)>(&overloaded_func::f)>("f"_hs)
.func<entt::overload<int(int) const>(&overloaded_func::f)>("f"_hs)
.func<entt::overload<float(int, float)>(&overloaded_func::f)>("f"_hs)
.func<&overloaded_func::g>("g"_hs);
entt::meta<property_t>()
entt::meta<property_type>()
.type("property"_hs)
.data<property_t::random>("random"_hs)
.prop(static_cast<entt::id_type>(property_t::random), 0)
.prop(static_cast<entt::id_type>(property_t::value), 3)
.data<property_t::value>("value"_hs)
.prop(static_cast<entt::id_type>(property_t::random), true)
.prop(static_cast<entt::id_type>(property_t::value), 0)
.prop(static_cast<entt::id_type>(property_t::key_only))
.prop(static_cast<entt::id_type>(property_t::list))
.data<property_t::key_only>("key_only"_hs)
.prop(static_cast<entt::id_type>(property_t::key_only))
.data<property_t::list>("list"_hs)
.prop(static_cast<entt::id_type>(property_t::random), false)
.prop(static_cast<entt::id_type>(property_t::value), 0)
.prop(static_cast<entt::id_type>(property_t::key_only))
.data<set<property_t>, get<property_t>>("var"_hs);
.data<property_type::random>("random"_hs)
.prop(static_cast<entt::id_type>(property_type::random), 0)
.prop(static_cast<entt::id_type>(property_type::value), 3)
.data<property_type::value>("value"_hs)
.prop(static_cast<entt::id_type>(property_type::random), true)
.prop(static_cast<entt::id_type>(property_type::value), 0)
.prop(static_cast<entt::id_type>(property_type::key_only))
.prop(static_cast<entt::id_type>(property_type::list))
.data<property_type::key_only>("key_only"_hs)
.prop(static_cast<entt::id_type>(property_type::key_only))
.data<property_type::list>("list"_hs)
.prop(static_cast<entt::id_type>(property_type::random), false)
.prop(static_cast<entt::id_type>(property_type::value), 0)
.prop(static_cast<entt::id_type>(property_type::key_only))
.data<set<property_type>, get<property_type>>("var"_hs);
entt::meta<clazz_t>()
entt::meta<clazz>()
.type("clazz"_hs)
.prop(static_cast<entt::id_type>(property_t::value), 3)
.ctor<const base_t &, int>()
.data<&clazz_t::value>("value"_hs)
.func<&clazz_t::member>("member"_hs)
.func<clazz_t::func>("func"_hs)
.prop(static_cast<entt::id_type>(property_type::value), 3)
.ctor<const base &, int>()
.data<&clazz::value>("value"_hs)
.func<&clazz::member>("member"_hs)
.func<clazz::func>("func"_hs)
.conv<int>();
}
@@ -199,7 +199,7 @@ TEST_F(MetaType, Resolve) {
const auto it = std::find_if(range.begin(), range.end(), [](auto curr) { return curr.second.id() == entt::hashed_string::value("clazz"); });
ASSERT_NE(it, range.end());
ASSERT_EQ(it->second, entt::resolve<clazz_t>());
ASSERT_EQ(it->second, entt::resolve<clazz>());
bool found = false;
@@ -213,22 +213,22 @@ TEST_F(MetaType, Resolve) {
TEST_F(MetaType, Functionalities) {
using namespace entt::literals;
auto type = entt::resolve<clazz_t>();
auto type = entt::resolve<clazz>();
ASSERT_TRUE(type);
ASSERT_NE(type, entt::meta_type{});
ASSERT_EQ(type.id(), "clazz"_hs);
ASSERT_EQ(type.info(), entt::type_id<clazz_t>());
ASSERT_EQ(type.info(), entt::type_id<clazz>());
for(auto &&curr: type.prop()) {
ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_t::value));
ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_type::value));
ASSERT_EQ(curr.second.value(), 3);
}
ASSERT_FALSE(type.prop(static_cast<entt::id_type>(property_t::key_only)));
ASSERT_FALSE(type.prop(static_cast<entt::id_type>(property_type::key_only)));
ASSERT_FALSE(type.prop("property"_hs));
auto prop = type.prop(static_cast<entt::id_type>(property_t::value));
auto prop = type.prop(static_cast<entt::id_type>(property_type::value));
ASSERT_TRUE(prop);
ASSERT_EQ(prop.value(), 3);
@@ -246,15 +246,15 @@ TEST_F(MetaType, SizeOf) {
TEST_F(MetaType, Traits) {
ASSERT_TRUE(entt::resolve<bool>().is_arithmetic());
ASSERT_TRUE(entt::resolve<double>().is_arithmetic());
ASSERT_FALSE(entt::resolve<clazz_t>().is_arithmetic());
ASSERT_FALSE(entt::resolve<clazz>().is_arithmetic());
ASSERT_TRUE(entt::resolve<int>().is_integral());
ASSERT_FALSE(entt::resolve<double>().is_integral());
ASSERT_FALSE(entt::resolve<clazz_t>().is_integral());
ASSERT_FALSE(entt::resolve<clazz>().is_integral());
ASSERT_TRUE(entt::resolve<long>().is_signed());
ASSERT_FALSE(entt::resolve<unsigned int>().is_signed());
ASSERT_FALSE(entt::resolve<clazz_t>().is_signed());
ASSERT_FALSE(entt::resolve<clazz>().is_signed());
// NOLINTBEGIN(*-avoid-c-arrays)
ASSERT_TRUE(entt::resolve<int[5]>().is_array());
@@ -262,10 +262,10 @@ TEST_F(MetaType, Traits) {
// NOLINTEND(*-avoid-c-arrays)
ASSERT_FALSE(entt::resolve<int>().is_array());
ASSERT_TRUE(entt::resolve<property_t>().is_enum());
ASSERT_TRUE(entt::resolve<property_type>().is_enum());
ASSERT_FALSE(entt::resolve<char>().is_enum());
ASSERT_TRUE(entt::resolve<derived_t>().is_class());
ASSERT_TRUE(entt::resolve<derived>().is_class());
ASSERT_FALSE(entt::resolve<double>().is_class());
ASSERT_TRUE(entt::resolve<int *>().is_pointer());
@@ -288,7 +288,7 @@ TEST_F(MetaType, RemovePointer) {
ASSERT_EQ(entt::resolve<void *>().remove_pointer(), entt::resolve<void>());
ASSERT_EQ(entt::resolve<char **>().remove_pointer(), entt::resolve<char *>());
ASSERT_EQ(entt::resolve<int (*)(char, double)>().remove_pointer(), entt::resolve<int(char, double)>());
ASSERT_EQ(entt::resolve<derived_t>().remove_pointer(), entt::resolve<derived_t>());
ASSERT_EQ(entt::resolve<derived>().remove_pointer(), entt::resolve<derived>());
}
TEST_F(MetaType, TemplateInfo) {
@@ -305,61 +305,61 @@ TEST_F(MetaType, TemplateInfo) {
}
TEST_F(MetaType, CanCast) {
auto type = entt::resolve<derived_t>();
auto type = entt::resolve<derived>();
ASSERT_FALSE(type.can_cast(entt::resolve<void>()));
ASSERT_TRUE(type.can_cast(entt::resolve<base_t>()));
ASSERT_TRUE(type.can_cast(entt::resolve<derived_t>()));
ASSERT_TRUE(type.can_cast(entt::resolve<base>()));
ASSERT_TRUE(type.can_cast(entt::resolve<derived>()));
}
TEST_F(MetaType, CanConvert) {
auto clazz = entt::resolve<clazz_t>();
auto derived = entt::resolve<derived_t>();
auto instance = entt::resolve<clazz>();
auto other = entt::resolve<derived>();
auto arithmetic = entt::resolve<int>();
ASSERT_TRUE(clazz.can_convert(entt::resolve<clazz_t>()));
ASSERT_TRUE(clazz.can_convert(entt::resolve<int>()));
ASSERT_TRUE(instance.can_convert(entt::resolve<clazz>()));
ASSERT_TRUE(instance.can_convert(entt::resolve<int>()));
ASSERT_TRUE(derived.can_convert(entt::resolve<derived_t>()));
ASSERT_TRUE(derived.can_convert(entt::resolve<base_t>()));
ASSERT_FALSE(derived.can_convert(entt::resolve<int>()));
ASSERT_TRUE(other.can_convert(entt::resolve<derived>()));
ASSERT_TRUE(other.can_convert(entt::resolve<base>()));
ASSERT_FALSE(other.can_convert(entt::resolve<int>()));
ASSERT_TRUE(arithmetic.can_convert(entt::resolve<int>()));
ASSERT_FALSE(arithmetic.can_convert(entt::resolve<clazz_t>()));
ASSERT_FALSE(arithmetic.can_convert(entt::resolve<clazz>()));
ASSERT_TRUE(arithmetic.can_convert(entt::resolve<double>()));
ASSERT_TRUE(arithmetic.can_convert(entt::resolve<float>()));
}
TEST_F(MetaType, Base) {
auto type = entt::resolve<derived_t>();
auto type = entt::resolve<derived>();
ASSERT_NE(type.base().cbegin(), type.base().cend());
for(auto curr: type.base()) {
ASSERT_EQ(curr.first, entt::type_id<base_t>().hash());
ASSERT_EQ(curr.second, entt::resolve<base_t>());
ASSERT_EQ(curr.first, entt::type_id<base>().hash());
ASSERT_EQ(curr.second, entt::resolve<base>());
}
}
TEST_F(MetaType, Ctor) {
derived_t derived;
base_t &base = derived;
auto type = entt::resolve<clazz_t>();
derived instance;
base &as_base = instance;
auto type = entt::resolve<clazz>();
ASSERT_TRUE((type.construct(entt::forward_as_meta(derived), 3)));
ASSERT_TRUE((type.construct(entt::forward_as_meta(base), 3)));
ASSERT_TRUE((type.construct(entt::forward_as_meta(instance), 3)));
ASSERT_TRUE((type.construct(entt::forward_as_meta(as_base), 3)));
// use the implicitly generated default constructor
auto any = type.construct();
ASSERT_TRUE(any);
ASSERT_EQ(any.type(), entt::resolve<clazz_t>());
ASSERT_EQ(any.type(), entt::resolve<clazz>());
}
TEST_F(MetaType, Data) {
using namespace entt::literals;
auto type = entt::resolve<clazz_t>();
auto type = entt::resolve<clazz>();
int counter{};
for([[maybe_unused]] auto &&curr: type.data()) {
@@ -378,8 +378,8 @@ TEST_F(MetaType, Data) {
TEST_F(MetaType, Func) {
using namespace entt::literals;
auto type = entt::resolve<clazz_t>();
clazz_t instance{};
auto type = entt::resolve<clazz>();
clazz instance{};
int counter{};
for([[maybe_unused]] auto &&curr: type.func()) {
@@ -401,8 +401,8 @@ TEST_F(MetaType, Func) {
TEST_F(MetaType, Invoke) {
using namespace entt::literals;
auto type = entt::resolve<clazz_t>();
clazz_t instance{};
auto type = entt::resolve<clazz>();
clazz instance{};
ASSERT_TRUE(type.invoke("member"_hs, instance));
ASSERT_FALSE(type.invoke("rebmem"_hs, instance));
@@ -414,8 +414,8 @@ TEST_F(MetaType, Invoke) {
TEST_F(MetaType, InvokeFromBase) {
using namespace entt::literals;
auto type = entt::resolve<concrete_t>();
concrete_t instance{};
auto type = entt::resolve<concrete>();
concrete instance{};
ASSERT_TRUE(type.invoke("base_only"_hs, instance, 3));
ASSERT_FALSE(type.invoke("ylno_esab"_hs, {}, 'c'));
@@ -424,15 +424,15 @@ TEST_F(MetaType, InvokeFromBase) {
TEST_F(MetaType, OverloadedFunc) {
using namespace entt::literals;
const auto type = entt::resolve<overloaded_func_t>();
overloaded_func_t instance{};
const auto type = entt::resolve<overloaded_func>();
overloaded_func instance{};
entt::meta_any res{};
ASSERT_TRUE(type.func("f"_hs));
ASSERT_TRUE(type.func("e"_hs));
ASSERT_TRUE(type.func("g"_hs));
res = type.invoke("f"_hs, instance, base_t{}, 1, 2);
res = type.invoke("f"_hs, instance, base{}, 1, 2);
ASSERT_TRUE(res);
ASSERT_EQ(instance.value, 1);
@@ -479,46 +479,46 @@ TEST_F(MetaType, OverloadedFunc) {
}
TEST_F(MetaType, Construct) {
auto any = entt::resolve<clazz_t>().construct(base_t{}, 2);
auto any = entt::resolve<clazz>().construct(base{}, 2);
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().value, 2);
ASSERT_EQ(any.cast<clazz>().value, 2);
}
TEST_F(MetaType, ConstructNoArgs) {
// this should work, no other tests required
auto any = entt::resolve<clazz_t>().construct();
auto any = entt::resolve<clazz>().construct();
ASSERT_TRUE(any);
}
TEST_F(MetaType, ConstructMetaAnyArgs) {
auto any = entt::resolve<clazz_t>().construct(entt::meta_any{base_t{}}, entt::meta_any{3});
auto any = entt::resolve<clazz>().construct(entt::meta_any{base{}}, entt::meta_any{3});
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().value, 3);
ASSERT_EQ(any.cast<clazz>().value, 3);
}
TEST_F(MetaType, ConstructInvalidArgs) {
ASSERT_FALSE(entt::resolve<clazz_t>().construct('c', base_t{}));
ASSERT_FALSE(entt::resolve<clazz>().construct('c', base{}));
}
TEST_F(MetaType, LessArgs) {
ASSERT_FALSE(entt::resolve<clazz_t>().construct(base_t{}));
ASSERT_FALSE(entt::resolve<clazz>().construct(base{}));
}
TEST_F(MetaType, ConstructCastAndConvert) {
auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{derived_t{}, 3});
auto any = entt::resolve<clazz>().construct(derived{}, clazz{derived{}, 3});
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().value, 3);
ASSERT_EQ(any.cast<clazz>().value, 3);
}
TEST_F(MetaType, ConstructArithmeticConversion) {
auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{derived_t{}, true});
auto any = entt::resolve<clazz>().construct(derived{}, clazz{derived{}, true});
ASSERT_TRUE(any);
ASSERT_EQ(any.cast<clazz_t>().value, 1);
ASSERT_EQ(any.cast<clazz>().value, 1);
}
TEST_F(MetaType, FromVoid) {
@@ -554,24 +554,24 @@ TEST_F(MetaType, Reset) {
using namespace entt::literals;
ASSERT_TRUE(entt::resolve("clazz"_hs));
ASSERT_EQ(entt::resolve<clazz_t>().id(), "clazz"_hs);
ASSERT_TRUE(entt::resolve<clazz_t>().prop(static_cast<entt::id_type>(property_t::value)));
ASSERT_TRUE(entt::resolve<clazz_t>().data("value"_hs));
ASSERT_TRUE((entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{})));
ASSERT_EQ(entt::resolve<clazz>().id(), "clazz"_hs);
ASSERT_TRUE(entt::resolve<clazz>().prop(static_cast<entt::id_type>(property_type::value)));
ASSERT_TRUE(entt::resolve<clazz>().data("value"_hs));
ASSERT_TRUE((entt::resolve<clazz>().construct(derived{}, clazz{})));
// implicitly generated default constructor
ASSERT_TRUE(entt::resolve<clazz_t>().construct());
ASSERT_TRUE(entt::resolve<clazz>().construct());
entt::meta_reset("clazz"_hs);
ASSERT_FALSE(entt::resolve("clazz"_hs));
ASSERT_NE(entt::resolve<clazz_t>().id(), "clazz"_hs);
ASSERT_FALSE(entt::resolve<clazz_t>().prop(static_cast<entt::id_type>(property_t::value)));
ASSERT_FALSE(entt::resolve<clazz_t>().data("value"_hs));
ASSERT_FALSE((entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{})));
ASSERT_NE(entt::resolve<clazz>().id(), "clazz"_hs);
ASSERT_FALSE(entt::resolve<clazz>().prop(static_cast<entt::id_type>(property_type::value)));
ASSERT_FALSE(entt::resolve<clazz>().data("value"_hs));
ASSERT_FALSE((entt::resolve<clazz>().construct(derived{}, clazz{})));
// implicitly generated default constructor is not cleared
ASSERT_TRUE(entt::resolve<clazz_t>().construct());
ASSERT_TRUE(entt::resolve<clazz>().construct());
entt::meta<clazz_t>().type("clazz"_hs);
entt::meta<clazz>().type("clazz"_hs);
ASSERT_TRUE(entt::resolve("clazz"_hs));
}
@@ -607,23 +607,23 @@ TEST_F(MetaType, ResetAll) {
TEST_F(MetaType, AbstractClass) {
using namespace entt::literals;
auto type = entt::resolve<abstract_t>();
concrete_t instance;
auto type = entt::resolve<abstract>();
concrete instance;
ASSERT_EQ(type.info(), entt::type_id<abstract_t>());
ASSERT_EQ(instance.base_t::value, 'c');
ASSERT_EQ(type.info(), entt::type_id<abstract>());
ASSERT_EQ(instance.base::value, 'c');
ASSERT_EQ(instance.value, 3);
type.func("func"_hs).invoke(instance, 2);
ASSERT_EQ(instance.base_t::value, 'c');
ASSERT_EQ(instance.base::value, 'c');
ASSERT_EQ(instance.value, 2);
}
TEST_F(MetaType, EnumAndNamedConstants) {
using namespace entt::literals;
auto type = entt::resolve<property_t>();
auto type = entt::resolve<property_type>();
ASSERT_TRUE(type.data("random"_hs));
ASSERT_TRUE(type.data("value"_hs));
@@ -631,11 +631,11 @@ TEST_F(MetaType, EnumAndNamedConstants) {
ASSERT_EQ(type.data("random"_hs).type(), type);
ASSERT_EQ(type.data("value"_hs).type(), type);
ASSERT_FALSE(type.data("random"_hs).set({}, property_t::value));
ASSERT_FALSE(type.data("value"_hs).set({}, property_t::random));
ASSERT_FALSE(type.data("random"_hs).set({}, property_type::value));
ASSERT_FALSE(type.data("value"_hs).set({}, property_type::random));
ASSERT_EQ(type.data("random"_hs).get({}).cast<property_t>(), property_t::random);
ASSERT_EQ(type.data("value"_hs).get({}).cast<property_t>(), property_t::value);
ASSERT_EQ(type.data("random"_hs).get({}).cast<property_type>(), property_type::random);
ASSERT_EQ(type.data("value"_hs).get({}).cast<property_type>(), property_type::value);
}
TEST_F(MetaType, ArithmeticTypeAndNamedConstants) {
@@ -659,43 +659,43 @@ TEST_F(MetaType, ArithmeticTypeAndNamedConstants) {
TEST_F(MetaType, Variables) {
using namespace entt::literals;
auto p_data = entt::resolve<property_t>().data("var"_hs);
auto p_data = entt::resolve<property_type>().data("var"_hs);
auto d_data = entt::resolve("double"_hs).data("var"_hs);
property_t prop{property_t::key_only};
property_type prop{property_type::key_only};
double d = 3.;
p_data.set(prop, property_t::random);
p_data.set(prop, property_type::random);
d_data.set(d, 3.);
ASSERT_EQ(p_data.get(prop).cast<property_t>(), property_t::random);
ASSERT_EQ(p_data.get(prop).cast<property_type>(), property_type::random);
ASSERT_EQ(d_data.get(d).cast<double>(), 3.);
ASSERT_EQ(prop, property_t::random);
ASSERT_EQ(prop, property_type::random);
ASSERT_EQ(d, 3.);
}
TEST_F(MetaType, PropertiesAndCornerCases) {
using namespace entt::literals;
auto type = entt::resolve<property_t>();
auto type = entt::resolve<property_type>();
ASSERT_EQ(type.prop().cbegin(), type.prop().cend());
ASSERT_EQ(type.data("random"_hs).prop(static_cast<entt::id_type>(property_t::random)).value().cast<int>(), 0);
ASSERT_EQ(type.data("random"_hs).prop(static_cast<entt::id_type>(property_t::value)).value().cast<int>(), 3);
ASSERT_EQ(type.data("random"_hs).prop(static_cast<entt::id_type>(property_type::random)).value().cast<int>(), 0);
ASSERT_EQ(type.data("random"_hs).prop(static_cast<entt::id_type>(property_type::value)).value().cast<int>(), 3);
ASSERT_EQ(type.data("value"_hs).prop(static_cast<entt::id_type>(property_t::random)).value().cast<bool>(), true);
ASSERT_EQ(type.data("value"_hs).prop(static_cast<entt::id_type>(property_t::value)).value().cast<int>(), 0);
ASSERT_TRUE(type.data("value"_hs).prop(static_cast<entt::id_type>(property_t::key_only)));
ASSERT_FALSE(type.data("value"_hs).prop(static_cast<entt::id_type>(property_t::key_only)).value());
ASSERT_EQ(type.data("value"_hs).prop(static_cast<entt::id_type>(property_type::random)).value().cast<bool>(), true);
ASSERT_EQ(type.data("value"_hs).prop(static_cast<entt::id_type>(property_type::value)).value().cast<int>(), 0);
ASSERT_TRUE(type.data("value"_hs).prop(static_cast<entt::id_type>(property_type::key_only)));
ASSERT_FALSE(type.data("value"_hs).prop(static_cast<entt::id_type>(property_type::key_only)).value());
ASSERT_TRUE(type.data("key_only"_hs).prop(static_cast<entt::id_type>(property_t::key_only)));
ASSERT_FALSE(type.data("key_only"_hs).prop(static_cast<entt::id_type>(property_t::key_only)).value());
ASSERT_TRUE(type.data("key_only"_hs).prop(static_cast<entt::id_type>(property_type::key_only)));
ASSERT_FALSE(type.data("key_only"_hs).prop(static_cast<entt::id_type>(property_type::key_only)).value());
ASSERT_EQ(type.data("list"_hs).prop(static_cast<entt::id_type>(property_t::random)).value().cast<bool>(), false);
ASSERT_EQ(type.data("list"_hs).prop(static_cast<entt::id_type>(property_t::value)).value().cast<int>(), 0);
ASSERT_TRUE(type.data("list"_hs).prop(static_cast<entt::id_type>(property_t::key_only)));
ASSERT_FALSE(type.data("list"_hs).prop(static_cast<entt::id_type>(property_t::key_only)).value());
ASSERT_EQ(type.data("list"_hs).prop(static_cast<entt::id_type>(property_type::random)).value().cast<bool>(), false);
ASSERT_EQ(type.data("list"_hs).prop(static_cast<entt::id_type>(property_type::value)).value().cast<int>(), 0);
ASSERT_TRUE(type.data("list"_hs).prop(static_cast<entt::id_type>(property_type::key_only)));
ASSERT_FALSE(type.data("list"_hs).prop(static_cast<entt::id_type>(property_type::key_only)).value());
type = entt::resolve<void>();
@@ -709,13 +709,13 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
entt::meta_reset<double>();
entt::meta_reset<unsigned int>();
entt::meta_reset<base_t>();
entt::meta_reset<derived_t>();
entt::meta_reset<abstract_t>();
entt::meta_reset<concrete_t>();
entt::meta_reset<overloaded_func_t>();
entt::meta_reset<property_t>();
entt::meta_reset<clazz_t>();
entt::meta_reset<base>();
entt::meta_reset<derived>();
entt::meta_reset<abstract>();
entt::meta_reset<concrete>();
entt::meta_reset<overloaded_func>();
entt::meta_reset<property_type>();
entt::meta_reset<clazz>();
ASSERT_FALSE(entt::resolve("double"_hs));
ASSERT_FALSE(entt::resolve("base"_hs));
@@ -724,11 +724,11 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
ASSERT_TRUE(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()).value.empty());
ASSERT_FALSE(entt::resolve<clazz_t>().prop(static_cast<entt::id_type>(property_t::value)));
ASSERT_FALSE(entt::resolve<clazz>().prop(static_cast<entt::id_type>(property_type::value)));
// implicitly generated default constructor is not cleared
ASSERT_TRUE(entt::resolve<clazz_t>().construct());
ASSERT_FALSE(entt::resolve<clazz_t>().data("value"_hs));
ASSERT_FALSE(entt::resolve<clazz_t>().func("member"_hs));
ASSERT_TRUE(entt::resolve<clazz>().construct());
ASSERT_FALSE(entt::resolve<clazz>().data("value"_hs));
ASSERT_FALSE(entt::resolve<clazz>().func("member"_hs));
entt::meta<double>().type("double"_hs);
entt::meta_any any{3.};
@@ -740,14 +740,14 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
ASSERT_FALSE(entt::resolve("derived"_hs));
ASSERT_TRUE(entt::resolve("double"_hs));
entt::meta<property_t>()
entt::meta<property_type>()
.type("property"_hs)
.data<property_t::random>("rand"_hs)
.prop(static_cast<entt::id_type>(property_t::value), 3)
.prop(static_cast<entt::id_type>(property_t::random), 3);
.data<property_type::random>("rand"_hs)
.prop(static_cast<entt::id_type>(property_type::value), 3)
.prop(static_cast<entt::id_type>(property_type::random), 3);
ASSERT_TRUE(entt::resolve<property_t>().data("rand"_hs).prop(static_cast<entt::id_type>(property_t::value)));
ASSERT_TRUE(entt::resolve<property_t>().data("rand"_hs).prop(static_cast<entt::id_type>(property_t::random)));
ASSERT_TRUE(entt::resolve<property_type>().data("rand"_hs).prop(static_cast<entt::id_type>(property_type::value)));
ASSERT_TRUE(entt::resolve<property_type>().data("rand"_hs).prop(static_cast<entt::id_type>(property_type::random)));
}
TEST_F(MetaType, ReRegistration) {
@@ -778,10 +778,10 @@ TEST_F(MetaType, ReRegistration) {
TEST_F(MetaType, NameCollision) {
using namespace entt::literals;
ASSERT_NO_THROW(entt::meta<clazz_t>().type("clazz"_hs));
ASSERT_NO_THROW(entt::meta<clazz>().type("clazz"_hs));
ASSERT_TRUE(entt::resolve("clazz"_hs));
ASSERT_NO_THROW(entt::meta<clazz_t>().type("quux"_hs));
ASSERT_NO_THROW(entt::meta<clazz>().type("quux"_hs));
ASSERT_FALSE(entt::resolve("clazz"_hs));
ASSERT_TRUE(entt::resolve("quux"_hs));
}
@@ -789,5 +789,5 @@ TEST_F(MetaType, NameCollision) {
ENTT_DEBUG_TEST_F(MetaTypeDeathTest, NameCollision) {
using namespace entt::literals;
ASSERT_DEATH(entt::meta<clazz_t>().type("abstract"_hs), "");
ASSERT_DEATH(entt::meta<clazz>().type("abstract"_hs), "");
}