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

test: minor changes

Browse Source
This commit is contained in:
Michele Caini
2023-10-29 22:59:41 +01:00
parent 57d1754bc8
commit e742fe7bf9
4 changed files with 71 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
test/entt/entity/registry.cpp
View File

@@ -22,9 +22,9 @@ bool operator==(const no_eto_type &lhs, const no_eto_type &rhs) {
return &lhs == &rhs;
}
struct stable_type {
struct pointer_stable {
static constexpr auto in_place_delete = true;
int value;
int value{};
};
struct non_default_constructible {
@@ -748,17 +748,17 @@ TEST(Registry, DestroyRange) {
TEST(Registry, StableDestroy) {
entt::registry registry;
const auto iview = registry.view<int>();
const auto icview = registry.view<int, stable_type>();
const auto icview = registry.view<int, pointer_stable>();
entt::entity entity[3u];
registry.create(std::begin(entity), std::end(entity));
registry.emplace<int>(entity[0u]);
registry.emplace<stable_type>(entity[0u]);
registry.emplace<pointer_stable>(entity[0u]);
registry.emplace<double>(entity[0u]);
registry.emplace<int>(entity[1u]);
registry.emplace<stable_type>(entity[1u]);
registry.emplace<pointer_stable>(entity[1u]);
registry.emplace<int>(entity[2u]);
@@ -773,7 +773,7 @@ TEST(Registry, StableDestroy) {
ASSERT_TRUE(registry.valid(entity[2u]));
ASSERT_EQ(registry.storage<int>().size(), 1u);
ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
ASSERT_EQ(registry.storage<double>().size(), 0u);
registry.destroy(iview.begin(), iview.end());
@@ -783,7 +783,7 @@ TEST(Registry, StableDestroy) {
ASSERT_EQ(icview.size_hint(), 0u);
ASSERT_EQ(registry.storage<int>().size(), 0u);
ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
ASSERT_EQ(registry.storage<double>().size(), 0u);
}
@@ -1577,17 +1577,17 @@ ENTT_DEBUG_TEST(RegistryDeathTest, Erase) {
TEST(Registry, StableErase) {
entt::registry registry;
const auto iview = registry.view<int>();
const auto icview = registry.view<int, stable_type>();
const auto icview = registry.view<int, pointer_stable>();
entt::entity entity[3u];
registry.create(std::begin(entity), std::end(entity));
registry.emplace<int>(entity[0u]);
registry.emplace<stable_type>(entity[0u]);
registry.emplace<pointer_stable>(entity[0u]);
registry.emplace<double>(entity[0u]);
registry.emplace<int>(entity[1u]);
registry.emplace<stable_type>(entity[1u]);
registry.emplace<pointer_stable>(entity[1u]);
registry.emplace<int>(entity[2u]);
@@ -1595,16 +1595,16 @@ TEST(Registry, StableErase) {
ASSERT_TRUE(registry.all_of<int>(entity[1u]));
ASSERT_TRUE(registry.any_of<int>(entity[2u]));
registry.erase<int, stable_type>(entity[0u]);
registry.erase<int, stable_type>(icview.begin(), icview.end());
registry.erase<int, stable_type>(icview.begin(), icview.end());
registry.erase<int, pointer_stable>(entity[0u]);
registry.erase<int, pointer_stable>(icview.begin(), icview.end());
registry.erase<int, pointer_stable>(icview.begin(), icview.end());
ASSERT_FALSE(registry.any_of<int>(entity[0u]));
ASSERT_FALSE(registry.all_of<int>(entity[1u]));
ASSERT_TRUE(registry.any_of<int>(entity[2u]));
ASSERT_EQ(registry.storage<int>().size(), 1u);
ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
ASSERT_EQ(registry.storage<double>().size(), 1u);
registry.erase<int>(iview.begin(), iview.end());
@@ -1612,7 +1612,7 @@ TEST(Registry, StableErase) {
ASSERT_FALSE(registry.any_of<int>(entity[2u]));
ASSERT_EQ(registry.storage<int>().size(), 0u);
ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
ASSERT_EQ(registry.storage<double>().size(), 1u);
}
@@ -1727,17 +1727,17 @@ TEST(Registry, Remove) {
TEST(Registry, StableRemove) {
entt::registry registry;
const auto iview = registry.view<int>();
const auto icview = registry.view<int, stable_type>();
const auto icview = registry.view<int, pointer_stable>();
entt::entity entity[3u];
registry.create(std::begin(entity), std::end(entity));
registry.emplace<int>(entity[0u]);
registry.emplace<stable_type>(entity[0u]);
registry.emplace<pointer_stable>(entity[0u]);
registry.emplace<double>(entity[0u]);
registry.emplace<int>(entity[1u]);
registry.emplace<stable_type>(entity[1u]);
registry.emplace<pointer_stable>(entity[1u]);
registry.emplace<int>(entity[2u]);
@@ -1745,17 +1745,17 @@ TEST(Registry, StableRemove) {
ASSERT_TRUE(registry.all_of<int>(entity[1u]));
ASSERT_TRUE(registry.any_of<int>(entity[2u]));
registry.remove<int, stable_type>(entity[0u]);
registry.remove<int, pointer_stable>(entity[0u]);
ASSERT_EQ((registry.remove<int, stable_type>(icview.begin(), icview.end())), 2u);
ASSERT_EQ((registry.remove<int, stable_type>(icview.begin(), icview.end())), 0u);
ASSERT_EQ((registry.remove<int, pointer_stable>(icview.begin(), icview.end())), 2u);
ASSERT_EQ((registry.remove<int, pointer_stable>(icview.begin(), icview.end())), 0u);
ASSERT_FALSE(registry.any_of<int>(entity[0u]));
ASSERT_FALSE(registry.all_of<int>(entity[1u]));
ASSERT_TRUE(registry.any_of<int>(entity[2u]));
ASSERT_EQ(registry.storage<int>().size(), 1u);
ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
ASSERT_EQ(registry.storage<double>().size(), 1u);
ASSERT_EQ((registry.remove<int>(iview.begin(), iview.end())), 1u);
@@ -1766,7 +1766,7 @@ TEST(Registry, StableRemove) {
ASSERT_FALSE(registry.any_of<int>(entity[2u]));
ASSERT_EQ(registry.storage<int>().size(), 0u);
ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
ASSERT_EQ(registry.storage<double>().size(), 1u);
}
@@ -1777,28 +1777,28 @@ TEST(Registry, Compact) {
registry.create(std::begin(entity), std::end(entity));
registry.emplace<int>(entity[0u]);
registry.emplace<stable_type>(entity[0u]);
registry.emplace<pointer_stable>(entity[0u]);
registry.emplace<int>(entity[1u]);
registry.emplace<stable_type>(entity[1u]);
registry.emplace<pointer_stable>(entity[1u]);
ASSERT_EQ(registry.storage<int>().size(), 2u);
ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
registry.destroy(std::begin(entity), std::end(entity));
ASSERT_EQ(registry.storage<int>().size(), 0u);
ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
registry.compact<int>();
ASSERT_EQ(registry.storage<int>().size(), 0u);
ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
registry.compact();
ASSERT_EQ(registry.storage<int>().size(), 0u);
ASSERT_EQ(registry.storage<stable_type>().size(), 0u);
ASSERT_EQ(registry.storage<pointer_stable>().size(), 0u);
}
TEST(Registry, NonOwningGroupInterleaved) {

18
test/entt/entity/runtime_view.cpp
View File

@@ -5,9 +5,9 @@
#include <entt/entity/registry.hpp>
#include <entt/entity/runtime_view.hpp>
struct stable_type {
struct pointer_stable {
static constexpr auto in_place_delete = true;
int value;
int value{};
};
template<typename Type>
@@ -341,12 +341,12 @@ TYPED_TEST(RuntimeView, StableType) {
registry.emplace<int>(e1);
registry.emplace<int>(e2);
registry.emplace<stable_type>(e0);
registry.emplace<stable_type>(e1);
registry.emplace<pointer_stable>(e0);
registry.emplace<pointer_stable>(e1);
registry.remove<stable_type>(e1);
registry.remove<pointer_stable>(e1);
view.iterate(registry.storage<int>()).iterate(registry.storage<stable_type>());
view.iterate(registry.storage<int>()).iterate(registry.storage<pointer_stable>());
ASSERT_EQ(view.size_hint(), 2u);
ASSERT_TRUE(view.contains(e0));
@@ -378,11 +378,11 @@ TYPED_TEST(RuntimeView, StableTypeWithExcludedComponent) {
const auto entity = registry.create();
const auto other = registry.create();
registry.emplace<stable_type>(entity, 0);
registry.emplace<stable_type>(other, 42);
registry.emplace<pointer_stable>(entity, 0);
registry.emplace<pointer_stable>(other, 42);
registry.emplace<int>(entity);
view.iterate(registry.storage<stable_type>()).exclude(registry.storage<int>());
view.iterate(registry.storage<pointer_stable>()).exclude(registry.storage<int>());
ASSERT_EQ(view.size_hint(), 2u);
ASSERT_FALSE(view.contains(entity));

10
test/entt/entity/sigh_mixin.cpp
View File

@@ -8,7 +8,7 @@
struct empty_type {};
struct stable_type {
struct pointer_stable {
static constexpr auto in_place_delete = true;
int value{};
};
@@ -109,7 +109,7 @@ TEST(SighMixin, GenericType) {
TEST(SighMixin, StableType) {
entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
entt::sigh_mixin<entt::storage<stable_type>> pool;
entt::sigh_mixin<entt::storage<pointer_stable>> pool;
entt::sparse_set &base = pool;
entt::registry registry;
@@ -156,7 +156,7 @@ TEST(SighMixin, StableType) {
ASSERT_EQ(on_destroy.value, 4);
ASSERT_EQ(pool.size(), 4u);
pool.insert(std::begin(entity), std::end(entity), stable_type{3});
pool.insert(std::begin(entity), std::end(entity), pointer_stable{3});
ASSERT_EQ(on_construct.value, 6);
ASSERT_EQ(on_destroy.value, 4);
@@ -540,7 +540,7 @@ TEST(SighMixin, CustomAllocator) {
test(entt::sigh_mixin<entt::basic_storage<int, entt::entity, test::throwing_allocator<int>>>{allocator}, allocator);
test(entt::sigh_mixin<entt::basic_storage<std::true_type, entt::entity, test::throwing_allocator<std::true_type>>>{allocator}, allocator);
test(entt::sigh_mixin<entt::basic_storage<stable_type, entt::entity, test::throwing_allocator<stable_type>>>{allocator}, allocator);
test(entt::sigh_mixin<entt::basic_storage<pointer_stable, entt::entity, test::throwing_allocator<pointer_stable>>>{allocator}, allocator);
}
TEST(SighMixin, ThrowingAllocator) {
@@ -616,7 +616,7 @@ TEST(SighMixin, ThrowingAllocator) {
};
test(entt::sigh_mixin<entt::basic_storage<int, entt::entity, test::throwing_allocator<int>>>{});
test(entt::sigh_mixin<entt::basic_storage<stable_type, entt::entity, test::throwing_allocator<stable_type>>>{});
test(entt::sigh_mixin<entt::basic_storage<pointer_stable, entt::entity, test::throwing_allocator<pointer_stable>>>{});
}
TEST(SighMixin, ThrowingComponent) {

56
test/entt/entity/view.cpp
View File

@@ -8,9 +8,9 @@
struct empty_type {};
struct stable_type {
struct pointer_stable {
static constexpr auto in_place_delete = true;
int value;
int value{};
};
TEST(SingleComponentView, Functionalities) {
@@ -420,15 +420,15 @@ TEST(SingleComponentView, FrontBack) {
TEST(SingleComponentView, DeductionGuide) {
entt::registry registry;
entt::storage_type_t<int> istorage;
entt::storage_type_t<stable_type> sstorage;
entt::storage_type_t<pointer_stable> sstorage;
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>>, entt::exclude_t<>>, decltype(entt::basic_view{std::as_const(istorage)})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<stable_type>>, entt::exclude_t<>>, decltype(entt::basic_view{sstorage})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<pointer_stable>>, entt::exclude_t<>>, decltype(entt::basic_view{sstorage})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage), std::make_tuple()})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage))})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<stable_type>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(sstorage)})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<pointer_stable>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(sstorage)})>();
}
TEST(SingleComponentView, IterableViewAlgorithmCompatibility) {
@@ -446,13 +446,13 @@ TEST(SingleComponentView, IterableViewAlgorithmCompatibility) {
TEST(SingleComponentView, StableType) {
entt::registry registry;
auto view = registry.view<stable_type>();
auto view = registry.view<pointer_stable>();
const auto entity = registry.create();
const auto other = registry.create();
registry.emplace<stable_type>(entity);
registry.emplace<stable_type>(other);
registry.emplace<pointer_stable>(entity);
registry.emplace<pointer_stable>(other);
registry.destroy(entity);
ASSERT_EQ(view.size_hint(), 2u);
@@ -465,18 +465,18 @@ TEST(SingleComponentView, StableType) {
ASSERT_EQ(*view.begin(), other);
ASSERT_EQ(++view.begin(), view.end());
view.each([other](const auto entt, stable_type) {
view.each([other](const auto entt, pointer_stable) {
ASSERT_EQ(other, entt);
});
view.each([check = true](stable_type) mutable {
view.each([check = true](pointer_stable) mutable {
ASSERT_TRUE(check);
check = false;
});
for(auto [entt, st]: view.each()) {
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(st), stable_type &>();
testing::StaticAssertTypeEq<decltype(st), pointer_stable &>();
ASSERT_EQ(other, entt);
}
@@ -1256,25 +1256,25 @@ TEST(MultiComponentView, DeductionGuide) {
entt::registry registry;
entt::storage_type_t<int> istorage;
entt::storage_type_t<double> dstorage;
entt::storage_type_t<stable_type> sstorage;
entt::storage_type_t<pointer_stable> sstorage;
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, dstorage})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::as_const(istorage), dstorage})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, std::as_const(dstorage)})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::as_const(istorage), std::as_const(dstorage)})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<stable_type>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, sstorage})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<pointer_stable>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, sstorage})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, dstorage), std::make_tuple()})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage), dstorage)})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, std::as_const(dstorage))})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage), std::as_const(dstorage))})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<stable_type>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, sstorage)})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<pointer_stable>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, sstorage)})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<entt::storage_type_t<double>>>, decltype(entt::basic_view{std::forward_as_tuple(istorage), std::forward_as_tuple(dstorage)})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>>, entt::exclude_t<entt::storage_type_t<double>>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage)), std::forward_as_tuple(dstorage)})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<const entt::storage_type_t<double>>>, decltype(entt::basic_view{std::forward_as_tuple(istorage), std::forward_as_tuple(std::as_const(dstorage))})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>>, entt::exclude_t<const entt::storage_type_t<double>>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage)), std::forward_as_tuple(std::as_const(dstorage))})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<entt::storage_type_t<stable_type>>>, decltype(entt::basic_view{std::forward_as_tuple(istorage), std::forward_as_tuple(sstorage)})>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<entt::storage_type_t<pointer_stable>>>, decltype(entt::basic_view{std::forward_as_tuple(istorage), std::forward_as_tuple(sstorage)})>();
}
TEST(MultiComponentView, IterableViewAlgorithmCompatibility) {
@@ -1293,20 +1293,20 @@ TEST(MultiComponentView, IterableViewAlgorithmCompatibility) {
TEST(MultiComponentView, StableType) {
entt::registry registry;
auto view = registry.view<int, stable_type>();
auto view = registry.view<int, pointer_stable>();
const auto entity = registry.create();
const auto other = registry.create();
registry.emplace<int>(entity);
registry.emplace<int>(other);
registry.emplace<stable_type>(entity);
registry.emplace<stable_type>(other);
registry.emplace<pointer_stable>(entity);
registry.emplace<pointer_stable>(other);
registry.destroy(entity);
ASSERT_EQ(view.size_hint(), 1u);
view.use<stable_type>();
view.use<pointer_stable>();
ASSERT_EQ(view.size_hint(), 2u);
ASSERT_FALSE(view.contains(entity));
@@ -1318,11 +1318,11 @@ TEST(MultiComponentView, StableType) {
ASSERT_EQ(*view.begin(), other);
ASSERT_EQ(++view.begin(), view.end());
view.each([other](const auto entt, int, stable_type) {
view.each([other](const auto entt, int, pointer_stable) {
ASSERT_EQ(other, entt);
});
view.each([check = true](int, stable_type) mutable {
view.each([check = true](int, pointer_stable) mutable {
ASSERT_TRUE(check);
check = false;
});
@@ -1330,7 +1330,7 @@ TEST(MultiComponentView, StableType) {
for(auto [entt, iv, st]: view.each()) {
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(st), stable_type &>();
testing::StaticAssertTypeEq<decltype(st), pointer_stable &>();
ASSERT_EQ(other, entt);
}
@@ -1341,13 +1341,13 @@ TEST(MultiComponentView, StableType) {
TEST(MultiComponentView, StableTypeWithExcludedComponent) {
entt::registry registry;
auto view = registry.view<stable_type>(entt::exclude<int>);
auto view = registry.view<pointer_stable>(entt::exclude<int>);
const auto entity = registry.create();
const auto other = registry.create();
registry.emplace<stable_type>(entity, 0);
registry.emplace<stable_type>(other, 42);
registry.emplace<pointer_stable>(entity, 0);
registry.emplace<pointer_stable>(other, 42);
registry.emplace<int>(entity);
ASSERT_EQ(view.size_hint(), 2u);
@@ -1629,12 +1629,12 @@ TEST(View, Pipe) {
registry.emplace<int>(other);
registry.emplace<char>(other);
registry.emplace<stable_type>(other);
registry.emplace<pointer_stable>(other);
auto view1 = registry.view<int>(entt::exclude<const double>);
auto view2 = registry.view<const char>(entt::exclude<float>);
auto view3 = registry.view<empty_type>();
auto view4 = registry.view<stable_type>();
auto view4 = registry.view<pointer_stable>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, const entt::storage_type_t<char>>, entt::exclude_t<const entt::storage_type_t<double>, entt::storage_type_t<float>>>, decltype(view1 | view2)>();
testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<char>, entt::storage_type_t<int>>, entt::exclude_t<entt::storage_type_t<float>, const entt::storage_type_t<double>>>, decltype(view2 | view1)>();
@@ -1668,7 +1668,7 @@ TEST(View, Pipe) {
ASSERT_EQ(pack14.storage<int>(), nullptr);
ASSERT_EQ(pack14.storage<const double>(), nullptr);
ASSERT_NE(pack14.storage<stable_type>(), nullptr);
ASSERT_NE(pack14.storage<pointer_stable>(), nullptr);
ASSERT_EQ(pack32.storage<empty_type>(), nullptr);
ASSERT_NE(pack32.storage<const char>(), nullptr);