test: prepare for new meta container tests

test/entt/meta/meta_container.cpp

@@ -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,7 +319,124 @@ TEST(MetaContainer, StdDeque) {
     ASSERT_EQ(view.size(), 0u);
 }
 
-TEST(MetaContainer, StdMap) {
+TEST(SequenceContainer, Constness) {
+    std::vector<int> vec{};
+    auto any = entt::forward_as_meta(std::as_const(vec));
+    auto view = any.as_sequence_container();
+
+    ASSERT_TRUE(view);
+    ASSERT_EQ(view.value_type(), entt::resolve<int>());
+
+    ASSERT_EQ(view.size(), 0u);
+    ASSERT_EQ(view.begin(), view.end());
+    ASSERT_FALSE(view.resize(3u));
+    ASSERT_EQ(view.size(), 0u);
+    ASSERT_EQ(view.begin(), view.end());
+
+    vec.push_back(42);
+
+    ASSERT_EQ(view.size(), 1u);
+    ASSERT_NE(view.begin(), view.end());
+    ASSERT_EQ(view[0].cast<const int &>(), 42);
+
+    auto it = view.begin();
+    auto ret = view.insert(it, 0);
+
+    ASSERT_FALSE(ret);
+    ASSERT_EQ(view.size(), 1u);
+    ASSERT_EQ(it->cast<int>(), 42);
+    ASSERT_EQ(++it, view.end());
+
+    it = view.begin();
+    ret = view.erase(it);
+
+    ASSERT_FALSE(ret);
+    ASSERT_EQ(view.size(), 1u);
+
+    ASSERT_FALSE(view.clear());
+    ASSERT_FALSE(view.reserve(42u));
+    ASSERT_EQ(view.size(), 1u);
+}
+
+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();
+
+    ASSERT_TRUE(view);
+    ASSERT_DEATH(view[0].cast<int &>() = 2, "");
+}
+
+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();
@@ -324,8 +452,8 @@ TEST(MetaContainer, StdMap) {
 
     ASSERT_EQ(view.find(3)->second.cast<char>(), 'd');
 
-    ASSERT_FALSE(view.insert(invalid_type{}, 'a'));
-    ASSERT_FALSE(view.insert(1, invalid_type{}));
+    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')));
@@ -334,8 +462,8 @@ TEST(MetaContainer, StdMap) {
     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.erase(invalid{}), 0u);
+    ASSERT_FALSE(view.find(invalid{}));
     ASSERT_EQ(view.size(), 5u);
 
     ASSERT_EQ(view.erase(0), 1u);
@@ -352,7 +480,7 @@ TEST(MetaContainer, StdMap) {
     ASSERT_EQ(view.size(), 0u);
 }
 
-TEST(MetaContainer, StdSet) {
+TEST(AssociativeContainer, StdSet) {
     std::set<int> set{2, 3, 4};
     auto any = entt::forward_as_meta(set);
     auto view = any.as_associative_container();
@@ -368,7 +496,7 @@ TEST(MetaContainer, StdSet) {
 
     ASSERT_EQ(view.find(3)->first.cast<int>(), 3);
 
-    ASSERT_FALSE(view.insert(invalid_type{}));
+    ASSERT_FALSE(view.insert(invalid{}));
 
     ASSERT_TRUE(view.insert(.0));
     ASSERT_TRUE(view.insert(1));
@@ -377,8 +505,8 @@ TEST(MetaContainer, StdSet) {
     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.erase(invalid{}), 0u);
+    ASSERT_FALSE(view.find(invalid{}));
     ASSERT_EQ(view.size(), 5u);
 
     ASSERT_EQ(view.erase(0), 1u);
@@ -395,7 +523,7 @@ TEST(MetaContainer, StdSet) {
     ASSERT_EQ(view.size(), 0u);
 }
 
-TEST(MetaContainer, DenseMap) {
+TEST(AssociativeContainer, DenseMap) {
     entt::dense_map<int, char> map{};
     auto any = entt::forward_as_meta(map);
     auto view = any.as_associative_container();
@@ -415,8 +543,8 @@ TEST(MetaContainer, DenseMap) {
 
     ASSERT_EQ(view.find(3)->second.cast<char>(), 'd');
 
-    ASSERT_FALSE(view.insert(invalid_type{}, 'a'));
-    ASSERT_FALSE(view.insert(1, invalid_type{}));
+    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')));
@@ -425,8 +553,8 @@ TEST(MetaContainer, DenseMap) {
     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.erase(invalid{}), 0u);
+    ASSERT_FALSE(view.find(invalid{}));
     ASSERT_EQ(view.size(), 5u);
 
     ASSERT_EQ(view.erase(0), 1u);
@@ -443,7 +571,7 @@ TEST(MetaContainer, DenseMap) {
     ASSERT_EQ(view.size(), 0u);
 }
 
-TEST(MetaContainer, DenseSet) {
+TEST(AssociativeContainer, DenseSet) {
     entt::dense_set<int> set{};
     auto any = entt::forward_as_meta(set);
     auto view = any.as_associative_container();
@@ -463,7 +591,7 @@ TEST(MetaContainer, DenseSet) {
 
     ASSERT_EQ(view.find(3)->first.cast<int>(), 3);
 
-    ASSERT_FALSE(view.insert(invalid_type{}));
+    ASSERT_FALSE(view.insert(invalid{}));
 
     ASSERT_TRUE(view.insert(.0));
     ASSERT_TRUE(view.insert(1));
@@ -472,8 +600,8 @@ TEST(MetaContainer, DenseSet) {
     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.erase(invalid{}), 0u);
+    ASSERT_FALSE(view.find(invalid{}));
     ASSERT_EQ(view.size(), 5u);
 
     ASSERT_EQ(view.erase(0), 1u);
@@ -490,55 +618,7 @@ TEST(MetaContainer, DenseSet) {
     ASSERT_EQ(view.size(), 0u);
 }
 
-TEST(MetaContainer, ConstSequenceContainer) {
-    std::vector<int> vec{};
-    auto any = entt::forward_as_meta(std::as_const(vec));
-    auto view = any.as_sequence_container();
-
-    ASSERT_TRUE(view);
-    ASSERT_EQ(view.value_type(), entt::resolve<int>());
-
-    ASSERT_EQ(view.size(), 0u);
-    ASSERT_EQ(view.begin(), view.end());
-    ASSERT_FALSE(view.resize(3u));
-    ASSERT_EQ(view.size(), 0u);
-    ASSERT_EQ(view.begin(), view.end());
-
-    vec.push_back(42);
-
-    ASSERT_EQ(view.size(), 1u);
-    ASSERT_NE(view.begin(), view.end());
-    ASSERT_EQ(view[0].cast<const int &>(), 42);
-
-    auto it = view.begin();
-    auto ret = view.insert(it, 0);
-
-    ASSERT_FALSE(ret);
-    ASSERT_EQ(view.size(), 1u);
-    ASSERT_EQ(it->cast<int>(), 42);
-    ASSERT_EQ(++it, view.end());
-
-    it = view.begin();
-    ret = view.erase(it);
-
-    ASSERT_FALSE(ret);
-    ASSERT_EQ(view.size(), 1u);
-
-    ASSERT_FALSE(view.clear());
-    ASSERT_FALSE(view.reserve(42u));
-    ASSERT_EQ(view.size(), 1u);
-}
-
-ENTT_DEBUG_TEST(MetaContainerDeathTest, ConstSequenceContainer) {
-    std::vector<int> vec{};
-    auto any = entt::forward_as_meta(std::as_const(vec));
-    auto view = any.as_sequence_container();
-
-    ASSERT_TRUE(view);
-    ASSERT_DEATH(view[0].cast<int &>() = 2, "");
-}
-
-TEST(MetaContainer, ConstKeyValueAssociativeContainer) {
+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);
-}