test: cleanup

test/entt/core/compressed_pair.cpp

@@ -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>();
 }

test/entt/core/hashed_string.cpp

@@ -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);
 }

test/entt/core/memory.cpp

@@ -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) {

test/entt/core/tuple.cpp

@@ -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);

test/entt/core/type_info.cpp

@@ -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>};

test/entt/core/type_traits.cpp

@@ -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>);
-
-    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_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>);
+
+    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>();
 }

test/entt/entity/component.cpp

@@ -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);
 }

test/entt/entity/group.cpp

@@ -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);
 

test/entt/entity/handle.cpp

@@ -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());

test/entt/entity/snapshot.cpp

@@ -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};

test/entt/entity/storage.cpp

@@ -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>>>();
 }

test/entt/entity/view.cpp

@@ -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})>);
-
-    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)})>);
-
-    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::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, dstorage})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::as_const(istorage), dstorage})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, std::as_const(dstorage)})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::as_const(istorage), std::as_const(dstorage)})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<stable_type>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, sstorage})>();
+
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, dstorage), std::make_tuple()})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage), dstorage)})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, std::as_const(dstorage))})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage), std::as_const(dstorage))})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<stable_type>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, sstorage)})>();
+
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::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));

test/example/signal_less.cpp

@@ -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()};