From 06e032bc6dde35b8fc3c443216571a589f4c4b1f Mon Sep 17 00:00:00 2001 From: Michele Caini Date: Thu, 5 Oct 2023 10:38:03 +0200 Subject: [PATCH] test: prepare for new meta container tests --- test/entt/meta/meta_container.cpp | 638 +++++++++++++++--------------- 1 file changed, 319 insertions(+), 319 deletions(-) diff --git a/test/entt/meta/meta_container.cpp b/test/entt/meta/meta_container.cpp index 3af8e4f15..7cc9479df 100644 --- a/test/entt/meta/meta_container.cpp +++ b/test/entt/meta/meta_container.cpp @@ -13,9 +13,9 @@ #include #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{}}.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{}}; - container = any.as_associative_container(); - - ASSERT_TRUE(container); -} - -TEST(MetaContainer, SequenceContainerIterator) { +TEST(SequenceContainer, Iterator) { std::vector 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(), 2); } -TEST(MetaContainer, AssociativeContainerIterator) { - std::map 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(), 2); - ASSERT_EQ((++first)->second.cast(), '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 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::reference; + using const_proxy_type = typename std::vector::const_reference; + + std::vector 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()); + + 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() = true; + view[1].cast() = true; + view[2].cast() = false; + + ASSERT_EQ(cview[1u].cast(), 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(), true); + ASSERT_EQ((++cview.begin())->cast(), false); + + it = view.begin(); + ret = view.erase(it); + + ASSERT_TRUE(ret); + ASSERT_EQ(view.size(), 4u); + ASSERT_EQ(ret->cast(), false); + + ASSERT_TRUE(view.clear()); + ASSERT_TRUE(view.reserve(42u)); + ASSERT_EQ(cview.size(), 0u); +} + +TEST(SequenceContainer, StdArray) { std::array 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 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 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 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()); - ASSERT_EQ(view.mapped_type(), entt::resolve()); - ASSERT_EQ(view.value_type(), (entt::resolve>())); - - ASSERT_EQ(view.size(), 3u); - ASSERT_NE(view.begin(), view.end()); - - ASSERT_EQ(view.find(3)->second.cast(), '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('b'))); - - ASSERT_EQ(view.size(), 5u); - ASSERT_EQ(view.find(0)->second.cast(), 'a'); - ASSERT_EQ(view.find(1.)->second.cast(), '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() = 'f'; - - ASSERT_EQ(view.find(1.f)->second.cast(), '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 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()); - ASSERT_EQ(view.mapped_type(), entt::meta_type{}); - ASSERT_EQ(view.value_type(), entt::resolve()); - - ASSERT_EQ(view.size(), 3u); - ASSERT_NE(view.begin(), view.end()); - - ASSERT_EQ(view.find(3)->first.cast(), 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(), 0); - ASSERT_EQ(view.find(1.)->first.cast(), 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(), nullptr); - ASSERT_NE(view.find(1.)->first.try_cast(), nullptr); - ASSERT_EQ(view.find(true)->first.cast(), 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 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()); - ASSERT_EQ(view.mapped_type(), entt::resolve()); - ASSERT_EQ(view.value_type(), (entt::resolve>())); - - ASSERT_EQ(view.size(), 3u); - ASSERT_NE(view.begin(), view.end()); - - ASSERT_EQ(view.find(3)->second.cast(), '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('b'))); - - ASSERT_EQ(view.size(), 5u); - ASSERT_EQ(view.find(0)->second.cast(), 'a'); - ASSERT_EQ(view.find(1.)->second.cast(), '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() = 'f'; - - ASSERT_EQ(view.find(1.f)->second.cast(), '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 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()); - ASSERT_EQ(view.mapped_type(), entt::meta_type{}); - ASSERT_EQ(view.value_type(), entt::resolve()); - - ASSERT_EQ(view.size(), 3u); - ASSERT_NE(view.begin(), view.end()); - - ASSERT_EQ(view.find(3)->first.cast(), 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(), 0); - ASSERT_EQ(view.find(1.)->first.cast(), 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(), nullptr); - ASSERT_NE(view.find(1.)->first.try_cast(), nullptr); - ASSERT_EQ(view.find(true)->first.cast(), 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 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 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() = 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()); + ASSERT_EQ(view[0].cast(), 42); + }; + + std::vector 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() = 2, ""); + }; + + std::vector 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{}}; + container = any.as_associative_container(); + + ASSERT_TRUE(container); +} + +TEST(AssociativeContainer, Iterator) { + std::map 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(), 2); + ASSERT_EQ((++first)->second.cast(), 'e'); + ASSERT_NE(first++, last); + ASSERT_EQ(first, last); + + ASSERT_TRUE(first == last); + ASSERT_FALSE(first != last); +} + +TEST(AssociativeContainer, StdMap) { + std::map 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()); + ASSERT_EQ(view.mapped_type(), entt::resolve()); + ASSERT_EQ(view.value_type(), (entt::resolve>())); + + ASSERT_EQ(view.size(), 3u); + ASSERT_NE(view.begin(), view.end()); + + ASSERT_EQ(view.find(3)->second.cast(), '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('b'))); + + ASSERT_EQ(view.size(), 5u); + ASSERT_EQ(view.find(0)->second.cast(), 'a'); + ASSERT_EQ(view.find(1.)->second.cast(), '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() = 'f'; + + ASSERT_EQ(view.find(1.f)->second.cast(), '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 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()); + ASSERT_EQ(view.mapped_type(), entt::meta_type{}); + ASSERT_EQ(view.value_type(), entt::resolve()); + + ASSERT_EQ(view.size(), 3u); + ASSERT_NE(view.begin(), view.end()); + + ASSERT_EQ(view.find(3)->first.cast(), 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(), 0); + ASSERT_EQ(view.find(1.)->first.cast(), 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(), nullptr); + ASSERT_NE(view.find(1.)->first.try_cast(), nullptr); + ASSERT_EQ(view.find(true)->first.cast(), 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 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()); + ASSERT_EQ(view.mapped_type(), entt::resolve()); + ASSERT_EQ(view.value_type(), (entt::resolve>())); + + ASSERT_EQ(view.size(), 3u); + ASSERT_NE(view.begin(), view.end()); + + ASSERT_EQ(view.find(3)->second.cast(), '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('b'))); + + ASSERT_EQ(view.size(), 5u); + ASSERT_EQ(view.find(0)->second.cast(), 'a'); + ASSERT_EQ(view.find(1.)->second.cast(), '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() = 'f'; + + ASSERT_EQ(view.find(1.f)->second.cast(), '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 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()); + ASSERT_EQ(view.mapped_type(), entt::meta_type{}); + ASSERT_EQ(view.value_type(), entt::resolve()); + + ASSERT_EQ(view.size(), 3u); + ASSERT_NE(view.begin(), view.end()); + + ASSERT_EQ(view.find(3)->first.cast(), 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(), 0); + ASSERT_EQ(view.find(1.)->first.cast(), 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(), nullptr); + ASSERT_NE(view.find(1.)->first.try_cast(), nullptr); + ASSERT_EQ(view.find(true)->first.cast(), 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 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 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() = 'a', ""); } -TEST(MetaContainer, ConstKeyOnlyAssociativeContainer) { +TEST(KeyOnlyAssociativeContainer, Constness) { std::set 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()); - ASSERT_EQ(view[0].cast(), 42); - }; - - std::vector 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() = 2, ""); - }; - - std::vector 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::reference; - using const_proxy_type = typename std::vector::const_reference; - - std::vector 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()); - - 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() = true; - view[1].cast() = true; - view[2].cast() = false; - - ASSERT_EQ(cview[1u].cast(), 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(), true); - ASSERT_EQ((++cview.begin())->cast(), false); - - it = view.begin(); - ret = view.erase(it); - - ASSERT_TRUE(ret); - ASSERT_EQ(view.size(), 4u); - ASSERT_EQ(ret->cast(), false); - - ASSERT_TRUE(view.clear()); - ASSERT_TRUE(view.reserve(42u)); - ASSERT_EQ(cview.size(), 0u); -}