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

test: cleanup

Browse Source
This commit is contained in:
Michele Caini
2023-09-19 09:27:01 +02:00
parent 14706c8f9a
commit 1280367a35
13 changed files with 523 additions and 526 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -47,24 +47,24 @@ TEST(CompressedPair, Size) {
empty_type empty;
};
static_assert(sizeof(entt::compressed_pair<int, int>) == sizeof(int[2u]));
static_assert(sizeof(entt::compressed_pair<empty_type, int>) == sizeof(int));
static_assert(sizeof(entt::compressed_pair<int, empty_type>) == sizeof(int));
static_assert(sizeof(entt::compressed_pair<int, empty_type>) < sizeof(local));
static_assert(sizeof(entt::compressed_pair<int, empty_type>) < sizeof(std::pair<int, empty_type>));
ASSERT_EQ(sizeof(entt::compressed_pair<int, int>), sizeof(int[2u]));
ASSERT_EQ(sizeof(entt::compressed_pair<empty_type, int>), sizeof(int));
ASSERT_EQ(sizeof(entt::compressed_pair<int, empty_type>), sizeof(int));
ASSERT_LT(sizeof(entt::compressed_pair<int, empty_type>), sizeof(local));
ASSERT_LT(sizeof(entt::compressed_pair<int, empty_type>), sizeof(std::pair<int, empty_type>));
}
TEST(CompressedPair, ConstructCopyMove) {
static_assert(!std::is_default_constructible_v<entt::compressed_pair<non_default_constructible, empty_type>>);
static_assert(std::is_default_constructible_v<entt::compressed_pair<move_only_type, empty_type>>);
ASSERT_FALSE((std::is_default_constructible_v<entt::compressed_pair<non_default_constructible, empty_type>>));
ASSERT_TRUE((std::is_default_constructible_v<entt::compressed_pair<move_only_type, empty_type>>));
static_assert(std::is_copy_constructible_v<entt::compressed_pair<non_default_constructible, empty_type>>);
static_assert(!std::is_copy_constructible_v<entt::compressed_pair<move_only_type, empty_type>>);
static_assert(std::is_copy_assignable_v<entt::compressed_pair<non_default_constructible, empty_type>>);
static_assert(!std::is_copy_assignable_v<entt::compressed_pair<move_only_type, empty_type>>);
ASSERT_TRUE((std::is_copy_constructible_v<entt::compressed_pair<non_default_constructible, empty_type>>));
ASSERT_FALSE((std::is_copy_constructible_v<entt::compressed_pair<move_only_type, empty_type>>));
ASSERT_TRUE((std::is_copy_assignable_v<entt::compressed_pair<non_default_constructible, empty_type>>));
ASSERT_FALSE((std::is_copy_assignable_v<entt::compressed_pair<move_only_type, empty_type>>));
static_assert(std::is_move_constructible_v<entt::compressed_pair<move_only_type, empty_type>>);
static_assert(std::is_move_assignable_v<entt::compressed_pair<move_only_type, empty_type>>);
ASSERT_TRUE((std::is_move_constructible_v<entt::compressed_pair<move_only_type, empty_type>>));
ASSERT_TRUE((std::is_move_assignable_v<entt::compressed_pair<move_only_type, empty_type>>));
entt::compressed_pair copyable{non_default_constructible{42}, empty_type{}};
auto by_copy{copyable};
@@ -104,9 +104,9 @@ TEST(CompressedPair, DeductionGuide) {
empty_type empty{};
entt::compressed_pair pair{value, 3};
static_assert(std::is_same_v<decltype(entt::compressed_pair{empty_type{}, empty}), entt::compressed_pair<empty_type, empty_type>>);
testing::StaticAssertTypeEq<decltype(entt::compressed_pair{empty_type{}, empty}), entt::compressed_pair<empty_type, empty_type>>();
testing::StaticAssertTypeEq<decltype(pair), entt::compressed_pair<int, int>>();
ASSERT_TRUE((std::is_same_v<decltype(pair), entt::compressed_pair<int, int>>));
ASSERT_EQ(pair.first(), 42);
ASSERT_EQ(pair.second(), 3);
}
@@ -115,11 +115,11 @@ TEST(CompressedPair, Getters) {
entt::compressed_pair pair{3, empty_type{}};
const auto &cpair = pair;
static_assert(std::is_same_v<decltype(pair.first()), int &>);
static_assert(std::is_same_v<decltype(pair.second()), empty_type &>);
testing::StaticAssertTypeEq<decltype(pair.first()), int &>();
testing::StaticAssertTypeEq<decltype(pair.second()), empty_type &>();
static_assert(std::is_same_v<decltype(cpair.first()), const int &>);
static_assert(std::is_same_v<decltype(cpair.second()), const empty_type &>);
testing::StaticAssertTypeEq<decltype(cpair.first()), const int &>();
testing::StaticAssertTypeEq<decltype(cpair.second()), const empty_type &>();
ASSERT_EQ(pair.first(), cpair.first());
ASSERT_EQ(&pair.second(), &cpair.second());
@@ -169,14 +169,14 @@ TEST(CompressedPair, Get) {
ASSERT_EQ(cfirst, 3);
ASSERT_EQ(csecond, 4);
static_assert(std::is_same_v<decltype(cfirst), const int>);
static_assert(std::is_same_v<decltype(csecond), const int>);
testing::StaticAssertTypeEq<decltype(cfirst), const int>();
testing::StaticAssertTypeEq<decltype(csecond), const int>();
auto [tfirst, tsecond] = entt::compressed_pair{9, 99};
ASSERT_EQ(tfirst, 9);
ASSERT_EQ(tsecond, 99);
static_assert(std::is_same_v<decltype(cfirst), const int>);
static_assert(std::is_same_v<decltype(csecond), const int>);
testing::StaticAssertTypeEq<decltype(cfirst), const int>();
testing::StaticAssertTypeEq<decltype(csecond), const int>();
}

53
test/entt/core/hashed_string.cpp
View File

@@ -1,7 +1,6 @@
#include <cstdint>
#include <string>
#include <string_view>
#include <type_traits>
#include <gtest/gtest.h>
#include <entt/core/hashed_string.hpp>
@@ -21,8 +20,8 @@ struct expected<std::uint64_t> {
inline constexpr auto expected_v = expected<entt::id_type>::value;
TEST(BasicHashedString, DeductionGuide) {
static_assert(std::is_same_v<decltype(entt::basic_hashed_string{"foo"}), entt::hashed_string>);
static_assert(std::is_same_v<decltype(entt::basic_hashed_string{L"foo"}), entt::hashed_wstring>);
testing::StaticAssertTypeEq<decltype(entt::basic_hashed_string{"foo"}), entt::hashed_string>();
testing::StaticAssertTypeEq<decltype(entt::basic_hashed_string{L"foo"}), entt::hashed_wstring>();
}
TEST(HashedString, Functionalities) {
@@ -110,23 +109,23 @@ TEST(HashedString, Constexprness) {
using namespace entt::literals;
constexpr std::string_view view{"foobar__", 6};
static_assert(entt::hashed_string{"quux"} == "quux"_hs);
static_assert(entt::hashed_string{"foobar"} == expected_v);
ASSERT_EQ(entt::hashed_string{"quux"}, "quux"_hs);
ASSERT_EQ(entt::hashed_string{"foobar"}, expected_v);
static_assert(entt::hashed_string::value("quux") == "quux"_hs);
static_assert(entt::hashed_string::value("foobar") == expected_v);
ASSERT_EQ(entt::hashed_string::value("quux"), "quux"_hs);
ASSERT_EQ(entt::hashed_string::value("foobar"), expected_v);
static_assert(entt::hashed_string{"quux", 4} == "quux"_hs);
static_assert(entt::hashed_string{view.data(), view.size()} == expected_v);
ASSERT_EQ((entt::hashed_string{"quux", 4}), "quux"_hs);
ASSERT_EQ((entt::hashed_string{view.data(), view.size()}), expected_v);
static_assert(entt::hashed_string::value("quux", 4) == "quux"_hs);
static_assert(entt::hashed_string::value(view.data(), view.size()) == expected_v);
ASSERT_EQ((entt::hashed_string::value("quux", 4)), "quux"_hs);
ASSERT_EQ((entt::hashed_string::value(view.data(), view.size())), expected_v);
static_assert(entt::hashed_string{"bar"} < "foo"_hs);
static_assert(entt::hashed_string{"bar"} <= "bar"_hs);
ASSERT_LT(entt::hashed_string{"bar"}, "foo"_hs);
ASSERT_LE(entt::hashed_string{"bar"}, "bar"_hs);
static_assert(entt::hashed_string{"foo"} > "bar"_hs);
static_assert(entt::hashed_string{"foo"} >= "foo"_hs);
ASSERT_GT(entt::hashed_string{"foo"}, "bar"_hs);
ASSERT_GE(entt::hashed_string{"foo"}, "foo"_hs);
}
TEST(HashedWString, Functionalities) {
@@ -204,21 +203,21 @@ TEST(HashedWString, Constexprness) {
using namespace entt::literals;
constexpr std::wstring_view view{L"foobar__", 6};
static_assert(entt::hashed_wstring{L"quux"} == L"quux"_hws);
static_assert(entt::hashed_wstring{L"foobar"} == expected_v);
ASSERT_EQ(entt::hashed_wstring{L"quux"}, L"quux"_hws);
ASSERT_EQ(entt::hashed_wstring{L"foobar"}, expected_v);
static_assert(entt::hashed_wstring::value(L"quux") == L"quux"_hws);
static_assert(entt::hashed_wstring::value(L"foobar") == expected_v);
ASSERT_EQ(entt::hashed_wstring::value(L"quux"), L"quux"_hws);
ASSERT_EQ(entt::hashed_wstring::value(L"foobar"), expected_v);
static_assert(entt::hashed_wstring{L"quux", 4} == L"quux"_hws);
static_assert(entt::hashed_wstring{view.data(), view.size()} == expected_v);
ASSERT_EQ((entt::hashed_wstring{L"quux", 4}), L"quux"_hws);
ASSERT_EQ((entt::hashed_wstring{view.data(), view.size()}), expected_v);
static_assert(entt::hashed_wstring::value(L"quux", 4) == L"quux"_hws);
static_assert(entt::hashed_wstring::value(view.data(), view.size()) == expected_v);
ASSERT_EQ((entt::hashed_wstring::value(L"quux", 4)), L"quux"_hws);
ASSERT_EQ((entt::hashed_wstring::value(view.data(), view.size())), expected_v);
static_assert(entt::hashed_wstring{L"bar"} < L"foo"_hws);
static_assert(entt::hashed_wstring{L"bar"} <= L"bar"_hws);
ASSERT_LT(entt::hashed_wstring{L"bar"}, L"foo"_hws);
ASSERT_LE(entt::hashed_wstring{L"bar"}, L"bar"_hws);
static_assert(entt::hashed_wstring{L"foo"} > L"bar"_hws);
static_assert(entt::hashed_wstring{L"foo"} >= L"foo"_hws);
ASSERT_GT(entt::hashed_wstring{L"foo"}, L"bar"_hws);
ASSERT_GE(entt::hashed_wstring{L"foo"}, L"foo"_hws);
}

38
test/entt/core/memory.cpp
View File

@@ -133,9 +133,8 @@ TEST(UsesAllocatorConstructionArgs, NoUsesAllocatorConstruction) {
const auto value = 42;
const auto args = entt::uses_allocator_construction_args<int>(std::allocator<int>{}, value);
static_assert(std::tuple_size_v<decltype(args)> == 1u);
static_assert(std::is_same_v<decltype(args), const std::tuple<const int &>>);
ASSERT_EQ(std::tuple_size_v<decltype(args)>, 1u);
testing::StaticAssertTypeEq<decltype(args), const std::tuple<const int &>>();
ASSERT_EQ(std::get<0>(args), value);
}
@@ -143,9 +142,8 @@ TEST(UsesAllocatorConstructionArgs, LeadingAllocatorConvention) {
const auto value = 42;
const auto args = entt::uses_allocator_construction_args<std::tuple<int, char>>(std::allocator<int>{}, value, 'c');
static_assert(std::tuple_size_v<decltype(args)> == 4u);
static_assert(std::is_same_v<decltype(args), const std::tuple<std::allocator_arg_t, const std::allocator<int> &, const int &, char &&>>);
ASSERT_EQ(std::tuple_size_v<decltype(args)>, 4u);
testing::StaticAssertTypeEq<decltype(args), const std::tuple<std::allocator_arg_t, const std::allocator<int> &, const int &, char &&>>();
ASSERT_EQ(std::get<2>(args), value);
}
@@ -153,9 +151,8 @@ TEST(UsesAllocatorConstructionArgs, TrailingAllocatorConvention) {
const auto size = 42u;
const auto args = entt::uses_allocator_construction_args<std::vector<int>>(std::allocator<int>{}, size);
static_assert(std::tuple_size_v<decltype(args)> == 2u);
static_assert(std::is_same_v<decltype(args), const std::tuple<const unsigned int &, const std::allocator<int> &>>);
ASSERT_EQ(std::tuple_size_v<decltype(args)>, 2u);
testing::StaticAssertTypeEq<decltype(args), const std::tuple<const unsigned int &, const std::allocator<int> &>>();
ASSERT_EQ(std::get<0>(args), size);
}
@@ -164,26 +161,24 @@ TEST(UsesAllocatorConstructionArgs, PairPiecewiseConstruct) {
const auto tup = std::make_tuple(size);
const auto args = entt::uses_allocator_construction_args<std::pair<int, std::vector<int>>>(std::allocator<int>{}, std::piecewise_construct, std::make_tuple(3), tup);
static_assert(std::tuple_size_v<decltype(args)> == 3u);
static_assert(std::is_same_v<decltype(args), const std::tuple<std::piecewise_construct_t, std::tuple<int &&>, std::tuple<const unsigned int &, const std::allocator<int> &>>>);
ASSERT_EQ(std::tuple_size_v<decltype(args)>, 3u);
testing::StaticAssertTypeEq<decltype(args), const std::tuple<std::piecewise_construct_t, std::tuple<int &&>, std::tuple<const unsigned int &, const std::allocator<int> &>>>();
ASSERT_EQ(std::get<0>(std::get<2>(args)), size);
}
TEST(UsesAllocatorConstructionArgs, PairNoArgs) {
[[maybe_unused]] const auto args = entt::uses_allocator_construction_args<std::pair<int, std::vector<int>>>(std::allocator<int>{});
static_assert(std::tuple_size_v<decltype(args)> == 3u);
static_assert(std::is_same_v<decltype(args), const std::tuple<std::piecewise_construct_t, std::tuple<>, std::tuple<const std::allocator<int> &>>>);
ASSERT_EQ(std::tuple_size_v<decltype(args)>, 3u);
testing::StaticAssertTypeEq<decltype(args), const std::tuple<std::piecewise_construct_t, std::tuple<>, std::tuple<const std::allocator<int> &>>>();
}
TEST(UsesAllocatorConstructionArgs, PairValues) {
const auto size = 42u;
const auto args = entt::uses_allocator_construction_args<std::pair<int, std::vector<int>>>(std::allocator<int>{}, 3, size);
static_assert(std::tuple_size_v<decltype(args)> == 3u);
static_assert(std::is_same_v<decltype(args), const std::tuple<std::piecewise_construct_t, std::tuple<int &&>, std::tuple<const unsigned int &, const std::allocator<int> &>>>);
ASSERT_EQ(std::tuple_size_v<decltype(args)>, 3u);
testing::StaticAssertTypeEq<decltype(args), const std::tuple<std::piecewise_construct_t, std::tuple<int &&>, std::tuple<const unsigned int &, const std::allocator<int> &>>>();
ASSERT_EQ(std::get<0>(std::get<2>(args)), size);
}
@@ -191,9 +186,8 @@ TEST(UsesAllocatorConstructionArgs, PairConstLValueReference) {
const auto value = std::make_pair(3, 42u);
const auto args = entt::uses_allocator_construction_args<std::pair<int, std::vector<int>>>(std::allocator<int>{}, value);
static_assert(std::tuple_size_v<decltype(args)> == 3u);
static_assert(std::is_same_v<decltype(args), const std::tuple<std::piecewise_construct_t, std::tuple<const int &>, std::tuple<const unsigned int &, const std::allocator<int> &>>>);
ASSERT_EQ(std::tuple_size_v<decltype(args)>, 3u);
testing::StaticAssertTypeEq<decltype(args), const std::tuple<std::piecewise_construct_t, std::tuple<const int &>, std::tuple<const unsigned int &, const std::allocator<int> &>>>();
ASSERT_EQ(std::get<0>(std::get<1>(args)), 3);
ASSERT_EQ(std::get<0>(std::get<2>(args)), 42u);
}
@@ -201,8 +195,8 @@ TEST(UsesAllocatorConstructionArgs, PairConstLValueReference) {
TEST(UsesAllocatorConstructionArgs, PairRValueReference) {
[[maybe_unused]] const auto args = entt::uses_allocator_construction_args<std::pair<int, std::vector<int>>>(std::allocator<int>{}, std::make_pair(3, 42u));
static_assert(std::tuple_size_v<decltype(args)> == 3u);
static_assert(std::is_same_v<decltype(args), const std::tuple<std::piecewise_construct_t, std::tuple<int &&>, std::tuple<unsigned int &&, const std::allocator<int> &>>>);
ASSERT_EQ(std::tuple_size_v<decltype(args)>, 3u);
testing::StaticAssertTypeEq<decltype(args), const std::tuple<std::piecewise_construct_t, std::tuple<int &&>, std::tuple<unsigned int &&, const std::allocator<int> &>>>();
}
TEST(MakeObjUsingAllocator, Functionalities) {

27
test/entt/core/tuple.cpp
View File

@@ -1,12 +1,13 @@
#include <tuple>
#include <utility>
#include <gtest/gtest.h>
#include <entt/core/tuple.hpp>
TEST(Tuple, IsTuple) {
static_assert(!entt::is_tuple_v<int>);
static_assert(entt::is_tuple_v<std::tuple<>>);
static_assert(entt::is_tuple_v<std::tuple<int>>);
static_assert(entt::is_tuple_v<std::tuple<int, char>>);
ASSERT_FALSE(entt::is_tuple_v<int>);
ASSERT_TRUE(entt::is_tuple_v<std::tuple<>>);
ASSERT_TRUE(entt::is_tuple_v<std::tuple<int>>);
ASSERT_TRUE((entt::is_tuple_v<std::tuple<int, char>>));
}
TEST(Tuple, UnwrapTuple) {
@@ -14,17 +15,17 @@ TEST(Tuple, UnwrapTuple) {
auto multi = std::make_tuple(42, 'c');
auto ref = std::forward_as_tuple(std::get<0>(single));
ASSERT_TRUE((std::is_same_v<decltype(entt::unwrap_tuple(single)), int &>));
ASSERT_TRUE((std::is_same_v<decltype(entt::unwrap_tuple(multi)), std::tuple<int, char> &>));
ASSERT_TRUE((std::is_same_v<decltype(entt::unwrap_tuple(ref)), int &>));
testing::StaticAssertTypeEq<decltype(entt::unwrap_tuple(single)), int &>();
testing::StaticAssertTypeEq<decltype(entt::unwrap_tuple(multi)), std::tuple<int, char> &>();
testing::StaticAssertTypeEq<decltype(entt::unwrap_tuple(ref)), int &>();
ASSERT_TRUE((std::is_same_v<decltype(entt::unwrap_tuple(std::move(single))), int &&>));
ASSERT_TRUE((std::is_same_v<decltype(entt::unwrap_tuple(std::move(multi))), std::tuple<int, char> &&>));
ASSERT_TRUE((std::is_same_v<decltype(entt::unwrap_tuple(std::move(ref))), int &>));
testing::StaticAssertTypeEq<decltype(entt::unwrap_tuple(std::move(single))), int &&>();
testing::StaticAssertTypeEq<decltype(entt::unwrap_tuple(std::move(multi))), std::tuple<int, char> &&>();
testing::StaticAssertTypeEq<decltype(entt::unwrap_tuple(std::move(ref))), int &>();
ASSERT_TRUE((std::is_same_v<decltype(entt::unwrap_tuple(std::as_const(single))), const int &>));
ASSERT_TRUE((std::is_same_v<decltype(entt::unwrap_tuple(std::as_const(multi))), const std::tuple<int, char> &>));
ASSERT_TRUE((std::is_same_v<decltype(entt::unwrap_tuple(std::as_const(ref))), int &>));
testing::StaticAssertTypeEq<decltype(entt::unwrap_tuple(std::as_const(single))), const int &>();
testing::StaticAssertTypeEq<decltype(entt::unwrap_tuple(std::as_const(multi))), const std::tuple<int, char> &>();
testing::StaticAssertTypeEq<decltype(entt::unwrap_tuple(std::as_const(ref))), int &>();
ASSERT_EQ(entt::unwrap_tuple(single), 42);
ASSERT_EQ(entt::unwrap_tuple(multi), multi);

8
test/entt/core/type_info.cpp
View File

@@ -42,10 +42,10 @@ TEST(TypeName, Functionalities) {
}
TEST(TypeInfo, Functionalities) {
static_assert(std::is_copy_constructible_v<entt::type_info>);
static_assert(std::is_move_constructible_v<entt::type_info>);
static_assert(std::is_copy_assignable_v<entt::type_info>);
static_assert(std::is_move_assignable_v<entt::type_info>);
ASSERT_TRUE(std::is_copy_constructible_v<entt::type_info>);
ASSERT_TRUE(std::is_move_constructible_v<entt::type_info>);
ASSERT_TRUE(std::is_copy_assignable_v<entt::type_info>);
ASSERT_TRUE(std::is_move_assignable_v<entt::type_info>);
entt::type_info info{std::in_place_type<int>};
entt::type_info other{std::in_place_type<void>};

242
test/entt/core/type_traits.cpp
View File

@@ -42,10 +42,10 @@ struct multi_argument_operation {
};
TEST(SizeOf, Functionalities) {
static_assert(entt::size_of_v<void> == 0u);
static_assert(entt::size_of_v<char> == sizeof(char));
static_assert(entt::size_of_v<int[]> == 0u);
static_assert(entt::size_of_v<int[3]> == sizeof(int[3]));
ASSERT_EQ(entt::size_of_v<void>, 0u);
ASSERT_EQ(entt::size_of_v<char>, sizeof(char));
ASSERT_EQ(entt::size_of_v<int[]>, 0u);
ASSERT_EQ(entt::size_of_v<int[3]>, sizeof(int[3]));
}
TEST(UnpackAsType, Functionalities) {
@@ -69,188 +69,188 @@ TEST(UnpackAsValue, Functionalities) {
TEST(IntegralConstant, Functionalities) {
entt::integral_constant<3> constant{};
static_assert(std::is_same_v<typename entt::integral_constant<3>::value_type, int>);
static_assert(constant.value == 3);
testing::StaticAssertTypeEq<typename entt::integral_constant<3>::value_type, int>();
ASSERT_EQ(constant.value, 3);
}
TEST(Choice, Functionalities) {
static_assert(std::is_base_of_v<entt::choice_t<0>, entt::choice_t<1>>);
static_assert(!std::is_base_of_v<entt::choice_t<1>, entt::choice_t<0>>);
ASSERT_TRUE((std::is_base_of_v<entt::choice_t<0>, entt::choice_t<1>>));
ASSERT_FALSE((std::is_base_of_v<entt::choice_t<1>, entt::choice_t<0>>));
}
TEST(TypeList, Functionalities) {
using type = entt::type_list<int, char>;
using other = entt::type_list<double>;
static_assert(type::size == 2u);
static_assert(other::size == 1u);
ASSERT_EQ(type::size, 2u);
ASSERT_EQ(other::size, 1u);
static_assert(std::is_same_v<decltype(type{} + other{}), entt::type_list<int, char, double>>);
static_assert(std::is_same_v<entt::type_list_cat_t<type, other, type, other>, entt::type_list<int, char, double, int, char, double>>);
static_assert(std::is_same_v<entt::type_list_cat_t<type, other>, entt::type_list<int, char, double>>);
static_assert(std::is_same_v<entt::type_list_cat_t<type, type>, entt::type_list<int, char, int, char>>);
static_assert(std::is_same_v<entt::type_list_unique_t<entt::type_list_cat_t<type, type>>, type>);
testing::StaticAssertTypeEq<decltype(type{} + other{}), entt::type_list<int, char, double>>();
testing::StaticAssertTypeEq<entt::type_list_cat_t<type, other, type, other>, entt::type_list<int, char, double, int, char, double>>();
testing::StaticAssertTypeEq<entt::type_list_cat_t<type, other>, entt::type_list<int, char, double>>();
testing::StaticAssertTypeEq<entt::type_list_cat_t<type, type>, entt::type_list<int, char, int, char>>();
testing::StaticAssertTypeEq<entt::type_list_unique_t<entt::type_list_cat_t<type, type>>, type>();
static_assert(entt::type_list_contains_v<type, int>);
static_assert(entt::type_list_contains_v<type, char>);
static_assert(!entt::type_list_contains_v<type, double>);
ASSERT_TRUE((entt::type_list_contains_v<type, int>));
ASSERT_TRUE((entt::type_list_contains_v<type, char>));
ASSERT_FALSE((entt::type_list_contains_v<type, double>));
static_assert(std::is_same_v<entt::type_list_element_t<0u, type>, int>);
static_assert(std::is_same_v<entt::type_list_element_t<1u, type>, char>);
static_assert(std::is_same_v<entt::type_list_element_t<0u, other>, double>);
testing::StaticAssertTypeEq<entt::type_list_element_t<0u, type>, int>();
testing::StaticAssertTypeEq<entt::type_list_element_t<1u, type>, char>();
testing::StaticAssertTypeEq<entt::type_list_element_t<0u, other>, double>();
static_assert(entt::type_list_index_v<int, type> == 0u);
static_assert(entt::type_list_index_v<char, type> == 1u);
static_assert(entt::type_list_index_v<double, other> == 0u);
ASSERT_EQ((entt::type_list_index_v<int, type>), 0u);
ASSERT_EQ((entt::type_list_index_v<char, type>), 1u);
ASSERT_EQ((entt::type_list_index_v<double, other>), 0u);
static_assert(std::is_same_v<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<float, bool>>, entt::type_list<int, char, double>>);
static_assert(std::is_same_v<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<int, char, double>>, entt::type_list<>>);
static_assert(std::is_same_v<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<int, char>>, entt::type_list<double>>);
static_assert(std::is_same_v<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<char, double>>, entt::type_list<int>>);
static_assert(std::is_same_v<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<char>>, entt::type_list<int, double>>);
testing::StaticAssertTypeEq<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<float, bool>>, entt::type_list<int, char, double>>();
testing::StaticAssertTypeEq<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<int, char, double>>, entt::type_list<>>();
testing::StaticAssertTypeEq<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<int, char>>, entt::type_list<double>>();
testing::StaticAssertTypeEq<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<char, double>>, entt::type_list<int>>();
testing::StaticAssertTypeEq<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<char>>, entt::type_list<int, double>>();
static_assert(std::is_same_v<entt::type_list_transform_t<entt::type_list<int, char>, entt::type_identity>, entt::type_list<int, char>>);
static_assert(std::is_same_v<entt::type_list_transform_t<entt::type_list<int, char>, std::add_const>, entt::type_list<const int, const char>>);
static_assert(std::is_same_v<entt::type_list_transform_t<entt::type_list<int, char>, multi_argument_operation>, entt::type_list<void, void>>);
testing::StaticAssertTypeEq<entt::type_list_transform_t<entt::type_list<int, char>, entt::type_identity>, entt::type_list<int, char>>();
testing::StaticAssertTypeEq<entt::type_list_transform_t<entt::type_list<int, char>, std::add_const>, entt::type_list<const int, const char>>();
testing::StaticAssertTypeEq<entt::type_list_transform_t<entt::type_list<int, char>, multi_argument_operation>, entt::type_list<void, void>>();
static_assert(std::tuple_size_v<entt::type_list<>> == 0u);
static_assert(std::tuple_size_v<entt::type_list<int>> == 1u);
static_assert(std::tuple_size_v<entt::type_list<int, float>> == 2u);
ASSERT_EQ(std::tuple_size_v<entt::type_list<>>, 0u);
ASSERT_EQ(std::tuple_size_v<entt::type_list<int>>, 1u);
ASSERT_EQ((std::tuple_size_v<entt::type_list<int, float>>), 2u);
static_assert(std::is_same_v<int, std::tuple_element_t<0, entt::type_list<int>>>);
static_assert(std::is_same_v<int, std::tuple_element_t<0, entt::type_list<int, float>>>);
static_assert(std::is_same_v<float, std::tuple_element_t<1, entt::type_list<int, float>>>);
testing::StaticAssertTypeEq<int, std::tuple_element_t<0, entt::type_list<int>>>();
testing::StaticAssertTypeEq<int, std::tuple_element_t<0, entt::type_list<int, float>>>();
testing::StaticAssertTypeEq<float, std::tuple_element_t<1, entt::type_list<int, float>>>();
}
TEST(ValueList, Functionalities) {
using value = entt::value_list<0, 2>;
using other = entt::value_list<1>;
static_assert(value::size == 2u);
static_assert(other::size == 1u);
ASSERT_EQ(value::size, 2u);
ASSERT_EQ(other::size, 1u);
static_assert(std::is_same_v<decltype(value{} + other{}), entt::value_list<0, 2, 1>>);
static_assert(std::is_same_v<entt::value_list_cat_t<value, other, value, other>, entt::value_list<0, 2, 1, 0, 2, 1>>);
static_assert(std::is_same_v<entt::value_list_cat_t<value, other>, entt::value_list<0, 2, 1>>);
static_assert(std::is_same_v<entt::value_list_cat_t<value, value>, entt::value_list<0, 2, 0, 2>>);
static_assert(std::is_same_v<entt::value_list_unique_t<entt::value_list_cat_t<value, value>>, value>);
testing::StaticAssertTypeEq<decltype(value{} + other{}), entt::value_list<0, 2, 1>>();
testing::StaticAssertTypeEq<entt::value_list_cat_t<value, other, value, other>, entt::value_list<0, 2, 1, 0, 2, 1>>();
testing::StaticAssertTypeEq<entt::value_list_cat_t<value, other>, entt::value_list<0, 2, 1>>();
testing::StaticAssertTypeEq<entt::value_list_cat_t<value, value>, entt::value_list<0, 2, 0, 2>>();
testing::StaticAssertTypeEq<entt::value_list_unique_t<entt::value_list_cat_t<value, value>>, value>();
static_assert(entt::value_list_contains_v<value, 0>);
static_assert(entt::value_list_contains_v<value, 2>);
static_assert(!entt::value_list_contains_v<value, 1>);
ASSERT_TRUE((entt::value_list_contains_v<value, 0>));
ASSERT_TRUE((entt::value_list_contains_v<value, 2>));
ASSERT_FALSE((entt::value_list_contains_v<value, 1>));
static_assert(entt::value_list_element_v<0u, value> == 0);
static_assert(entt::value_list_element_v<1u, value> == 2);
static_assert(entt::value_list_element_v<0u, other> == 1);
ASSERT_EQ((entt::value_list_element_v<0u, value>), 0);
ASSERT_EQ((entt::value_list_element_v<1u, value>), 2);
ASSERT_EQ((entt::value_list_element_v<0u, other>), 1);
static_assert(entt::value_list_index_v<0, value> == 0u);
static_assert(entt::value_list_index_v<2, value> == 1u);
static_assert(entt::value_list_index_v<1, other> == 0u);
ASSERT_EQ((entt::value_list_index_v<0, value>), 0u);
ASSERT_EQ((entt::value_list_index_v<2, value>), 1u);
ASSERT_EQ((entt::value_list_index_v<1, other>), 0u);
static_assert(std::is_same_v<entt::value_list_diff_t<entt::value_list<0, 1, 2>, entt::value_list<3, 4>>, entt::value_list<0, 1, 2>>);
static_assert(std::is_same_v<entt::value_list_diff_t<entt::value_list<0, 1, 2>, entt::value_list<0, 1, 2>>, entt::value_list<>>);
static_assert(std::is_same_v<entt::value_list_diff_t<entt::value_list<0, 1, 2>, entt::value_list<0, 1>>, entt::value_list<2>>);
static_assert(std::is_same_v<entt::value_list_diff_t<entt::value_list<0, 1, 2>, entt::value_list<1, 2>>, entt::value_list<0>>);
static_assert(std::is_same_v<entt::value_list_diff_t<entt::value_list<0, 1, 2>, entt::value_list<1>>, entt::value_list<0, 2>>);
testing::StaticAssertTypeEq<entt::value_list_diff_t<entt::value_list<0, 1, 2>, entt::value_list<3, 4>>, entt::value_list<0, 1, 2>>();
testing::StaticAssertTypeEq<entt::value_list_diff_t<entt::value_list<0, 1, 2>, entt::value_list<0, 1, 2>>, entt::value_list<>>();
testing::StaticAssertTypeEq<entt::value_list_diff_t<entt::value_list<0, 1, 2>, entt::value_list<0, 1>>, entt::value_list<2>>();
testing::StaticAssertTypeEq<entt::value_list_diff_t<entt::value_list<0, 1, 2>, entt::value_list<1, 2>>, entt::value_list<0>>();
testing::StaticAssertTypeEq<entt::value_list_diff_t<entt::value_list<0, 1, 2>, entt::value_list<1>>, entt::value_list<0, 2>>();
static_assert(std::tuple_size_v<entt::value_list<>> == 0u);
static_assert(std::tuple_size_v<entt::value_list<42>> == 1u);
static_assert(std::tuple_size_v<entt::value_list<42, 'a'>> == 2u);
ASSERT_EQ((std::tuple_size_v<entt::value_list<>>), 0u);
ASSERT_EQ((std::tuple_size_v<entt::value_list<42>>), 1u);
ASSERT_EQ((std::tuple_size_v<entt::value_list<42, 'a'>>), 2u);
static_assert(std::is_same_v<int, std::tuple_element_t<0, entt::value_list<42>>>);
static_assert(std::is_same_v<int, std::tuple_element_t<0, entt::value_list<42, 'a'>>>);
static_assert(std::is_same_v<char, std::tuple_element_t<1, entt::value_list<42, 'a'>>>);
testing::StaticAssertTypeEq<int, std::tuple_element_t<0, entt::value_list<42>>>();
testing::StaticAssertTypeEq<int, std::tuple_element_t<0, entt::value_list<42, 'a'>>>();
testing::StaticAssertTypeEq<char, std::tuple_element_t<1, entt::value_list<42, 'a'>>>();
}
TEST(IsApplicable, Functionalities) {
static_assert(entt::is_applicable_v<void(int, char), std::tuple<double, char>>);
static_assert(!entt::is_applicable_v<void(int, char), std::tuple<int>>);
ASSERT_TRUE((entt::is_applicable_v<void(int, char), std::tuple<double, char>>));
ASSERT_FALSE((entt::is_applicable_v<void(int, char), std::tuple<int>>));
static_assert(entt::is_applicable_r_v<float, int(int, char), std::tuple<double, char>>);
static_assert(!entt::is_applicable_r_v<float, void(int, char), std::tuple<double, char>>);
static_assert(!entt::is_applicable_r_v<int, int(int, char), std::tuple<void>>);
ASSERT_TRUE((entt::is_applicable_r_v<float, int(int, char), std::tuple<double, char>>));
ASSERT_FALSE((entt::is_applicable_r_v<float, void(int, char), std::tuple<double, char>>));
ASSERT_FALSE((entt::is_applicable_r_v<int, int(int, char), std::tuple<void>>));
}
TEST(IsComplete, Functionalities) {
static_assert(!entt::is_complete_v<void>);
static_assert(entt::is_complete_v<int>);
ASSERT_FALSE(entt::is_complete_v<void>);
ASSERT_TRUE(entt::is_complete_v<int>);
}
TEST(IsIterator, Functionalities) {
static_assert(!entt::is_iterator_v<void>);
static_assert(!entt::is_iterator_v<int>);
ASSERT_FALSE(entt::is_iterator_v<void>);
ASSERT_FALSE(entt::is_iterator_v<int>);
static_assert(!entt::is_iterator_v<void *>);
static_assert(entt::is_iterator_v<int *>);
ASSERT_FALSE(entt::is_iterator_v<void *>);
ASSERT_TRUE(entt::is_iterator_v<int *>);
static_assert(entt::is_iterator_v<std::vector<int>::iterator>);
static_assert(entt::is_iterator_v<std::vector<int>::const_iterator>);
static_assert(entt::is_iterator_v<std::vector<int>::reverse_iterator>);
ASSERT_TRUE(entt::is_iterator_v<std::vector<int>::iterator>);
ASSERT_TRUE(entt::is_iterator_v<std::vector<int>::const_iterator>);
ASSERT_TRUE(entt::is_iterator_v<std::vector<int>::reverse_iterator>);
}
TEST(IsEBCOEligible, Functionalities) {
static_assert(entt::is_ebco_eligible_v<not_comparable>);
static_assert(!entt::is_ebco_eligible_v<nlohmann_json_like>);
static_assert(!entt::is_ebco_eligible_v<double>);
static_assert(!entt::is_ebco_eligible_v<void>);
ASSERT_TRUE(entt::is_ebco_eligible_v<not_comparable>);
ASSERT_FALSE(entt::is_ebco_eligible_v<nlohmann_json_like>);
ASSERT_FALSE(entt::is_ebco_eligible_v<double>);
ASSERT_FALSE(entt::is_ebco_eligible_v<void>);
}
TEST(IsTransparent, Functionalities) {
static_assert(!entt::is_transparent_v<std::less<int>>);
static_assert(entt::is_transparent_v<std::less<void>>);
static_assert(!entt::is_transparent_v<std::logical_not<double>>);
static_assert(entt::is_transparent_v<std::logical_not<void>>);
ASSERT_FALSE(entt::is_transparent_v<std::less<int>>);
ASSERT_TRUE(entt::is_transparent_v<std::less<void>>);
ASSERT_FALSE(entt::is_transparent_v<std::logical_not<double>>);
ASSERT_TRUE(entt::is_transparent_v<std::logical_not<void>>);
}
TEST(IsEqualityComparable, Functionalities) {
static_assert(entt::is_equality_comparable_v<int>);
static_assert(entt::is_equality_comparable_v<const int>);
static_assert(entt::is_equality_comparable_v<std::vector<int>>);
static_assert(entt::is_equality_comparable_v<std::vector<std::vector<int>>>);
static_assert(entt::is_equality_comparable_v<std::unordered_map<int, int>>);
static_assert(entt::is_equality_comparable_v<std::unordered_map<int, std::unordered_map<int, char>>>);
static_assert(entt::is_equality_comparable_v<std::pair<const int, int>>);
static_assert(entt::is_equality_comparable_v<std::pair<const int, std::unordered_map<int, char>>>);
static_assert(entt::is_equality_comparable_v<std::vector<not_comparable>::iterator>);
static_assert(entt::is_equality_comparable_v<nlohmann_json_like>);
ASSERT_TRUE(entt::is_equality_comparable_v<int>);
ASSERT_TRUE(entt::is_equality_comparable_v<const int>);
ASSERT_TRUE(entt::is_equality_comparable_v<std::vector<int>>);
ASSERT_TRUE(entt::is_equality_comparable_v<std::vector<std::vector<int>>>);
ASSERT_TRUE((entt::is_equality_comparable_v<std::unordered_map<int, int>>));
ASSERT_TRUE((entt::is_equality_comparable_v<std::unordered_map<int, std::unordered_map<int, char>>>));
ASSERT_TRUE((entt::is_equality_comparable_v<std::pair<const int, int>>));
ASSERT_TRUE((entt::is_equality_comparable_v<std::pair<const int, std::unordered_map<int, char>>>));
ASSERT_TRUE(entt::is_equality_comparable_v<std::vector<not_comparable>::iterator>);
ASSERT_TRUE(entt::is_equality_comparable_v<nlohmann_json_like>);
static_assert(!entt::is_equality_comparable_v<int[3u]>);
static_assert(!entt::is_equality_comparable_v<not_comparable>);
static_assert(!entt::is_equality_comparable_v<const not_comparable>);
static_assert(!entt::is_equality_comparable_v<std::vector<not_comparable>>);
static_assert(!entt::is_equality_comparable_v<std::vector<std::vector<not_comparable>>>);
static_assert(!entt::is_equality_comparable_v<std::unordered_map<int, not_comparable>>);
static_assert(!entt::is_equality_comparable_v<std::unordered_map<int, std::unordered_map<int, not_comparable>>>);
static_assert(!entt::is_equality_comparable_v<std::pair<const int, not_comparable>>);
static_assert(!entt::is_equality_comparable_v<std::pair<const int, std::unordered_map<int, not_comparable>>>);
static_assert(!entt::is_equality_comparable_v<void>);
ASSERT_FALSE(entt::is_equality_comparable_v<int[3u]>);
ASSERT_FALSE(entt::is_equality_comparable_v<not_comparable>);
ASSERT_FALSE(entt::is_equality_comparable_v<const not_comparable>);
ASSERT_FALSE(entt::is_equality_comparable_v<std::vector<not_comparable>>);
ASSERT_FALSE(entt::is_equality_comparable_v<std::vector<std::vector<not_comparable>>>);
ASSERT_FALSE((entt::is_equality_comparable_v<std::unordered_map<int, not_comparable>>));
ASSERT_FALSE((entt::is_equality_comparable_v<std::unordered_map<int, std::unordered_map<int, not_comparable>>>));
ASSERT_FALSE((entt::is_equality_comparable_v<std::pair<const int, not_comparable>>));
ASSERT_FALSE((entt::is_equality_comparable_v<std::pair<const int, std::unordered_map<int, not_comparable>>>));
ASSERT_FALSE(entt::is_equality_comparable_v<void>);
}
TEST(ConstnessAs, Functionalities) {
static_assert(std::is_same_v<entt::constness_as_t<int, char>, int>);
static_assert(std::is_same_v<entt::constness_as_t<const int, char>, int>);
static_assert(std::is_same_v<entt::constness_as_t<int, const char>, const int>);
static_assert(std::is_same_v<entt::constness_as_t<const int, const char>, const int>);
testing::StaticAssertTypeEq<entt::constness_as_t<int, char>, int>();
testing::StaticAssertTypeEq<entt::constness_as_t<const int, char>, int>();
testing::StaticAssertTypeEq<entt::constness_as_t<int, const char>, const int>();
testing::StaticAssertTypeEq<entt::constness_as_t<const int, const char>, const int>();
}
TEST(MemberClass, Functionalities) {
static_assert(std::is_same_v<clazz, entt::member_class_t<decltype(&clazz::foo)>>);
static_assert(std::is_same_v<clazz, entt::member_class_t<decltype(&clazz::bar)>>);
static_assert(std::is_same_v<clazz, entt::member_class_t<decltype(&clazz::quux)>>);
testing::StaticAssertTypeEq<clazz, entt::member_class_t<decltype(&clazz::foo)>>();
testing::StaticAssertTypeEq<clazz, entt::member_class_t<decltype(&clazz::bar)>>();
testing::StaticAssertTypeEq<clazz, entt::member_class_t<decltype(&clazz::quux)>>();
}
TEST(NthArgument, Functionalities) {
static_assert(std::is_same_v<entt::nth_argument_t<0u, &free_function>, int>);
static_assert(std::is_same_v<entt::nth_argument_t<1u, &free_function>, const double &>);
static_assert(std::is_same_v<entt::nth_argument_t<0u, &clazz::bar>, double>);
static_assert(std::is_same_v<entt::nth_argument_t<1u, &clazz::bar>, float>);
static_assert(std::is_same_v<entt::nth_argument_t<0u, &clazz::quux>, bool>);
testing::StaticAssertTypeEq<entt::nth_argument_t<0u, &free_function>, int>();
testing::StaticAssertTypeEq<entt::nth_argument_t<1u, &free_function>, const double &>();
testing::StaticAssertTypeEq<entt::nth_argument_t<0u, &clazz::bar>, double>();
testing::StaticAssertTypeEq<entt::nth_argument_t<1u, &clazz::bar>, float>();
testing::StaticAssertTypeEq<entt::nth_argument_t<0u, &clazz::quux>, bool>();
ASSERT_EQ(free_function(entt::nth_argument_t<0u, &free_function>{}, entt::nth_argument_t<1u, &free_function>{}), 42);
}
TEST(Tag, Functionalities) {
using namespace entt::literals;
static_assert(entt::tag<"foobar"_hs>::value == entt::hashed_string::value("foobar"));
static_assert(std::is_same_v<typename entt::tag<"foobar"_hs>::value_type, entt::id_type>);
ASSERT_EQ(entt::tag<"foobar"_hs>::value, entt::hashed_string::value("foobar"));
testing::StaticAssertTypeEq<typename entt::tag<"foobar"_hs>::value_type, entt::id_type>();
}

24
test/entt/entity/component.cpp
View File

@@ -32,41 +32,41 @@ struct entt::component_traits<traits_based> {
TEST(Component, VoidType) {
using traits_type = entt::component_traits<void>;
static_assert(!traits_type::in_place_delete);
static_assert(traits_type::page_size == 0u);
ASSERT_FALSE(traits_type::in_place_delete);
ASSERT_EQ(traits_type::page_size, 0u);
}
TEST(Component, Empty) {
using traits_type = entt::component_traits<empty>;
static_assert(!traits_type::in_place_delete);
static_assert(traits_type::page_size == 0u);
ASSERT_FALSE(traits_type::in_place_delete);
ASSERT_EQ(traits_type::page_size, 0u);
}
TEST(Component, NonEmpty) {
using traits_type = entt::component_traits<non_empty>;
static_assert(!traits_type::in_place_delete);
static_assert(traits_type::page_size == ENTT_PACKED_PAGE);
ASSERT_FALSE(traits_type::in_place_delete);
ASSERT_EQ(traits_type::page_size, ENTT_PACKED_PAGE);
}
TEST(Component, NonMovable) {
using traits_type = entt::component_traits<non_movable>;
static_assert(traits_type::in_place_delete);
static_assert(traits_type::page_size == ENTT_PACKED_PAGE);
ASSERT_TRUE(traits_type::in_place_delete);
ASSERT_EQ(traits_type::page_size, ENTT_PACKED_PAGE);
}
TEST(Component, SelfContained) {
using traits_type = entt::component_traits<self_contained>;
static_assert(traits_type::in_place_delete);
static_assert(traits_type::page_size == 4u);
ASSERT_TRUE(traits_type::in_place_delete);
ASSERT_EQ(traits_type::page_size, 4u);
}
TEST(Component, TraitsBased) {
using traits_type = entt::component_traits<traits_based>;
static_assert(!traits_type::in_place_delete);
static_assert(traits_type::page_size == 8u);
ASSERT_TRUE(!traits_type::in_place_delete);
ASSERT_EQ(traits_type::page_size, 8u);
}

206
test/entt/entity/group.cpp
View File

@@ -223,8 +223,8 @@ TEST(NonOwningGroup, Each) {
ASSERT_EQ(std::get<0>(*iterable.begin()), entity[1u]);
ASSERT_EQ(std::get<0>(*++citerable.begin()), entity[0u]);
static_assert(std::is_same_v<decltype(std::get<1>(*iterable.begin())), int &>);
static_assert(std::is_same_v<decltype(std::get<2>(*citerable.begin())), const char &>);
testing::StaticAssertTypeEq<decltype(std::get<1>(*iterable.begin())), int &>();
testing::StaticAssertTypeEq<decltype(std::get<2>(*citerable.begin())), const char &>();
// do not use iterable, make sure an iterable group works when created from a temporary
for(auto [entt, ivalue, cvalue]: registry.group(entt::get<int, char>).each()) {
@@ -284,8 +284,8 @@ TEST(NonOwningGroup, Sort) {
ASSERT_FALSE(group.contains(e3));
group.sort<const int, unsigned int>([](const auto lhs, const auto rhs) {
static_assert(std::is_same_v<decltype(std::get<0>(lhs)), const int &>);
static_assert(std::is_same_v<decltype(std::get<1>(rhs)), unsigned int &>);
testing::StaticAssertTypeEq<decltype(std::get<0>(lhs)), const int &>();
testing::StaticAssertTypeEq<decltype(std::get<1>(rhs)), unsigned int &>();
return std::get<0>(lhs) < std::get<0>(rhs);
});
@@ -388,33 +388,33 @@ TEST(NonOwningGroup, ConstNonConstAndAllInBetween) {
ASSERT_EQ(group.size(), 1u);
static_assert(std::is_same_v<decltype(group.get<0>({})), int &>);
static_assert(std::is_same_v<decltype(group.get<int>({})), int &>);
testing::StaticAssertTypeEq<decltype(group.get<0>({})), int &>();
testing::StaticAssertTypeEq<decltype(group.get<int>({})), int &>();
static_assert(std::is_same_v<decltype(group.get<1>({})), void>);
static_assert(std::is_same_v<decltype(group.get<empty_type>({})), void>);
testing::StaticAssertTypeEq<decltype(group.get<1>({})), void>();
testing::StaticAssertTypeEq<decltype(group.get<empty_type>({})), void>();
static_assert(std::is_same_v<decltype(group.get<2>({})), const char &>);
static_assert(std::is_same_v<decltype(group.get<const char>({})), const char &>);
testing::StaticAssertTypeEq<decltype(group.get<2>({})), const char &>();
testing::StaticAssertTypeEq<decltype(group.get<const char>({})), const char &>();
static_assert(std::is_same_v<decltype(group.get<int, empty_type, const char>({})), std::tuple<int &, const char &>>);
static_assert(std::is_same_v<decltype(group.get<0, 1, 2>({})), std::tuple<int &, const char &>>);
testing::StaticAssertTypeEq<decltype(group.get<int, empty_type, const char>({})), std::tuple<int &, const char &>>();
testing::StaticAssertTypeEq<decltype(group.get<0, 1, 2>({})), std::tuple<int &, const char &>>();
static_assert(std::is_same_v<decltype(group.get({})), std::tuple<int &, const char &>>);
testing::StaticAssertTypeEq<decltype(group.get({})), std::tuple<int &, const char &>>();
static_assert(std::is_same_v<decltype(std::as_const(registry).group_if_exists(entt::get<int, char>)), decltype(std::as_const(registry).group_if_exists(entt::get<const int, const char>))>);
static_assert(std::is_same_v<decltype(std::as_const(registry).group_if_exists(entt::get<const int, char>)), decltype(std::as_const(registry).group_if_exists(entt::get<const int, const char>))>);
static_assert(std::is_same_v<decltype(std::as_const(registry).group_if_exists(entt::get<int, const char>)), decltype(std::as_const(registry).group_if_exists(entt::get<const int, const char>))>);
testing::StaticAssertTypeEq<decltype(std::as_const(registry).group_if_exists(entt::get<int, char>)), decltype(std::as_const(registry).group_if_exists(entt::get<const int, const char>))>();
testing::StaticAssertTypeEq<decltype(std::as_const(registry).group_if_exists(entt::get<const int, char>)), decltype(std::as_const(registry).group_if_exists(entt::get<const int, const char>))>();
testing::StaticAssertTypeEq<decltype(std::as_const(registry).group_if_exists(entt::get<int, const char>)), decltype(std::as_const(registry).group_if_exists(entt::get<const int, const char>))>();
group.each([](auto &&i, auto &&c) {
static_assert(std::is_same_v<decltype(i), int &>);
static_assert(std::is_same_v<decltype(c), const char &>);
testing::StaticAssertTypeEq<decltype(i), int &>();
testing::StaticAssertTypeEq<decltype(c), const char &>();
});
for(auto [entt, iv, cv]: group.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), const char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), const char &>();
}
}
@@ -534,8 +534,8 @@ TEST(NonOwningGroup, EmptyAndNonEmptyTypes) {
});
for(auto [entt, iv]: group.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
ASSERT_TRUE(entt == e0 || entt == e1);
}
@@ -573,9 +573,9 @@ TEST(NonOwningGroup, EmptyTypes) {
});
for(auto [entt, iv, cv]: registry.group(entt::get<int, char, empty_type>).each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
ASSERT_EQ(entity, entt);
}
@@ -585,9 +585,9 @@ TEST(NonOwningGroup, EmptyTypes) {
});
for(auto [entt, iv, cv]: registry.group(entt::get<int, empty_type, char>).each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
ASSERT_EQ(entity, entt);
}
@@ -596,9 +596,9 @@ TEST(NonOwningGroup, EmptyTypes) {
});
for(auto [entt, iv, cv]: registry.group(entt::get<empty_type, int, char>).each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
ASSERT_EQ(entity, entt);
}
@@ -643,9 +643,10 @@ TEST(NonOwningGroup, SignalRace) {
TEST(NonOwningGroup, ExtendedGet) {
using type = decltype(std::declval<entt::registry>().group(entt::get<int, empty_type, char>).get({}));
static_assert(std::tuple_size_v<type> == 2u);
static_assert(std::is_same_v<std::tuple_element_t<0, type>, int &>);
static_assert(std::is_same_v<std::tuple_element_t<1, type>, char &>);
ASSERT_EQ(std::tuple_size_v<type>, 2u);
testing::StaticAssertTypeEq<std::tuple_element_t<0, type>, int &>();
testing::StaticAssertTypeEq<std::tuple_element_t<1, type>, char &>();
entt::registry registry;
const auto entity = registry.create();
@@ -678,18 +679,18 @@ TEST(NonOwningGroup, Storage) {
const auto entity = registry.create();
auto group = registry.group(entt::get<int, const char>, entt::exclude<double, const float>);
static_assert(std::is_same_v<decltype(group.storage<0u>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(group.storage<int>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(group.storage<const int>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(group.storage<1u>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(group.storage<char>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(group.storage<const char>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(group.storage<2u>()), entt::storage_type_t<double> *>);
static_assert(std::is_same_v<decltype(group.storage<double>()), entt::storage_type_t<double> *>);
static_assert(std::is_same_v<decltype(group.storage<const double>()), entt::storage_type_t<double> *>);
static_assert(std::is_same_v<decltype(group.storage<3u>()), const entt::storage_type_t<float> *>);
static_assert(std::is_same_v<decltype(group.storage<float>()), const entt::storage_type_t<float> *>);
static_assert(std::is_same_v<decltype(group.storage<const float>()), const entt::storage_type_t<float> *>);
testing::StaticAssertTypeEq<decltype(group.storage<0u>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(group.storage<int>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(group.storage<const int>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(group.storage<1u>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(group.storage<char>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(group.storage<const char>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(group.storage<2u>()), entt::storage_type_t<double> *>();
testing::StaticAssertTypeEq<decltype(group.storage<double>()), entt::storage_type_t<double> *>();
testing::StaticAssertTypeEq<decltype(group.storage<const double>()), entt::storage_type_t<double> *>();
testing::StaticAssertTypeEq<decltype(group.storage<3u>()), const entt::storage_type_t<float> *>();
testing::StaticAssertTypeEq<decltype(group.storage<float>()), const entt::storage_type_t<float> *>();
testing::StaticAssertTypeEq<decltype(group.storage<const float>()), const entt::storage_type_t<float> *>();
ASSERT_TRUE(group);
@@ -971,8 +972,8 @@ TEST(OwningGroup, Each) {
ASSERT_EQ(std::get<0>(*iterable.begin()), entity[1u]);
ASSERT_EQ(std::get<0>(*++citerable.begin()), entity[0u]);
static_assert(std::is_same_v<decltype(std::get<1>(*iterable.begin())), int &>);
static_assert(std::is_same_v<decltype(std::get<2>(*citerable.begin())), const char &>);
testing::StaticAssertTypeEq<decltype(std::get<1>(*iterable.begin())), int &>();
testing::StaticAssertTypeEq<decltype(std::get<2>(*citerable.begin())), const char &>();
// do not use iterable, make sure an iterable group works when created from a temporary
for(auto [entt, ivalue, cvalue]: registry.group<int>(entt::get<char>).each()) {
@@ -1101,8 +1102,8 @@ TEST(OwningGroup, SortUnordered) {
registry.emplace<boxed_int>(entity[6], 5);
group.sort<boxed_int, char>([](const auto lhs, const auto rhs) {
static_assert(std::is_same_v<decltype(std::get<0>(lhs)), boxed_int &>);
static_assert(std::is_same_v<decltype(std::get<1>(rhs)), char &>);
testing::StaticAssertTypeEq<decltype(std::get<0>(lhs)), boxed_int &>();
testing::StaticAssertTypeEq<decltype(std::get<1>(rhs)), char &>();
return std::get<1>(lhs) < std::get<1>(rhs);
});
@@ -1218,43 +1219,43 @@ TEST(OwningGroup, ConstNonConstAndAllInBetween) {
ASSERT_EQ(group.size(), 1u);
static_assert(std::is_same_v<decltype(group.get<0>({})), int &>);
static_assert(std::is_same_v<decltype(group.get<int>({})), int &>);
testing::StaticAssertTypeEq<decltype(group.get<0>({})), int &>();
testing::StaticAssertTypeEq<decltype(group.get<int>({})), int &>();
static_assert(std::is_same_v<decltype(group.get<1>({})), const char &>);
static_assert(std::is_same_v<decltype(group.get<const char>({})), const char &>);
testing::StaticAssertTypeEq<decltype(group.get<1>({})), const char &>();
testing::StaticAssertTypeEq<decltype(group.get<const char>({})), const char &>();
static_assert(std::is_same_v<decltype(group.get<2>({})), void>);
static_assert(std::is_same_v<decltype(group.get<empty_type>({})), void>);
testing::StaticAssertTypeEq<decltype(group.get<2>({})), void>();
testing::StaticAssertTypeEq<decltype(group.get<empty_type>({})), void>();
static_assert(std::is_same_v<decltype(group.get<3>({})), double &>);
static_assert(std::is_same_v<decltype(group.get<double>({})), double &>);
testing::StaticAssertTypeEq<decltype(group.get<3>({})), double &>();
testing::StaticAssertTypeEq<decltype(group.get<double>({})), double &>();
static_assert(std::is_same_v<decltype(group.get<4>({})), const float &>);
static_assert(std::is_same_v<decltype(group.get<const float>({})), const float &>);
testing::StaticAssertTypeEq<decltype(group.get<4>({})), const float &>();
testing::StaticAssertTypeEq<decltype(group.get<const float>({})), const float &>();
static_assert(std::is_same_v<decltype(group.get<int, const char, empty_type, double, const float>({})), std::tuple<int &, const char &, double &, const float &>>);
static_assert(std::is_same_v<decltype(group.get<0, 1, 2, 3, 4>({})), std::tuple<int &, const char &, double &, const float &>>);
testing::StaticAssertTypeEq<decltype(group.get<int, const char, empty_type, double, const float>({})), std::tuple<int &, const char &, double &, const float &>>();
testing::StaticAssertTypeEq<decltype(group.get<0, 1, 2, 3, 4>({})), std::tuple<int &, const char &, double &, const float &>>();
static_assert(std::is_same_v<decltype(group.get({})), std::tuple<int &, const char &, double &, const float &>>);
testing::StaticAssertTypeEq<decltype(group.get({})), std::tuple<int &, const char &, double &, const float &>>();
static_assert(std::is_same_v<decltype(std::as_const(registry).group_if_exists<int>(entt::get<char>)), decltype(std::as_const(registry).group_if_exists<const int>(entt::get<const char>))>);
static_assert(std::is_same_v<decltype(std::as_const(registry).group_if_exists<const int>(entt::get<char>)), decltype(std::as_const(registry).group_if_exists<const int>(entt::get<const char>))>);
static_assert(std::is_same_v<decltype(std::as_const(registry).group_if_exists<int>(entt::get<const char>)), decltype(std::as_const(registry).group_if_exists<const int>(entt::get<const char>))>);
testing::StaticAssertTypeEq<decltype(std::as_const(registry).group_if_exists<int>(entt::get<char>)), decltype(std::as_const(registry).group_if_exists<const int>(entt::get<const char>))>();
testing::StaticAssertTypeEq<decltype(std::as_const(registry).group_if_exists<const int>(entt::get<char>)), decltype(std::as_const(registry).group_if_exists<const int>(entt::get<const char>))>();
testing::StaticAssertTypeEq<decltype(std::as_const(registry).group_if_exists<int>(entt::get<const char>)), decltype(std::as_const(registry).group_if_exists<const int>(entt::get<const char>))>();
group.each([](auto &&i, auto &&c, auto &&d, auto &&f) {
static_assert(std::is_same_v<decltype(i), int &>);
static_assert(std::is_same_v<decltype(c), const char &>);
static_assert(std::is_same_v<decltype(d), double &>);
static_assert(std::is_same_v<decltype(f), const float &>);
testing::StaticAssertTypeEq<decltype(i), int &>();
testing::StaticAssertTypeEq<decltype(c), const char &>();
testing::StaticAssertTypeEq<decltype(d), double &>();
testing::StaticAssertTypeEq<decltype(f), const float &>();
});
for(auto [entt, iv, cv, dv, fv]: group.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), const char &>);
static_assert(std::is_same_v<decltype(dv), double &>);
static_assert(std::is_same_v<decltype(fv), const float &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), const char &>();
testing::StaticAssertTypeEq<decltype(dv), double &>();
testing::StaticAssertTypeEq<decltype(fv), const float &>();
}
}
@@ -1374,8 +1375,8 @@ TEST(OwningGroup, EmptyAndNonEmptyTypes) {
});
for(auto [entt, iv]: group.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
ASSERT_TRUE(entt == e0 || entt == e1);
}
@@ -1413,9 +1414,9 @@ TEST(OwningGroup, EmptyTypes) {
});
for(auto [entt, iv, cv]: registry.group<int>(entt::get<char, empty_type>).each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
ASSERT_EQ(entity, entt);
}
@@ -1425,9 +1426,9 @@ TEST(OwningGroup, EmptyTypes) {
});
for(auto [entt, cv, iv]: registry.group<char>(entt::get<empty_type, int>).each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(cv), char &>);
static_assert(std::is_same_v<decltype(iv), int &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
ASSERT_EQ(entity, entt);
}
@@ -1436,9 +1437,9 @@ TEST(OwningGroup, EmptyTypes) {
});
for(auto [entt, iv, cv]: registry.group<empty_type>(entt::get<int, char>).each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
ASSERT_EQ(entity, entt);
}
@@ -1531,9 +1532,10 @@ TEST(OwningGroup, SwappingValuesIsAllowed) {
TEST(OwningGroup, ExtendedGet) {
using type = decltype(std::declval<entt::registry>().group<int, empty_type>(entt::get<char>).get({}));
static_assert(std::tuple_size_v<type> == 2u);
static_assert(std::is_same_v<std::tuple_element_t<0, type>, int &>);
static_assert(std::is_same_v<std::tuple_element_t<1, type>, char &>);
ASSERT_EQ(std::tuple_size_v<type>, 2u);
testing::StaticAssertTypeEq<std::tuple_element_t<0, type>, int &>();
testing::StaticAssertTypeEq<std::tuple_element_t<1, type>, char &>();
entt::registry registry;
const auto entity = registry.create();
@@ -1566,18 +1568,18 @@ TEST(OwningGroup, Storage) {
const auto entity = registry.create();
auto group = registry.group<int>(entt::get<const char>, entt::exclude<double, const float>);
static_assert(std::is_same_v<decltype(group.storage<0u>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(group.storage<int>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(group.storage<const int>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(group.storage<1u>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(group.storage<char>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(group.storage<const char>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(group.storage<2u>()), entt::storage_type_t<double> *>);
static_assert(std::is_same_v<decltype(group.storage<double>()), entt::storage_type_t<double> *>);
static_assert(std::is_same_v<decltype(group.storage<const double>()), entt::storage_type_t<double> *>);
static_assert(std::is_same_v<decltype(group.storage<3u>()), const entt::storage_type_t<float> *>);
static_assert(std::is_same_v<decltype(group.storage<float>()), const entt::storage_type_t<float> *>);
static_assert(std::is_same_v<decltype(group.storage<const float>()), const entt::storage_type_t<float> *>);
testing::StaticAssertTypeEq<decltype(group.storage<0u>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(group.storage<int>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(group.storage<const int>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(group.storage<1u>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(group.storage<char>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(group.storage<const char>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(group.storage<2u>()), entt::storage_type_t<double> *>();
testing::StaticAssertTypeEq<decltype(group.storage<double>()), entt::storage_type_t<double> *>();
testing::StaticAssertTypeEq<decltype(group.storage<const double>()), entt::storage_type_t<double> *>();
testing::StaticAssertTypeEq<decltype(group.storage<3u>()), const entt::storage_type_t<float> *>();
testing::StaticAssertTypeEq<decltype(group.storage<float>()), const entt::storage_type_t<float> *>();
testing::StaticAssertTypeEq<decltype(group.storage<const float>()), const entt::storage_type_t<float> *>();
ASSERT_TRUE(group);

24
test/entt/entity/handle.cpp
View File

@@ -8,18 +8,18 @@
#include <entt/entity/registry.hpp>
TEST(BasicHandle, Assumptions) {
static_assert(std::is_trivially_copyable_v<entt::handle>);
static_assert(std::is_trivially_assignable_v<entt::handle, entt::handle>);
static_assert(std::is_trivially_destructible_v<entt::handle>);
ASSERT_TRUE(std::is_trivially_copyable_v<entt::handle>);
ASSERT_TRUE((std::is_trivially_assignable_v<entt::handle, entt::handle>));
ASSERT_TRUE(std::is_trivially_destructible_v<entt::handle>);
static_assert(std::is_trivially_copyable_v<entt::const_handle>);
static_assert(std::is_trivially_assignable_v<entt::const_handle, entt::const_handle>);
static_assert(std::is_trivially_destructible_v<entt::const_handle>);
ASSERT_TRUE(std::is_trivially_copyable_v<entt::const_handle>);
ASSERT_TRUE((std::is_trivially_assignable_v<entt::const_handle, entt::const_handle>));
ASSERT_TRUE(std::is_trivially_destructible_v<entt::const_handle>);
}
TEST(BasicHandle, DeductionGuide) {
static_assert(std::is_same_v<decltype(entt::basic_handle{std::declval<entt::registry &>(), {}}), entt::basic_handle<entt::registry>>);
static_assert(std::is_same_v<decltype(entt::basic_handle{std::declval<const entt::registry &>(), {}}), entt::basic_handle<const entt::registry>>);
testing::StaticAssertTypeEq<decltype(entt::basic_handle{std::declval<entt::registry &>(), {}}), entt::basic_handle<entt::registry>>();
testing::StaticAssertTypeEq<decltype(entt::basic_handle{std::declval<const entt::registry &>(), {}}), entt::basic_handle<const entt::registry>>();
}
TEST(BasicHandle, Construction) {
@@ -39,8 +39,8 @@ TEST(BasicHandle, Construction) {
ASSERT_EQ(handle, chandle);
static_assert(std::is_same_v<entt::registry *, decltype(handle.registry())>);
static_assert(std::is_same_v<const entt::registry *, decltype(chandle.registry())>);
testing::StaticAssertTypeEq<entt::registry *, decltype(handle.registry())>();
testing::StaticAssertTypeEq<const entt::registry *, decltype(chandle.registry())>();
}
TEST(BasicHandle, Invalidation) {
@@ -250,8 +250,8 @@ TEST(BasicHandle, Storage) {
entt::handle handle{registry, entity};
entt::const_handle chandle{std::as_const(registry), entity};
static_assert(std::is_same_v<decltype(*handle.storage().begin()), std::pair<entt::id_type, entt::sparse_set &>>);
static_assert(std::is_same_v<decltype(*chandle.storage().begin()), std::pair<entt::id_type, const entt::sparse_set &>>);
testing::StaticAssertTypeEq<decltype(*handle.storage().begin()), std::pair<entt::id_type, entt::sparse_set &>>();
testing::StaticAssertTypeEq<decltype(*chandle.storage().begin()), std::pair<entt::id_type, const entt::sparse_set &>>();
ASSERT_EQ(handle.storage().begin(), handle.storage().end());
ASSERT_EQ(chandle.storage().begin(), chandle.storage().end());

30
test/entt/entity/snapshot.cpp
View File

@@ -25,11 +25,11 @@ struct shadow {
};
TEST(BasicSnapshot, Constructors) {
static_assert(!std::is_default_constructible_v<entt::basic_snapshot<entt::registry>>);
static_assert(!std::is_copy_constructible_v<entt::basic_snapshot<entt::registry>>);
static_assert(!std::is_copy_assignable_v<entt::basic_snapshot<entt::registry>>);
static_assert(std::is_move_constructible_v<entt::basic_snapshot<entt::registry>>);
static_assert(std::is_move_assignable_v<entt::basic_snapshot<entt::registry>>);
ASSERT_FALSE(std::is_default_constructible_v<entt::basic_snapshot<entt::registry>>);
ASSERT_FALSE(std::is_copy_constructible_v<entt::basic_snapshot<entt::registry>>);
ASSERT_FALSE(std::is_copy_assignable_v<entt::basic_snapshot<entt::registry>>);
ASSERT_TRUE(std::is_move_constructible_v<entt::basic_snapshot<entt::registry>>);
ASSERT_TRUE(std::is_move_assignable_v<entt::basic_snapshot<entt::registry>>);
entt::registry registry;
entt::basic_snapshot snapshot{registry};
@@ -219,11 +219,11 @@ TEST(BasicSnapshot, GetTypeSparse) {
}
TEST(BasicSnapshotLoader, Constructors) {
static_assert(!std::is_default_constructible_v<entt::basic_snapshot_loader<entt::registry>>);
static_assert(!std::is_copy_constructible_v<entt::basic_snapshot_loader<entt::registry>>);
static_assert(!std::is_copy_assignable_v<entt::basic_snapshot_loader<entt::registry>>);
static_assert(std::is_move_constructible_v<entt::basic_snapshot_loader<entt::registry>>);
static_assert(std::is_move_assignable_v<entt::basic_snapshot_loader<entt::registry>>);
ASSERT_FALSE(std::is_default_constructible_v<entt::basic_snapshot_loader<entt::registry>>);
ASSERT_FALSE(std::is_copy_constructible_v<entt::basic_snapshot_loader<entt::registry>>);
ASSERT_FALSE(std::is_copy_assignable_v<entt::basic_snapshot_loader<entt::registry>>);
ASSERT_TRUE(std::is_move_constructible_v<entt::basic_snapshot_loader<entt::registry>>);
ASSERT_TRUE(std::is_move_assignable_v<entt::basic_snapshot_loader<entt::registry>>);
entt::registry registry;
entt::basic_snapshot_loader loader{registry};
@@ -495,11 +495,11 @@ TEST(BasicSnapshotLoader, Orphans) {
}
TEST(BasicContinuousLoader, Constructors) {
static_assert(!std::is_default_constructible_v<entt::basic_continuous_loader<entt::registry>>);
static_assert(!std::is_copy_constructible_v<entt::basic_continuous_loader<entt::registry>>);
static_assert(!std::is_copy_assignable_v<entt::basic_continuous_loader<entt::registry>>);
static_assert(std::is_move_constructible_v<entt::basic_continuous_loader<entt::registry>>);
static_assert(std::is_move_assignable_v<entt::basic_continuous_loader<entt::registry>>);
ASSERT_FALSE(std::is_default_constructible_v<entt::basic_continuous_loader<entt::registry>>);
ASSERT_FALSE(std::is_copy_constructible_v<entt::basic_continuous_loader<entt::registry>>);
ASSERT_FALSE(std::is_copy_assignable_v<entt::basic_continuous_loader<entt::registry>>);
ASSERT_TRUE(std::is_move_constructible_v<entt::basic_continuous_loader<entt::registry>>);
ASSERT_TRUE(std::is_move_assignable_v<entt::basic_continuous_loader<entt::registry>>);
entt::registry registry;
entt::basic_continuous_loader loader{registry};

130
test/entt/entity/storage.cpp
View File

@@ -975,7 +975,7 @@ TEST_F(Storage, ShrinkToFit) {
}
TEST_F(Storage, AggregatesMustWork) {
static_assert(std::is_aggregate_v<aggregate_tracking_type>);
ASSERT_TRUE(std::is_aggregate_v<aggregate_tracking_type>);
entt::storage<aggregate_tracking_type> storage{};
// aggregate types with no args enter the non-aggregate path
@@ -1018,9 +1018,9 @@ TEST_F(Storage, SelfMoveSupportInPlaceDelete) {
TEST_F(Storage, Iterator) {
using iterator = typename entt::storage<boxed_int>::iterator;
static_assert(std::is_same_v<iterator::value_type, boxed_int>);
static_assert(std::is_same_v<iterator::pointer, boxed_int *>);
static_assert(std::is_same_v<iterator::reference, boxed_int &>);
testing::StaticAssertTypeEq<iterator::value_type, boxed_int>();
testing::StaticAssertTypeEq<iterator::pointer, boxed_int *>();
testing::StaticAssertTypeEq<iterator::reference, boxed_int &>();
entt::storage<boxed_int> pool;
pool.emplace(entt::entity{3}, 42);
@@ -1079,9 +1079,9 @@ TEST_F(Storage, Iterator) {
TEST_F(Storage, ConstIterator) {
using iterator = typename entt::storage<boxed_int>::const_iterator;
static_assert(std::is_same_v<iterator::value_type, boxed_int>);
static_assert(std::is_same_v<iterator::pointer, const boxed_int *>);
static_assert(std::is_same_v<iterator::reference, const boxed_int &>);
testing::StaticAssertTypeEq<iterator::value_type, boxed_int>();
testing::StaticAssertTypeEq<iterator::pointer, const boxed_int *>();
testing::StaticAssertTypeEq<iterator::reference, const boxed_int &>();
entt::storage<boxed_int> pool;
pool.emplace(entt::entity{3}, 42);
@@ -1142,9 +1142,9 @@ TEST_F(Storage, ConstIterator) {
TEST_F(Storage, ReverseIterator) {
using reverse_iterator = typename entt::storage<boxed_int>::reverse_iterator;
static_assert(std::is_same_v<reverse_iterator::value_type, boxed_int>);
static_assert(std::is_same_v<reverse_iterator::pointer, boxed_int *>);
static_assert(std::is_same_v<reverse_iterator::reference, boxed_int &>);
testing::StaticAssertTypeEq<reverse_iterator::value_type, boxed_int>();
testing::StaticAssertTypeEq<reverse_iterator::pointer, boxed_int *>();
testing::StaticAssertTypeEq<reverse_iterator::reference, boxed_int &>();
entt::storage<boxed_int> pool;
pool.emplace(entt::entity{3}, 42);
@@ -1203,9 +1203,9 @@ TEST_F(Storage, ReverseIterator) {
TEST_F(Storage, ConstReverseIterator) {
using const_reverse_iterator = typename entt::storage<boxed_int>::const_reverse_iterator;
static_assert(std::is_same_v<const_reverse_iterator::value_type, boxed_int>);
static_assert(std::is_same_v<const_reverse_iterator::pointer, const boxed_int *>);
static_assert(std::is_same_v<const_reverse_iterator::reference, const boxed_int &>);
testing::StaticAssertTypeEq<const_reverse_iterator::value_type, boxed_int>();
testing::StaticAssertTypeEq<const_reverse_iterator::pointer, const boxed_int *>();
testing::StaticAssertTypeEq<const_reverse_iterator::reference, const boxed_int &>();
entt::storage<boxed_int> pool;
pool.emplace(entt::entity{3}, 42);
@@ -1270,8 +1270,8 @@ TEST_F(Storage, IteratorConversion) {
typename entt::storage<boxed_int>::iterator it = pool.begin();
typename entt::storage<boxed_int>::const_iterator cit = it;
static_assert(std::is_same_v<decltype(*it), boxed_int &>);
static_assert(std::is_same_v<decltype(*cit), const boxed_int &>);
testing::StaticAssertTypeEq<decltype(*it), boxed_int &>();
testing::StaticAssertTypeEq<decltype(*cit), const boxed_int &>();
ASSERT_EQ(it->value, 42);
ASSERT_EQ(it->value, cit->value);
@@ -1304,9 +1304,9 @@ TEST_F(Storage, IteratorPageSizeAwareness) {
TEST_F(Storage, Iterable) {
using iterator = typename entt::storage<boxed_int>::iterable::iterator;
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity, boxed_int &>>);
static_assert(std::is_same_v<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, boxed_int &>>>);
static_assert(std::is_same_v<typename iterator::reference, typename iterator::value_type>);
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity, boxed_int &>>();
testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, boxed_int &>>>();
testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
entt::storage<boxed_int> pool;
entt::sparse_set &base = pool;
@@ -1338,8 +1338,8 @@ TEST_F(Storage, Iterable) {
ASSERT_EQ(begin.base(), base.end());
for(auto [entity, element]: iterable) {
static_assert(std::is_same_v<decltype(entity), entt::entity>);
static_assert(std::is_same_v<decltype(element), boxed_int &>);
testing::StaticAssertTypeEq<decltype(entity), entt::entity>();
testing::StaticAssertTypeEq<decltype(element), boxed_int &>();
ASSERT_TRUE(entity != entt::entity{1} || element == boxed_int{99});
ASSERT_TRUE(entity != entt::entity{3} || element == boxed_int{42});
}
@@ -1348,9 +1348,9 @@ TEST_F(Storage, Iterable) {
TEST_F(Storage, ConstIterable) {
using iterator = typename entt::storage<boxed_int>::const_iterable::iterator;
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity, const boxed_int &>>);
static_assert(std::is_same_v<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, const boxed_int &>>>);
static_assert(std::is_same_v<typename iterator::reference, typename iterator::value_type>);
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity, const boxed_int &>>();
testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, const boxed_int &>>>();
testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
entt::storage<boxed_int> pool;
entt::sparse_set &base = pool;
@@ -1382,8 +1382,8 @@ TEST_F(Storage, ConstIterable) {
ASSERT_EQ(begin.base(), base.end());
for(auto [entity, element]: iterable) {
static_assert(std::is_same_v<decltype(entity), entt::entity>);
static_assert(std::is_same_v<decltype(element), const boxed_int &>);
testing::StaticAssertTypeEq<decltype(entity), entt::entity>();
testing::StaticAssertTypeEq<decltype(element), const boxed_int &>();
ASSERT_TRUE(entity != entt::entity{1} || element == boxed_int{99});
ASSERT_TRUE(entity != entt::entity{3} || element == boxed_int{42});
}
@@ -1396,8 +1396,8 @@ TEST_F(Storage, IterableIteratorConversion) {
typename entt::storage<boxed_int>::iterable::iterator it = pool.each().begin();
typename entt::storage<boxed_int>::const_iterable::iterator cit = it;
static_assert(std::is_same_v<decltype(*it), std::tuple<entt::entity, boxed_int &>>);
static_assert(std::is_same_v<decltype(*cit), std::tuple<entt::entity, const boxed_int &>>);
testing::StaticAssertTypeEq<decltype(*it), std::tuple<entt::entity, boxed_int &>>();
testing::StaticAssertTypeEq<decltype(*cit), std::tuple<entt::entity, const boxed_int &>>();
ASSERT_EQ(it, cit);
ASSERT_NE(++cit, it);
@@ -1406,10 +1406,10 @@ TEST_F(Storage, IterableIteratorConversion) {
TEST_F(Storage, EmptyTypeIterable) {
using iterator = typename entt::storage<empty_stable_type>::iterable::iterator;
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity>>);
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity>>);
static_assert(std::is_same_v<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>);
static_assert(std::is_same_v<typename iterator::reference, typename iterator::value_type>);
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
entt::storage<empty_stable_type> pool;
entt::sparse_set &base = pool;
@@ -1439,7 +1439,7 @@ TEST_F(Storage, EmptyTypeIterable) {
ASSERT_EQ(begin.base(), base.end());
for(auto [entity]: iterable) {
static_assert(std::is_same_v<decltype(entity), entt::entity>);
testing::StaticAssertTypeEq<decltype(entity), entt::entity>();
ASSERT_TRUE(entity == entt::entity{1} || entity == entt::entity{3});
}
}
@@ -1447,10 +1447,10 @@ TEST_F(Storage, EmptyTypeIterable) {
TEST_F(Storage, EmptyTypeConstIterable) {
using iterator = typename entt::storage<empty_stable_type>::const_iterable::iterator;
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity>>);
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity>>);
static_assert(std::is_same_v<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>);
static_assert(std::is_same_v<typename iterator::reference, typename iterator::value_type>);
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
entt::storage<empty_stable_type> pool;
entt::sparse_set &base = pool;
@@ -1480,7 +1480,7 @@ TEST_F(Storage, EmptyTypeConstIterable) {
ASSERT_EQ(begin.base(), base.end());
for(auto [entity]: iterable) {
static_assert(std::is_same_v<decltype(entity), entt::entity>);
testing::StaticAssertTypeEq<decltype(entity), entt::entity>();
ASSERT_TRUE(entity == entt::entity{1} || entity == entt::entity{3});
}
}
@@ -1498,9 +1498,9 @@ TEST_F(Storage, IterableAlgorithmCompatibility) {
TEST_F(Storage, ReverseIterable) {
using iterator = typename entt::storage<boxed_int>::reverse_iterable::iterator;
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity, boxed_int &>>);
static_assert(std::is_same_v<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, boxed_int &>>>);
static_assert(std::is_same_v<typename iterator::reference, typename iterator::value_type>);
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity, boxed_int &>>();
testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, boxed_int &>>>();
testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
entt::storage<boxed_int> pool;
entt::sparse_set &base = pool;
@@ -1532,8 +1532,8 @@ TEST_F(Storage, ReverseIterable) {
ASSERT_EQ(begin.base(), base.rend());
for(auto [entity, element]: iterable) {
static_assert(std::is_same_v<decltype(entity), entt::entity>);
static_assert(std::is_same_v<decltype(element), boxed_int &>);
testing::StaticAssertTypeEq<decltype(entity), entt::entity>();
testing::StaticAssertTypeEq<decltype(element), boxed_int &>();
ASSERT_TRUE(entity != entt::entity{1} || element == boxed_int{99});
ASSERT_TRUE(entity != entt::entity{3} || element == boxed_int{42});
}
@@ -1542,9 +1542,9 @@ TEST_F(Storage, ReverseIterable) {
TEST_F(Storage, ConstReverseIterable) {
using iterator = typename entt::storage<boxed_int>::const_reverse_iterable::iterator;
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity, const boxed_int &>>);
static_assert(std::is_same_v<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, const boxed_int &>>>);
static_assert(std::is_same_v<typename iterator::reference, typename iterator::value_type>);
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity, const boxed_int &>>();
testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity, const boxed_int &>>>();
testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
entt::storage<boxed_int> pool;
entt::sparse_set &base = pool;
@@ -1576,8 +1576,8 @@ TEST_F(Storage, ConstReverseIterable) {
ASSERT_EQ(begin.base(), base.rend());
for(auto [entity, element]: iterable) {
static_assert(std::is_same_v<decltype(entity), entt::entity>);
static_assert(std::is_same_v<decltype(element), const boxed_int &>);
testing::StaticAssertTypeEq<decltype(entity), entt::entity>();
testing::StaticAssertTypeEq<decltype(element), const boxed_int &>();
ASSERT_TRUE(entity != entt::entity{1} || element == boxed_int{99});
ASSERT_TRUE(entity != entt::entity{3} || element == boxed_int{42});
}
@@ -1590,8 +1590,8 @@ TEST_F(Storage, ReverseIterableIteratorConversion) {
typename entt::storage<boxed_int>::reverse_iterable::iterator it = pool.reach().begin();
typename entt::storage<boxed_int>::const_reverse_iterable::iterator cit = it;
static_assert(std::is_same_v<decltype(*it), std::tuple<entt::entity, boxed_int &>>);
static_assert(std::is_same_v<decltype(*cit), std::tuple<entt::entity, const boxed_int &>>);
testing::StaticAssertTypeEq<decltype(*it), std::tuple<entt::entity, boxed_int &>>();
testing::StaticAssertTypeEq<decltype(*cit), std::tuple<entt::entity, const boxed_int &>>();
ASSERT_EQ(it, cit);
ASSERT_NE(++cit, it);
@@ -1600,10 +1600,10 @@ TEST_F(Storage, ReverseIterableIteratorConversion) {
TEST_F(Storage, EmptyTypeReverseIterable) {
using iterator = typename entt::storage<empty_stable_type>::reverse_iterable::iterator;
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity>>);
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity>>);
static_assert(std::is_same_v<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>);
static_assert(std::is_same_v<typename iterator::reference, typename iterator::value_type>);
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
entt::storage<empty_stable_type> pool;
entt::sparse_set &base = pool;
@@ -1633,7 +1633,7 @@ TEST_F(Storage, EmptyTypeReverseIterable) {
ASSERT_EQ(begin.base(), base.rend());
for(auto [entity]: iterable) {
static_assert(std::is_same_v<decltype(entity), entt::entity>);
testing::StaticAssertTypeEq<decltype(entity), entt::entity>();
ASSERT_TRUE(entity == entt::entity{1} || entity == entt::entity{3});
}
}
@@ -1641,10 +1641,10 @@ TEST_F(Storage, EmptyTypeReverseIterable) {
TEST_F(Storage, EmptyTypeConstReverseIterable) {
using iterator = typename entt::storage<empty_stable_type>::const_reverse_iterable::iterator;
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity>>);
static_assert(std::is_same_v<iterator::value_type, std::tuple<entt::entity>>);
static_assert(std::is_same_v<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>);
static_assert(std::is_same_v<typename iterator::reference, typename iterator::value_type>);
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
testing::StaticAssertTypeEq<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
entt::storage<empty_stable_type> pool;
entt::sparse_set &base = pool;
@@ -1674,7 +1674,7 @@ TEST_F(Storage, EmptyTypeConstReverseIterable) {
ASSERT_EQ(begin.base(), base.rend());
for(auto [entity]: iterable) {
static_assert(std::is_same_v<decltype(entity), entt::entity>);
testing::StaticAssertTypeEq<decltype(entity), entt::entity>();
ASSERT_TRUE(entity == entt::entity{1} || entity == entt::entity{3});
}
}
@@ -2305,14 +2305,14 @@ TEST_F(Storage, UsesAllocatorConstruction) {
TEST_F(Storage, StorageType) {
// just a bunch of static asserts to avoid regressions
static_assert(std::is_same_v<entt::storage_type_t<char, entt::entity>, entt::sigh_mixin<entt::basic_storage<char, entt::entity>>>);
static_assert(std::is_same_v<entt::storage_type_t<int>, entt::sigh_mixin<entt::storage<int>>>);
testing::StaticAssertTypeEq<entt::storage_type_t<char, entt::entity>, entt::sigh_mixin<entt::basic_storage<char, entt::entity>>>();
testing::StaticAssertTypeEq<entt::storage_type_t<int>, entt::sigh_mixin<entt::storage<int>>>();
}
TEST_F(Storage, StorageFor) {
// just a bunch of static asserts to avoid regressions
static_assert(std::is_same_v<entt::storage_for_t<const double, entt::entity>, const entt::sigh_mixin<entt::basic_storage<double, entt::entity>>>);
static_assert(std::is_same_v<entt::storage_for_t<char, entt::entity>, entt::sigh_mixin<entt::basic_storage<char, entt::entity>>>);
static_assert(std::is_same_v<entt::storage_for_t<const bool>, const entt::sigh_mixin<entt::storage<bool>>>);
static_assert(std::is_same_v<entt::storage_for_t<int>, entt::sigh_mixin<entt::storage<int>>>);
testing::StaticAssertTypeEq<entt::storage_for_t<const double, entt::entity>, const entt::sigh_mixin<entt::basic_storage<double, entt::entity>>>();
testing::StaticAssertTypeEq<entt::storage_for_t<char, entt::entity>, entt::sigh_mixin<entt::basic_storage<char, entt::entity>>>();
testing::StaticAssertTypeEq<entt::storage_for_t<const bool>, const entt::sigh_mixin<entt::storage<bool>>>();
testing::StaticAssertTypeEq<entt::storage_for_t<int>, entt::sigh_mixin<entt::storage<int>>>();
}

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

@@ -1,7 +1,6 @@
#include <algorithm>
#include <iterator>
#include <tuple>
#include <type_traits>
#include <utility>
#include <gtest/gtest.h>
#include <entt/entity/registry.hpp>
@@ -246,8 +245,8 @@ TEST(SingleComponentView, Each) {
ASSERT_EQ(std::get<0>(*iterable.begin()), entity[1u]);
ASSERT_EQ(std::get<0>(*++citerable.begin()), entity[0u]);
static_assert(std::is_same_v<decltype(std::get<1>(*iterable.begin())), int &>);
static_assert(std::is_same_v<decltype(std::get<1>(*citerable.begin())), const int &>);
testing::StaticAssertTypeEq<decltype(std::get<1>(*iterable.begin())), int &>();
testing::StaticAssertTypeEq<decltype(std::get<1>(*citerable.begin())), const int &>();
// do not use iterable, make sure an iterable view works when created from a temporary
for(auto [entt, value]: view.each()) {
@@ -268,32 +267,32 @@ TEST(SingleComponentView, ConstNonConstAndAllInBetween) {
ASSERT_EQ(view.size(), 1u);
ASSERT_EQ(cview.size(), 1u);
static_assert(std::is_same_v<decltype(view.get<0u>({})), int &>);
static_assert(std::is_same_v<decltype(view.get<int>({})), int &>);
static_assert(std::is_same_v<decltype(view.get({})), std::tuple<int &>>);
testing::StaticAssertTypeEq<decltype(view.get<0u>({})), int &>();
testing::StaticAssertTypeEq<decltype(view.get<int>({})), int &>();
testing::StaticAssertTypeEq<decltype(view.get({})), std::tuple<int &>>();
static_assert(std::is_same_v<decltype(cview.get<0u>({})), const int &>);
static_assert(std::is_same_v<decltype(cview.get<const int>({})), const int &>);
static_assert(std::is_same_v<decltype(cview.get({})), std::tuple<const int &>>);
testing::StaticAssertTypeEq<decltype(cview.get<0u>({})), const int &>();
testing::StaticAssertTypeEq<decltype(cview.get<const int>({})), const int &>();
testing::StaticAssertTypeEq<decltype(cview.get({})), std::tuple<const int &>>();
static_assert(std::is_same_v<decltype(std::as_const(registry).view<int>()), decltype(cview)>);
testing::StaticAssertTypeEq<decltype(std::as_const(registry).view<int>()), decltype(cview)>();
view.each([](auto &&i) {
static_assert(std::is_same_v<decltype(i), int &>);
testing::StaticAssertTypeEq<decltype(i), int &>();
});
cview.each([](auto &&i) {
static_assert(std::is_same_v<decltype(i), const int &>);
testing::StaticAssertTypeEq<decltype(i), const int &>();
});
for(auto [entt, iv]: view.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
}
for(auto [entt, iv]: cview.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), const int &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), const int &>();
}
}
@@ -310,17 +309,17 @@ TEST(SingleComponentView, ConstNonConstAndAllInBetweenWithEmptyType) {
ASSERT_EQ(view.size(), 1u);
ASSERT_EQ(cview.size(), 1u);
static_assert(std::is_same_v<decltype(view.get({})), std::tuple<>>);
static_assert(std::is_same_v<decltype(cview.get({})), std::tuple<>>);
testing::StaticAssertTypeEq<decltype(view.get({})), std::tuple<>>();
testing::StaticAssertTypeEq<decltype(cview.get({})), std::tuple<>>();
static_assert(std::is_same_v<decltype(std::as_const(registry).view<empty_type>()), decltype(cview)>);
testing::StaticAssertTypeEq<decltype(std::as_const(registry).view<empty_type>()), decltype(cview)>();
for(auto [entt]: view.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
}
for(auto [entt]: cview.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
}
}
@@ -381,7 +380,7 @@ TEST(SingleComponentView, EmptyTypes) {
});
for(auto [entt]: registry.view<empty_type>().each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
ASSERT_EQ(entity, entt);
}
@@ -395,8 +394,8 @@ TEST(SingleComponentView, EmptyTypes) {
});
for(auto [entt, iv]: registry.view<int>().each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
ASSERT_EQ(entity, entt);
}
}
@@ -423,13 +422,13 @@ TEST(SingleComponentView, DeductionGuide) {
entt::storage_type_t<int> istorage;
entt::storage_type_t<stable_type> sstorage;
static_assert(std::is_same_v<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage})>);
static_assert(std::is_same_v<entt::basic_view<entt::get_t<const entt::storage_type_t<int>>, entt::exclude_t<>>, decltype(entt::basic_view{std::as_const(istorage)})>);
static_assert(std::is_same_v<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<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})>();
static_assert(std::is_same_v<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()})>);
static_assert(std::is_same_v<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))})>);
static_assert(std::is_same_v<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<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)})>();
}
TEST(SingleComponentView, IterableViewAlgorithmCompatibility) {
@@ -476,8 +475,8 @@ TEST(SingleComponentView, StableType) {
});
for(auto [entt, st]: view.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(st), stable_type &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(st), stable_type &>();
ASSERT_EQ(other, entt);
}
@@ -492,14 +491,14 @@ TEST(SingleComponentView, Storage) {
auto view = registry.view<int>();
auto cview = registry.view<const char>();
static_assert(std::is_same_v<decltype(view.storage()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(view.storage<0u>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(view.storage<int>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(view.storage<const int>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(cview.storage()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(cview.storage<0u>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(cview.storage<char>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(cview.storage<const char>()), const entt::storage_type_t<char> *>);
testing::StaticAssertTypeEq<decltype(view.storage()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(view.storage<0u>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(view.storage<int>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(view.storage<const int>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(cview.storage()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(cview.storage<0u>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(cview.storage<char>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(cview.storage<const char>()), const entt::storage_type_t<char> *>();
ASSERT_TRUE(view);
ASSERT_TRUE(cview);
@@ -923,8 +922,8 @@ TEST(MultiComponentView, Each) {
ASSERT_EQ(std::get<0>(*iterable.begin()), entity[1u]);
ASSERT_EQ(std::get<0>(*++citerable.begin()), entity[0u]);
static_assert(std::is_same_v<decltype(std::get<1>(*iterable.begin())), int &>);
static_assert(std::is_same_v<decltype(std::get<2>(*citerable.begin())), const char &>);
testing::StaticAssertTypeEq<decltype(std::get<1>(*iterable.begin())), int &>();
testing::StaticAssertTypeEq<decltype(std::get<2>(*citerable.begin())), const char &>();
// do not use iterable, make sure an iterable view works when created from a temporary
for(auto [entt, ivalue, cvalue]: registry.view<int, char>().each()) {
@@ -1024,29 +1023,29 @@ TEST(MultiComponentView, ConstNonConstAndAllInBetween) {
ASSERT_EQ(view.size_hint(), 1u);
static_assert(std::is_same_v<decltype(view.get<0u>({})), int &>);
static_assert(std::is_same_v<decltype(view.get<2u>({})), const char &>);
static_assert(std::is_same_v<decltype(view.get<0u, 2u>({})), std::tuple<int &, const char &>>);
testing::StaticAssertTypeEq<decltype(view.get<0u>({})), int &>();
testing::StaticAssertTypeEq<decltype(view.get<2u>({})), const char &>();
testing::StaticAssertTypeEq<decltype(view.get<0u, 2u>({})), std::tuple<int &, const char &>>();
static_assert(std::is_same_v<decltype(view.get<int>({})), int &>);
static_assert(std::is_same_v<decltype(view.get<const char>({})), const char &>);
static_assert(std::is_same_v<decltype(view.get<int, const char>({})), std::tuple<int &, const char &>>);
testing::StaticAssertTypeEq<decltype(view.get<int>({})), int &>();
testing::StaticAssertTypeEq<decltype(view.get<const char>({})), const char &>();
testing::StaticAssertTypeEq<decltype(view.get<int, const char>({})), std::tuple<int &, const char &>>();
static_assert(std::is_same_v<decltype(view.get({})), std::tuple<int &, const char &>>);
testing::StaticAssertTypeEq<decltype(view.get({})), std::tuple<int &, const char &>>();
static_assert(std::is_same_v<decltype(std::as_const(registry).view<char, int>()), decltype(std::as_const(registry).view<const char, const int>())>);
static_assert(std::is_same_v<decltype(std::as_const(registry).view<char, const int>()), decltype(std::as_const(registry).view<const char, const int>())>);
static_assert(std::is_same_v<decltype(std::as_const(registry).view<const char, int>()), decltype(std::as_const(registry).view<const char, const int>())>);
testing::StaticAssertTypeEq<decltype(std::as_const(registry).view<char, int>()), decltype(std::as_const(registry).view<const char, const int>())>();
testing::StaticAssertTypeEq<decltype(std::as_const(registry).view<char, const int>()), decltype(std::as_const(registry).view<const char, const int>())>();
testing::StaticAssertTypeEq<decltype(std::as_const(registry).view<const char, int>()), decltype(std::as_const(registry).view<const char, const int>())>();
view.each([](auto &&i, auto &&c) {
static_assert(std::is_same_v<decltype(i), int &>);
static_assert(std::is_same_v<decltype(c), const char &>);
testing::StaticAssertTypeEq<decltype(i), int &>();
testing::StaticAssertTypeEq<decltype(c), const char &>();
});
for(auto [entt, iv, cv]: view.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), const char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), const char &>();
}
}
@@ -1169,9 +1168,9 @@ TEST(MultiComponentView, EmptyTypes) {
});
for(auto [entt, iv, cv]: v1.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
ASSERT_EQ(entity, entt);
}
@@ -1181,9 +1180,9 @@ TEST(MultiComponentView, EmptyTypes) {
});
for(auto [entt, iv, cv]: v2.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
ASSERT_EQ(entity, entt);
}
@@ -1192,9 +1191,9 @@ TEST(MultiComponentView, EmptyTypes) {
});
for(auto [entt, iv, cv]: v3.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
ASSERT_EQ(entity, entt);
}
@@ -1205,9 +1204,9 @@ TEST(MultiComponentView, EmptyTypes) {
v3.use<0u>();
for(auto [entt, iv, cv]: v3.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
ASSERT_EQ(entity, entt);
}
@@ -1219,9 +1218,9 @@ TEST(MultiComponentView, EmptyTypes) {
v2.use<empty_type>();
for(auto [entt, iv, cv]: v2.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(cv), char &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(cv), char &>();
ASSERT_EQ(entity, entt);
}
}
@@ -1250,9 +1249,11 @@ TEST(MultiComponentView, FrontBack) {
TEST(MultiComponentView, ExtendedGet) {
using type = decltype(std::declval<entt::registry>().view<int, empty_type, char>().get({}));
static_assert(std::tuple_size_v<type> == 2u);
static_assert(std::is_same_v<std::tuple_element_t<0, type>, int &>);
static_assert(std::is_same_v<std::tuple_element_t<1, type>, char &>);
ASSERT_EQ(std::tuple_size_v<type>, 2u);
testing::StaticAssertTypeEq<std::tuple_element_t<0, type>, int &>();
testing::StaticAssertTypeEq<std::tuple_element_t<1, type>, char &>();
}
TEST(MultiComponentView, DeductionGuide) {
@@ -1261,23 +1262,23 @@ TEST(MultiComponentView, DeductionGuide) {
entt::storage_type_t<double> dstorage;
entt::storage_type_t<stable_type> sstorage;
static_assert(std::is_same_v<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})>);
static_assert(std::is_same_v<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})>);
static_assert(std::is_same_v<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)})>);
static_assert(std::is_same_v<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)})>);
static_assert(std::is_same_v<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<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})>();
static_assert(std::is_same_v<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()})>);
static_assert(std::is_same_v<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)})>);
static_assert(std::is_same_v<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))})>);
static_assert(std::is_same_v<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))})>);
static_assert(std::is_same_v<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<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)})>();
static_assert(std::is_same_v<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)})>);
static_assert(std::is_same_v<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)})>);
static_assert(std::is_same_v<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))})>);
static_assert(std::is_same_v<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))})>);
static_assert(std::is_same_v<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<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)})>();
}
TEST(MultiComponentView, IterableViewAlgorithmCompatibility) {
@@ -1331,9 +1332,9 @@ TEST(MultiComponentView, StableType) {
});
for(auto [entt, iv, st]: view.each()) {
static_assert(std::is_same_v<decltype(entt), entt::entity>);
static_assert(std::is_same_v<decltype(iv), int &>);
static_assert(std::is_same_v<decltype(st), stable_type &>);
testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
testing::StaticAssertTypeEq<decltype(iv), int &>();
testing::StaticAssertTypeEq<decltype(st), stable_type &>();
ASSERT_EQ(other, entt);
}
@@ -1433,18 +1434,18 @@ TEST(MultiComponentView, Storage) {
const auto entity = registry.create();
auto view = registry.view<int, const char>(entt::exclude<double, const float>);
static_assert(std::is_same_v<decltype(view.storage<0u>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(view.storage<int>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(view.storage<const int>()), entt::storage_type_t<int> *>);
static_assert(std::is_same_v<decltype(view.storage<1u>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(view.storage<char>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(view.storage<const char>()), const entt::storage_type_t<char> *>);
static_assert(std::is_same_v<decltype(view.storage<2u>()), entt::storage_type_t<double> *>);
static_assert(std::is_same_v<decltype(view.storage<double>()), entt::storage_type_t<double> *>);
static_assert(std::is_same_v<decltype(view.storage<const double>()), entt::storage_type_t<double> *>);
static_assert(std::is_same_v<decltype(view.storage<3u>()), const entt::storage_type_t<float> *>);
static_assert(std::is_same_v<decltype(view.storage<float>()), const entt::storage_type_t<float> *>);
static_assert(std::is_same_v<decltype(view.storage<const float>()), const entt::storage_type_t<float> *>);
testing::StaticAssertTypeEq<decltype(view.storage<0u>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(view.storage<int>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(view.storage<const int>()), entt::storage_type_t<int> *>();
testing::StaticAssertTypeEq<decltype(view.storage<1u>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(view.storage<char>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(view.storage<const char>()), const entt::storage_type_t<char> *>();
testing::StaticAssertTypeEq<decltype(view.storage<2u>()), entt::storage_type_t<double> *>();
testing::StaticAssertTypeEq<decltype(view.storage<double>()), entt::storage_type_t<double> *>();
testing::StaticAssertTypeEq<decltype(view.storage<const double>()), entt::storage_type_t<double> *>();
testing::StaticAssertTypeEq<decltype(view.storage<3u>()), const entt::storage_type_t<float> *>();
testing::StaticAssertTypeEq<decltype(view.storage<float>()), const entt::storage_type_t<float> *>();
testing::StaticAssertTypeEq<decltype(view.storage<const float>()), const entt::storage_type_t<float> *>();
ASSERT_TRUE(view);
@@ -1643,9 +1644,9 @@ TEST(View, Pipe) {
auto view3 = registry.view<empty_type>();
auto view4 = registry.view<stable_type>();
static_assert(std::is_same_v<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)>);
static_assert(std::is_same_v<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)>);
static_assert(std::is_same_v<decltype((view3 | view2) | view1), decltype(view3 | (view2 | view1))>);
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)>();
testing::StaticAssertTypeEq<decltype((view3 | view2) | view1), decltype(view3 | (view2 | view1))>();
ASSERT_FALSE((view1 | view2).contains(entity));
ASSERT_TRUE((view1 | view2).contains(other));

4
test/example/signal_less.cpp
View File

@@ -28,8 +28,8 @@ inline constexpr auto has_on_construct_v = has_on_construct<Entity, Type>::value
TEST(Example, SignalLess) {
// invoking registry::on_construct<int> is a compile-time error
static_assert(!has_on_construct_v<entt::entity, int>);
static_assert(has_on_construct_v<entt::entity, char>);
ASSERT_FALSE((has_on_construct_v<entt::entity, int>));
ASSERT_TRUE((has_on_construct_v<entt::entity, char>));
entt::registry registry;
const entt::entity entity[1u]{registry.create()};