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

test: prepare for new meta container tests

Browse Source
This commit is contained in:
Michele Caini
2023-10-05 10:38:03 +02:00
parent 25e844fadd
commit 06e032bc6d
1 changed files with 319 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

638
test/entt/meta/meta_container.cpp
View File

@@ -13,9 +13,9 @@
#include <entt/meta/resolve.hpp>
#include "../common/config.h"
struct invalid_type {};
struct invalid {};
TEST(MetaContainer, InvalidContainer) {
TEST(MetaContainer, Invalid) {
ASSERT_FALSE(entt::meta_any{42}.as_sequence_container());
ASSERT_FALSE(entt::meta_any{42}.as_associative_container());
@@ -23,7 +23,7 @@ TEST(MetaContainer, InvalidContainer) {
ASSERT_FALSE(entt::meta_any{std::vector<int>{}}.as_associative_container());
}
TEST(MetaContainer, EmptySequenceContainer) {
TEST(SequenceContainer, Empty) {
entt::meta_sequence_container container{};
ASSERT_FALSE(container);
@@ -34,18 +34,7 @@ TEST(MetaContainer, EmptySequenceContainer) {
ASSERT_TRUE(container);
}
TEST(MetaContainer, EmptyAssociativeContainer) {
entt::meta_associative_container container{};
ASSERT_FALSE(container);
entt::meta_any any{std::map<int, char>{}};
container = any.as_associative_container();
ASSERT_TRUE(container);
}
TEST(MetaContainer, SequenceContainerIterator) {
TEST(SequenceContainer, Iterator) {
std::vector<int> vec{2, 3, 4};
auto any = entt::forward_as_meta(vec);
entt::meta_sequence_container::iterator first{};
@@ -74,34 +63,7 @@ TEST(MetaContainer, SequenceContainerIterator) {
ASSERT_EQ((--first)->cast<int>(), 2);
}
TEST(MetaContainer, AssociativeContainerIterator) {
std::map<int, char> map{{2, 'c'}, {3, 'd'}, {4, 'e'}};
auto any = entt::forward_as_meta(map);
entt::meta_associative_container::iterator first{};
auto view = any.as_associative_container();
ASSERT_FALSE(first);
first = view.begin();
const auto last = view.end();
ASSERT_TRUE(first);
ASSERT_TRUE(last);
ASSERT_FALSE(first == last);
ASSERT_TRUE(first != last);
ASSERT_NE(first, last);
ASSERT_EQ((first++)->first.cast<int>(), 2);
ASSERT_EQ((++first)->second.cast<char>(), 'e');
ASSERT_NE(first++, last);
ASSERT_EQ(first, last);
ASSERT_TRUE(first == last);
ASSERT_FALSE(first != last);
}
TEST(MetaContainer, StdVector) {
TEST(SequenceContainer, StdVector) {
std::vector<int> vec{};
auto any = entt::forward_as_meta(vec);
auto view = any.as_sequence_container();
@@ -126,7 +88,7 @@ TEST(MetaContainer, StdVector) {
auto ret = view.insert(it, 0);
ASSERT_TRUE(ret);
ASSERT_FALSE(view.insert(ret, invalid_type{}));
ASSERT_FALSE(view.insert(ret, invalid{}));
ASSERT_TRUE(view.insert(++ret, 1.));
ASSERT_EQ(view.size(), 5u);
@@ -156,7 +118,56 @@ TEST(MetaContainer, StdVector) {
ASSERT_EQ(view.size(), 0u);
}
TEST(MetaContainer, StdArray) {
TEST(SequenceContainer, StdVectorBool) {
using proxy_type = typename std::vector<bool>::reference;
using const_proxy_type = typename std::vector<bool>::const_reference;
std::vector<bool> vec{};
auto any = entt::forward_as_meta(vec);
auto cany = std::as_const(any).as_ref();
auto view = any.as_sequence_container();
auto cview = cany.as_sequence_container();
ASSERT_TRUE(view);
ASSERT_EQ(view.value_type(), entt::resolve<bool>());
ASSERT_EQ(view.size(), 0u);
ASSERT_EQ(view.begin(), view.end());
ASSERT_TRUE(view.resize(3u));
ASSERT_EQ(view.size(), 3u);
ASSERT_NE(view.begin(), view.end());
view[0].cast<proxy_type>() = true;
view[1].cast<proxy_type>() = true;
view[2].cast<proxy_type>() = false;
ASSERT_EQ(cview[1u].cast<const_proxy_type>(), true);
auto it = view.begin();
auto ret = view.insert(it, true);
ASSERT_TRUE(ret);
ASSERT_FALSE(view.insert(ret, invalid{}));
ASSERT_TRUE(view.insert(++ret, false));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.begin()->cast<proxy_type>(), true);
ASSERT_EQ((++cview.begin())->cast<const_proxy_type>(), false);
it = view.begin();
ret = view.erase(it);
ASSERT_TRUE(ret);
ASSERT_EQ(view.size(), 4u);
ASSERT_EQ(ret->cast<proxy_type>(), false);
ASSERT_TRUE(view.clear());
ASSERT_TRUE(view.reserve(42u));
ASSERT_EQ(cview.size(), 0u);
}
TEST(SequenceContainer, StdArray) {
std::array<int, 3> arr{};
auto any = entt::forward_as_meta(arr);
auto view = any.as_sequence_container();
@@ -198,7 +209,7 @@ TEST(MetaContainer, StdArray) {
ASSERT_EQ(view.size(), 3u);
}
TEST(MetaContainer, StdList) {
TEST(SequenceContainer, StdList) {
std::list<int> list{};
auto any = entt::forward_as_meta(list);
auto view = any.as_sequence_container();
@@ -223,7 +234,7 @@ TEST(MetaContainer, StdList) {
auto ret = view.insert(it, 0);
ASSERT_TRUE(ret);
ASSERT_FALSE(view.insert(ret, invalid_type{}));
ASSERT_FALSE(view.insert(ret, invalid{}));
ASSERT_TRUE(view.insert(++ret, 1.));
ASSERT_EQ(view.size(), 5u);
@@ -253,7 +264,7 @@ TEST(MetaContainer, StdList) {
ASSERT_EQ(view.size(), 0u);
}
TEST(MetaContainer, StdDeque) {
TEST(SequenceContainer, StdDeque) {
std::deque<int> deque{};
auto any = entt::forward_as_meta(deque);
auto view = any.as_sequence_container();
@@ -278,7 +289,7 @@ TEST(MetaContainer, StdDeque) {
auto ret = view.insert(it, 0);
ASSERT_TRUE(ret);
ASSERT_FALSE(view.insert(ret, invalid_type{}));
ASSERT_FALSE(view.insert(ret, invalid{}));
ASSERT_TRUE(view.insert(++ret, 1.));
ASSERT_EQ(view.size(), 5u);
@@ -308,189 +319,7 @@ TEST(MetaContainer, StdDeque) {
ASSERT_EQ(view.size(), 0u);
}
TEST(MetaContainer, StdMap) {
std::map<int, char> map{{2, 'c'}, {3, 'd'}, {4, 'e'}};
auto any = entt::forward_as_meta(map);
auto view = any.as_associative_container();
ASSERT_TRUE(view);
ASSERT_FALSE(view.key_only());
ASSERT_EQ(view.key_type(), entt::resolve<int>());
ASSERT_EQ(view.mapped_type(), entt::resolve<char>());
ASSERT_EQ(view.value_type(), (entt::resolve<std::pair<const int, char>>()));
ASSERT_EQ(view.size(), 3u);
ASSERT_NE(view.begin(), view.end());
ASSERT_EQ(view.find(3)->second.cast<char>(), 'd');
ASSERT_FALSE(view.insert(invalid_type{}, 'a'));
ASSERT_FALSE(view.insert(1, invalid_type{}));
ASSERT_TRUE(view.insert(0, 'a'));
ASSERT_TRUE(view.insert(1., static_cast<int>('b')));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.find(0)->second.cast<char>(), 'a');
ASSERT_EQ(view.find(1.)->second.cast<char>(), 'b');
ASSERT_EQ(view.erase(invalid_type{}), 0u);
ASSERT_FALSE(view.find(invalid_type{}));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.erase(0), 1u);
ASSERT_EQ(view.size(), 4u);
ASSERT_EQ(view.find(0), view.end());
view.find(1.)->second.cast<char &>() = 'f';
ASSERT_EQ(view.find(1.f)->second.cast<char>(), 'f');
ASSERT_EQ(view.erase(1.), 1u);
ASSERT_TRUE(view.clear());
ASSERT_FALSE(view.reserve(42u));
ASSERT_EQ(view.size(), 0u);
}
TEST(MetaContainer, StdSet) {
std::set<int> set{2, 3, 4};
auto any = entt::forward_as_meta(set);
auto view = any.as_associative_container();
ASSERT_TRUE(view);
ASSERT_TRUE(view.key_only());
ASSERT_EQ(view.key_type(), entt::resolve<int>());
ASSERT_EQ(view.mapped_type(), entt::meta_type{});
ASSERT_EQ(view.value_type(), entt::resolve<int>());
ASSERT_EQ(view.size(), 3u);
ASSERT_NE(view.begin(), view.end());
ASSERT_EQ(view.find(3)->first.cast<int>(), 3);
ASSERT_FALSE(view.insert(invalid_type{}));
ASSERT_TRUE(view.insert(.0));
ASSERT_TRUE(view.insert(1));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.find(0)->first.cast<int>(), 0);
ASSERT_EQ(view.find(1.)->first.cast<int>(), 1);
ASSERT_EQ(view.erase(invalid_type{}), 0u);
ASSERT_FALSE(view.find(invalid_type{}));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.erase(0), 1u);
ASSERT_EQ(view.size(), 4u);
ASSERT_EQ(view.find(0), view.end());
ASSERT_EQ(view.find(1.f)->first.try_cast<int>(), nullptr);
ASSERT_NE(view.find(1.)->first.try_cast<const int>(), nullptr);
ASSERT_EQ(view.find(true)->first.cast<const int &>(), 1);
ASSERT_EQ(view.erase(1.), 1u);
ASSERT_TRUE(view.clear());
ASSERT_FALSE(view.reserve(42u));
ASSERT_EQ(view.size(), 0u);
}
TEST(MetaContainer, DenseMap) {
entt::dense_map<int, char> map{};
auto any = entt::forward_as_meta(map);
auto view = any.as_associative_container();
map.emplace(2, 'c');
map.emplace(3, 'd');
map.emplace(4, '3');
ASSERT_TRUE(view);
ASSERT_FALSE(view.key_only());
ASSERT_EQ(view.key_type(), entt::resolve<int>());
ASSERT_EQ(view.mapped_type(), entt::resolve<char>());
ASSERT_EQ(view.value_type(), (entt::resolve<std::pair<const int, char>>()));
ASSERT_EQ(view.size(), 3u);
ASSERT_NE(view.begin(), view.end());
ASSERT_EQ(view.find(3)->second.cast<char>(), 'd');
ASSERT_FALSE(view.insert(invalid_type{}, 'a'));
ASSERT_FALSE(view.insert(1, invalid_type{}));
ASSERT_TRUE(view.insert(0, 'a'));
ASSERT_TRUE(view.insert(1., static_cast<int>('b')));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.find(0)->second.cast<char>(), 'a');
ASSERT_EQ(view.find(1.)->second.cast<char>(), 'b');
ASSERT_EQ(view.erase(invalid_type{}), 0u);
ASSERT_FALSE(view.find(invalid_type{}));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.erase(0), 1u);
ASSERT_EQ(view.size(), 4u);
ASSERT_EQ(view.find(0), view.end());
view.find(1.)->second.cast<char &>() = 'f';
ASSERT_EQ(view.find(1.f)->second.cast<char>(), 'f');
ASSERT_EQ(view.erase(1.), 1u);
ASSERT_TRUE(view.clear());
ASSERT_TRUE(view.reserve(42u));
ASSERT_EQ(view.size(), 0u);
}
TEST(MetaContainer, DenseSet) {
entt::dense_set<int> set{};
auto any = entt::forward_as_meta(set);
auto view = any.as_associative_container();
set.emplace(2);
set.emplace(3);
set.emplace(4);
ASSERT_TRUE(view);
ASSERT_TRUE(view.key_only());
ASSERT_EQ(view.key_type(), entt::resolve<int>());
ASSERT_EQ(view.mapped_type(), entt::meta_type{});
ASSERT_EQ(view.value_type(), entt::resolve<int>());
ASSERT_EQ(view.size(), 3u);
ASSERT_NE(view.begin(), view.end());
ASSERT_EQ(view.find(3)->first.cast<int>(), 3);
ASSERT_FALSE(view.insert(invalid_type{}));
ASSERT_TRUE(view.insert(.0));
ASSERT_TRUE(view.insert(1));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.find(0)->first.cast<int>(), 0);
ASSERT_EQ(view.find(1.)->first.cast<int>(), 1);
ASSERT_EQ(view.erase(invalid_type{}), 0u);
ASSERT_FALSE(view.find(invalid_type{}));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.erase(0), 1u);
ASSERT_EQ(view.size(), 4u);
ASSERT_EQ(view.find(0), view.end());
ASSERT_EQ(view.find(1.f)->first.try_cast<int>(), nullptr);
ASSERT_NE(view.find(1.)->first.try_cast<const int>(), nullptr);
ASSERT_EQ(view.find(true)->first.cast<const int &>(), 1);
ASSERT_EQ(view.erase(1.), 1u);
ASSERT_TRUE(view.clear());
ASSERT_TRUE(view.reserve(42u));
ASSERT_EQ(view.size(), 0u);
}
TEST(MetaContainer, ConstSequenceContainer) {
TEST(SequenceContainer, Constness) {
std::vector<int> vec{};
auto any = entt::forward_as_meta(std::as_const(vec));
auto view = any.as_sequence_container();
@@ -529,7 +358,7 @@ TEST(MetaContainer, ConstSequenceContainer) {
ASSERT_EQ(view.size(), 1u);
}
ENTT_DEBUG_TEST(MetaContainerDeathTest, ConstSequenceContainer) {
ENTT_DEBUG_TEST(SequenceContainerDeathTest, Constness) {
std::vector<int> vec{};
auto any = entt::forward_as_meta(std::as_const(vec));
auto view = any.as_sequence_container();
@@ -538,7 +367,258 @@ ENTT_DEBUG_TEST(MetaContainerDeathTest, ConstSequenceContainer) {
ASSERT_DEATH(view[0].cast<int &>() = 2, "");
}
TEST(MetaContainer, ConstKeyValueAssociativeContainer) {
TEST(SequenceContainer, AsConst) {
auto test = [](const entt::meta_any any) {
auto view = any.as_sequence_container();
ASSERT_TRUE(view);
ASSERT_EQ(view.value_type(), entt::resolve<int>());
ASSERT_EQ(view[0].cast<const int &>(), 42);
};
std::vector<int> vec{42};
test(vec);
test(entt::forward_as_meta(vec));
test(entt::forward_as_meta(std::as_const(vec)));
}
ENTT_DEBUG_TEST(SequenceContainerDeathTest, AsConst) {
auto test = [](const entt::meta_any any) {
auto view = any.as_sequence_container();
ASSERT_TRUE(view);
ASSERT_DEATH(view[0].cast<int &>() = 2, "");
};
std::vector<int> vec{42};
test(vec);
test(entt::forward_as_meta(vec));
test(entt::forward_as_meta(std::as_const(vec)));
}
TEST(AssociativeContainer, Empty) {
entt::meta_associative_container container{};
ASSERT_FALSE(container);
entt::meta_any any{std::map<int, char>{}};
container = any.as_associative_container();
ASSERT_TRUE(container);
}
TEST(AssociativeContainer, Iterator) {
std::map<int, char> map{{2, 'c'}, {3, 'd'}, {4, 'e'}};
auto any = entt::forward_as_meta(map);
entt::meta_associative_container::iterator first{};
auto view = any.as_associative_container();
ASSERT_FALSE(first);
first = view.begin();
const auto last = view.end();
ASSERT_TRUE(first);
ASSERT_TRUE(last);
ASSERT_FALSE(first == last);
ASSERT_TRUE(first != last);
ASSERT_NE(first, last);
ASSERT_EQ((first++)->first.cast<int>(), 2);
ASSERT_EQ((++first)->second.cast<char>(), 'e');
ASSERT_NE(first++, last);
ASSERT_EQ(first, last);
ASSERT_TRUE(first == last);
ASSERT_FALSE(first != last);
}
TEST(AssociativeContainer, StdMap) {
std::map<int, char> map{{2, 'c'}, {3, 'd'}, {4, 'e'}};
auto any = entt::forward_as_meta(map);
auto view = any.as_associative_container();
ASSERT_TRUE(view);
ASSERT_FALSE(view.key_only());
ASSERT_EQ(view.key_type(), entt::resolve<int>());
ASSERT_EQ(view.mapped_type(), entt::resolve<char>());
ASSERT_EQ(view.value_type(), (entt::resolve<std::pair<const int, char>>()));
ASSERT_EQ(view.size(), 3u);
ASSERT_NE(view.begin(), view.end());
ASSERT_EQ(view.find(3)->second.cast<char>(), 'd');
ASSERT_FALSE(view.insert(invalid{}, 'a'));
ASSERT_FALSE(view.insert(1, invalid{}));
ASSERT_TRUE(view.insert(0, 'a'));
ASSERT_TRUE(view.insert(1., static_cast<int>('b')));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.find(0)->second.cast<char>(), 'a');
ASSERT_EQ(view.find(1.)->second.cast<char>(), 'b');
ASSERT_EQ(view.erase(invalid{}), 0u);
ASSERT_FALSE(view.find(invalid{}));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.erase(0), 1u);
ASSERT_EQ(view.size(), 4u);
ASSERT_EQ(view.find(0), view.end());
view.find(1.)->second.cast<char &>() = 'f';
ASSERT_EQ(view.find(1.f)->second.cast<char>(), 'f');
ASSERT_EQ(view.erase(1.), 1u);
ASSERT_TRUE(view.clear());
ASSERT_FALSE(view.reserve(42u));
ASSERT_EQ(view.size(), 0u);
}
TEST(AssociativeContainer, StdSet) {
std::set<int> set{2, 3, 4};
auto any = entt::forward_as_meta(set);
auto view = any.as_associative_container();
ASSERT_TRUE(view);
ASSERT_TRUE(view.key_only());
ASSERT_EQ(view.key_type(), entt::resolve<int>());
ASSERT_EQ(view.mapped_type(), entt::meta_type{});
ASSERT_EQ(view.value_type(), entt::resolve<int>());
ASSERT_EQ(view.size(), 3u);
ASSERT_NE(view.begin(), view.end());
ASSERT_EQ(view.find(3)->first.cast<int>(), 3);
ASSERT_FALSE(view.insert(invalid{}));
ASSERT_TRUE(view.insert(.0));
ASSERT_TRUE(view.insert(1));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.find(0)->first.cast<int>(), 0);
ASSERT_EQ(view.find(1.)->first.cast<int>(), 1);
ASSERT_EQ(view.erase(invalid{}), 0u);
ASSERT_FALSE(view.find(invalid{}));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.erase(0), 1u);
ASSERT_EQ(view.size(), 4u);
ASSERT_EQ(view.find(0), view.end());
ASSERT_EQ(view.find(1.f)->first.try_cast<int>(), nullptr);
ASSERT_NE(view.find(1.)->first.try_cast<const int>(), nullptr);
ASSERT_EQ(view.find(true)->first.cast<const int &>(), 1);
ASSERT_EQ(view.erase(1.), 1u);
ASSERT_TRUE(view.clear());
ASSERT_FALSE(view.reserve(42u));
ASSERT_EQ(view.size(), 0u);
}
TEST(AssociativeContainer, DenseMap) {
entt::dense_map<int, char> map{};
auto any = entt::forward_as_meta(map);
auto view = any.as_associative_container();
map.emplace(2, 'c');
map.emplace(3, 'd');
map.emplace(4, '3');
ASSERT_TRUE(view);
ASSERT_FALSE(view.key_only());
ASSERT_EQ(view.key_type(), entt::resolve<int>());
ASSERT_EQ(view.mapped_type(), entt::resolve<char>());
ASSERT_EQ(view.value_type(), (entt::resolve<std::pair<const int, char>>()));
ASSERT_EQ(view.size(), 3u);
ASSERT_NE(view.begin(), view.end());
ASSERT_EQ(view.find(3)->second.cast<char>(), 'd');
ASSERT_FALSE(view.insert(invalid{}, 'a'));
ASSERT_FALSE(view.insert(1, invalid{}));
ASSERT_TRUE(view.insert(0, 'a'));
ASSERT_TRUE(view.insert(1., static_cast<int>('b')));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.find(0)->second.cast<char>(), 'a');
ASSERT_EQ(view.find(1.)->second.cast<char>(), 'b');
ASSERT_EQ(view.erase(invalid{}), 0u);
ASSERT_FALSE(view.find(invalid{}));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.erase(0), 1u);
ASSERT_EQ(view.size(), 4u);
ASSERT_EQ(view.find(0), view.end());
view.find(1.)->second.cast<char &>() = 'f';
ASSERT_EQ(view.find(1.f)->second.cast<char>(), 'f');
ASSERT_EQ(view.erase(1.), 1u);
ASSERT_TRUE(view.clear());
ASSERT_TRUE(view.reserve(42u));
ASSERT_EQ(view.size(), 0u);
}
TEST(AssociativeContainer, DenseSet) {
entt::dense_set<int> set{};
auto any = entt::forward_as_meta(set);
auto view = any.as_associative_container();
set.emplace(2);
set.emplace(3);
set.emplace(4);
ASSERT_TRUE(view);
ASSERT_TRUE(view.key_only());
ASSERT_EQ(view.key_type(), entt::resolve<int>());
ASSERT_EQ(view.mapped_type(), entt::meta_type{});
ASSERT_EQ(view.value_type(), entt::resolve<int>());
ASSERT_EQ(view.size(), 3u);
ASSERT_NE(view.begin(), view.end());
ASSERT_EQ(view.find(3)->first.cast<int>(), 3);
ASSERT_FALSE(view.insert(invalid{}));
ASSERT_TRUE(view.insert(.0));
ASSERT_TRUE(view.insert(1));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.find(0)->first.cast<int>(), 0);
ASSERT_EQ(view.find(1.)->first.cast<int>(), 1);
ASSERT_EQ(view.erase(invalid{}), 0u);
ASSERT_FALSE(view.find(invalid{}));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.erase(0), 1u);
ASSERT_EQ(view.size(), 4u);
ASSERT_EQ(view.find(0), view.end());
ASSERT_EQ(view.find(1.f)->first.try_cast<int>(), nullptr);
ASSERT_NE(view.find(1.)->first.try_cast<const int>(), nullptr);
ASSERT_EQ(view.find(true)->first.cast<const int &>(), 1);
ASSERT_EQ(view.erase(1.), 1u);
ASSERT_TRUE(view.clear());
ASSERT_TRUE(view.reserve(42u));
ASSERT_EQ(view.size(), 0u);
}
TEST(KeyValueAssociativeContainer, Constness) {
std::map<int, char> map{};
auto any = entt::forward_as_meta(std::as_const(map));
auto view = any.as_associative_container();
@@ -572,7 +652,7 @@ TEST(MetaContainer, ConstKeyValueAssociativeContainer) {
ASSERT_EQ(view.size(), 1u);
}
ENTT_DEBUG_TEST(MetaContainerDeathTest, ConstKeyValueAssociativeContainer) {
ENTT_DEBUG_TEST(KeyValueAssociativeContainerDeathTest, Constness) {
std::map<int, char> map{};
auto any = entt::forward_as_meta(std::as_const(map));
auto view = any.as_associative_container();
@@ -581,7 +661,7 @@ ENTT_DEBUG_TEST(MetaContainerDeathTest, ConstKeyValueAssociativeContainer) {
ASSERT_DEATH(view.find(2)->second.cast<char &>() = 'a', "");
}
TEST(MetaContainer, ConstKeyOnlyAssociativeContainer) {
TEST(KeyOnlyAssociativeContainer, Constness) {
std::set<int> set{};
auto any = entt::forward_as_meta(std::as_const(set));
auto view = any.as_associative_container();
@@ -619,38 +699,7 @@ TEST(MetaContainer, ConstKeyOnlyAssociativeContainer) {
ASSERT_EQ(view.size(), 1u);
}
TEST(MetaContainer, SequenceContainerConstMetaAny) {
auto test = [](const entt::meta_any any) {
auto view = any.as_sequence_container();
ASSERT_TRUE(view);
ASSERT_EQ(view.value_type(), entt::resolve<int>());
ASSERT_EQ(view[0].cast<const int &>(), 42);
};
std::vector<int> vec{42};
test(vec);
test(entt::forward_as_meta(vec));
test(entt::forward_as_meta(std::as_const(vec)));
}
ENTT_DEBUG_TEST(MetaContainerDeathTest, SequenceContainerConstMetaAny) {
auto test = [](const entt::meta_any any) {
auto view = any.as_sequence_container();
ASSERT_TRUE(view);
ASSERT_DEATH(view[0].cast<int &>() = 2, "");
};
std::vector<int> vec{42};
test(vec);
test(entt::forward_as_meta(vec));
test(entt::forward_as_meta(std::as_const(vec)));
}
TEST(MetaContainer, KeyValueAssociativeContainerConstMetaAny) {
TEST(KeyValueAssociativeContainer, AsConst) {
auto test = [](const entt::meta_any any) {
auto view = any.as_associative_container();
@@ -666,7 +715,7 @@ TEST(MetaContainer, KeyValueAssociativeContainerConstMetaAny) {
test(entt::forward_as_meta(std::as_const(map)));
}
ENTT_DEBUG_TEST(MetaContainerDeathTest, KeyValueAssociativeContainerConstMetaAny) {
ENTT_DEBUG_TEST(KeyValueAssociativeContainerDeathTest, AsConst) {
auto test = [](const entt::meta_any any) {
auto view = any.as_associative_container();
@@ -681,7 +730,7 @@ ENTT_DEBUG_TEST(MetaContainerDeathTest, KeyValueAssociativeContainerConstMetaAny
test(entt::forward_as_meta(std::as_const(map)));
}
TEST(MetaContainer, KeyOnlyAssociativeContainerConstMetaAny) {
TEST(KeyOnlyAssociativeContainer, AsConst) {
auto test = [](const entt::meta_any any) {
auto view = any.as_associative_container();
@@ -700,52 +749,3 @@ TEST(MetaContainer, KeyOnlyAssociativeContainerConstMetaAny) {
test(entt::forward_as_meta(set));
test(entt::forward_as_meta(std::as_const(set)));
}
TEST(MetaContainer, StdVectorBool) {
using proxy_type = typename std::vector<bool>::reference;
using const_proxy_type = typename std::vector<bool>::const_reference;
std::vector<bool> vec{};
auto any = entt::forward_as_meta(vec);
auto cany = std::as_const(any).as_ref();
auto view = any.as_sequence_container();
auto cview = cany.as_sequence_container();
ASSERT_TRUE(view);
ASSERT_EQ(view.value_type(), entt::resolve<bool>());
ASSERT_EQ(view.size(), 0u);
ASSERT_EQ(view.begin(), view.end());
ASSERT_TRUE(view.resize(3u));
ASSERT_EQ(view.size(), 3u);
ASSERT_NE(view.begin(), view.end());
view[0].cast<proxy_type>() = true;
view[1].cast<proxy_type>() = true;
view[2].cast<proxy_type>() = false;
ASSERT_EQ(cview[1u].cast<const_proxy_type>(), true);
auto it = view.begin();
auto ret = view.insert(it, true);
ASSERT_TRUE(ret);
ASSERT_FALSE(view.insert(ret, invalid_type{}));
ASSERT_TRUE(view.insert(++ret, false));
ASSERT_EQ(view.size(), 5u);
ASSERT_EQ(view.begin()->cast<proxy_type>(), true);
ASSERT_EQ((++cview.begin())->cast<const_proxy_type>(), false);
it = view.begin();
ret = view.erase(it);
ASSERT_TRUE(ret);
ASSERT_EQ(view.size(), 4u);
ASSERT_EQ(ret->cast<proxy_type>(), false);
ASSERT_TRUE(view.clear());
ASSERT_TRUE(view.reserve(42u));
ASSERT_EQ(cview.size(), 0u);
}