test: cleanup

test/entt/container/dense_map.cpp

@@ -187,9 +187,9 @@ TEST(DenseMap, Move) {
 TEST(DenseMap, Iterator) {
     using iterator = typename entt::dense_map<int, int>::iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::pair<const int &, int &>>);
-    static_assert(std::is_same_v<iterator::pointer, entt::input_iterator_pointer<std::pair<const int &, int &>>>);
-    static_assert(std::is_same_v<iterator::reference, std::pair<const int &, int &>>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::pair<const int &, int &>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::pair<const int &, int &>>>();
+    testing::StaticAssertTypeEq<iterator::reference, std::pair<const int &, int &>>();
 
     entt::dense_map<int, int> map;
     map.emplace(3, 42);
@@ -240,9 +240,9 @@ TEST(DenseMap, Iterator) {
 TEST(DenseMap, ConstIterator) {
     using iterator = typename entt::dense_map<int, int>::const_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::pair<const int &, const int &>>);
-    static_assert(std::is_same_v<iterator::pointer, entt::input_iterator_pointer<std::pair<const int &, const int &>>>);
-    static_assert(std::is_same_v<iterator::reference, std::pair<const int &, const int &>>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::pair<const int &, const int &>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::pair<const int &, const int &>>>();
+    testing::StaticAssertTypeEq<iterator::reference, std::pair<const int &, const int &>>();
 
     entt::dense_map<int, int> map;
     map.emplace(3, 42);
@@ -297,8 +297,8 @@ TEST(DenseMap, IteratorConversion) {
     typename entt::dense_map<int, int>::iterator it = map.begin();
     typename entt::dense_map<int, int>::const_iterator cit = it;
 
-    static_assert(std::is_same_v<decltype(*it), std::pair<const int &, int &>>);
-    static_assert(std::is_same_v<decltype(*cit), std::pair<const int &, const int &>>);
+    testing::StaticAssertTypeEq<decltype(*it), std::pair<const int &, int &>>();
+    testing::StaticAssertTypeEq<decltype(*cit), std::pair<const int &, const int &>>();
 
     ASSERT_EQ(it->first, 3);
     ASSERT_EQ((*it).second, 42);
@@ -991,9 +991,9 @@ ENTT_DEBUG_TEST(DenseMapDeathTest, Indexing) {
 TEST(DenseMap, LocalIterator) {
     using iterator = typename entt::dense_map<std::size_t, std::size_t, entt::identity>::local_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::pair<const std::size_t &, std::size_t &>>);
-    static_assert(std::is_same_v<iterator::pointer, entt::input_iterator_pointer<std::pair<const std::size_t &, std::size_t &>>>);
-    static_assert(std::is_same_v<iterator::reference, std::pair<const std::size_t &, std::size_t &>>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::pair<const std::size_t &, std::size_t &>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::pair<const std::size_t &, std::size_t &>>>();
+    testing::StaticAssertTypeEq<iterator::reference, std::pair<const std::size_t &, std::size_t &>>();
 
     constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
@@ -1019,9 +1019,9 @@ TEST(DenseMap, LocalIterator) {
 TEST(DenseMap, ConstLocalIterator) {
     using iterator = typename entt::dense_map<std::size_t, std::size_t, entt::identity>::const_local_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::pair<const std::size_t &, const std::size_t &>>);
-    static_assert(std::is_same_v<iterator::pointer, entt::input_iterator_pointer<std::pair<const std::size_t &, const std::size_t &>>>);
-    static_assert(std::is_same_v<iterator::reference, std::pair<const std::size_t &, const std::size_t &>>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::pair<const std::size_t &, const std::size_t &>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::pair<const std::size_t &, const std::size_t &>>>();
+    testing::StaticAssertTypeEq<iterator::reference, std::pair<const std::size_t &, const std::size_t &>>();
 
     constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
@@ -1051,8 +1051,8 @@ TEST(DenseMap, LocalIteratorConversion) {
     typename entt::dense_map<int, int>::local_iterator it = map.begin(map.bucket(3));
     typename entt::dense_map<int, int>::const_local_iterator cit = it;
 
-    static_assert(std::is_same_v<decltype(*it), std::pair<const int &, int &>>);
-    static_assert(std::is_same_v<decltype(*cit), std::pair<const int &, const int &>>);
+    testing::StaticAssertTypeEq<decltype(*it), std::pair<const int &, int &>>();
+    testing::StaticAssertTypeEq<decltype(*cit), std::pair<const int &, const int &>>();
 
     ASSERT_EQ(it->first, 3);
     ASSERT_EQ((*it).second, 42);

test/entt/container/dense_set.cpp

@@ -177,9 +177,9 @@ TEST(DenseSet, Move) {
 TEST(DenseSet, Iterator) {
     using iterator = typename entt::dense_set<int>::iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, int>);
-    static_assert(std::is_same_v<iterator::pointer, const int *>);
-    static_assert(std::is_same_v<iterator::reference, const int &>);
+    testing::StaticAssertTypeEq<iterator::value_type, int>();
+    testing::StaticAssertTypeEq<iterator::pointer, const int *>();
+    testing::StaticAssertTypeEq<iterator::reference, const int &>();
 
     entt::dense_set<int> set;
     set.emplace(3);
@@ -230,9 +230,9 @@ TEST(DenseSet, Iterator) {
 TEST(DenseSet, ConstIterator) {
     using iterator = typename entt::dense_set<int>::const_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, int>);
-    static_assert(std::is_same_v<iterator::pointer, const int *>);
-    static_assert(std::is_same_v<iterator::reference, const int &>);
+    testing::StaticAssertTypeEq<iterator::value_type, int>();
+    testing::StaticAssertTypeEq<iterator::pointer, const int *>();
+    testing::StaticAssertTypeEq<iterator::reference, const int &>();
 
     entt::dense_set<int> set;
     set.emplace(3);
@@ -283,9 +283,9 @@ TEST(DenseSet, ConstIterator) {
 TEST(DenseSet, ReverseIterator) {
     using iterator = typename entt::dense_set<int>::reverse_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, int>);
-    static_assert(std::is_same_v<iterator::pointer, const int *>);
-    static_assert(std::is_same_v<iterator::reference, const int &>);
+    testing::StaticAssertTypeEq<iterator::value_type, int>();
+    testing::StaticAssertTypeEq<iterator::pointer, const int *>();
+    testing::StaticAssertTypeEq<iterator::reference, const int &>();
 
     entt::dense_set<int> set;
     set.emplace(3);
@@ -336,9 +336,9 @@ TEST(DenseSet, ReverseIterator) {
 TEST(DenseSet, ConstReverseIterator) {
     using iterator = typename entt::dense_set<int>::const_reverse_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, int>);
-    static_assert(std::is_same_v<iterator::pointer, const int *>);
-    static_assert(std::is_same_v<iterator::reference, const int &>);
+    testing::StaticAssertTypeEq<iterator::value_type, int>();
+    testing::StaticAssertTypeEq<iterator::pointer, const int *>();
+    testing::StaticAssertTypeEq<iterator::reference, const int &>();
 
     entt::dense_set<int> set;
     set.emplace(3);
@@ -393,8 +393,8 @@ TEST(DenseSet, IteratorConversion) {
     typename entt::dense_set<int, int>::iterator it = set.begin();
     typename entt::dense_set<int, int>::const_iterator cit = it;
 
-    static_assert(std::is_same_v<decltype(*it), const int &>);
-    static_assert(std::is_same_v<decltype(*cit), const int &>);
+    testing::StaticAssertTypeEq<decltype(*it), const int &>();
+    testing::StaticAssertTypeEq<decltype(*cit), const int &>();
 
     ASSERT_EQ(*it, 3);
     ASSERT_EQ(*it.operator->(), 3);
@@ -823,9 +823,9 @@ TEST(DenseSet, EqualRange) {
 TEST(DenseSet, LocalIterator) {
     using iterator = typename entt::dense_set<std::size_t, entt::identity>::local_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::size_t>);
-    static_assert(std::is_same_v<iterator::pointer, const std::size_t *>);
-    static_assert(std::is_same_v<iterator::reference, const std::size_t &>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::size_t>();
+    testing::StaticAssertTypeEq<iterator::pointer, const std::size_t *>();
+    testing::StaticAssertTypeEq<iterator::reference, const std::size_t &>();
 
     constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
@@ -851,9 +851,9 @@ TEST(DenseSet, LocalIterator) {
 TEST(DenseSet, ConstLocalIterator) {
     using iterator = typename entt::dense_set<std::size_t, entt::identity>::const_local_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::size_t>);
-    static_assert(std::is_same_v<iterator::pointer, const std::size_t *>);
-    static_assert(std::is_same_v<iterator::reference, const std::size_t &>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::size_t>();
+    testing::StaticAssertTypeEq<iterator::pointer, const std::size_t *>();
+    testing::StaticAssertTypeEq<iterator::reference, const std::size_t &>();
 
     constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
@@ -883,8 +883,8 @@ TEST(DenseSet, LocalIteratorConversion) {
     typename entt::dense_set<int>::local_iterator it = set.begin(set.bucket(3));
     typename entt::dense_set<int>::const_local_iterator cit = it;
 
-    static_assert(std::is_same_v<decltype(*it), const int &>);
-    static_assert(std::is_same_v<decltype(*cit), const int &>);
+    testing::StaticAssertTypeEq<decltype(*it), const int &>();
+    testing::StaticAssertTypeEq<decltype(*cit), const int &>();
 
     ASSERT_EQ(*it, 3);
     ASSERT_EQ(*it.operator->(), 3);

test/entt/entity/registry.cpp

@@ -3,7 +3,6 @@
 #include <iterator>
 #include <memory>
 #include <tuple>
-#include <type_traits>
 #include <unordered_set>
 #include <utility>
 #include <gtest/gtest.h>
@@ -1914,36 +1913,36 @@ TEST(Registry, GetOrEmplace) {
 TEST(Registry, Constness) {
     entt::registry registry;
 
-    static_assert((std::is_same_v<decltype(registry.emplace<int>({})), int &>));
-    static_assert((std::is_same_v<decltype(registry.emplace<empty_type>({})), void>));
+    testing::StaticAssertTypeEq<decltype(registry.emplace<int>({})), int &>();
+    testing::StaticAssertTypeEq<decltype(registry.emplace<empty_type>({})), void>();
 
-    static_assert((std::is_same_v<decltype(registry.get<>({})), std::tuple<>>));
-    static_assert((std::is_same_v<decltype(registry.get<int>({})), int &>));
-    static_assert((std::is_same_v<decltype(registry.get<int, const char>({})), std::tuple<int &, const char &>>));
+    testing::StaticAssertTypeEq<decltype(registry.get<>({})), std::tuple<>>();
+    testing::StaticAssertTypeEq<decltype(registry.get<int>({})), int &>();
+    testing::StaticAssertTypeEq<decltype(registry.get<int, const char>({})), std::tuple<int &, const char &>>();
 
-    static_assert((std::is_same_v<decltype(registry.try_get<>({})), std::tuple<>>));
-    static_assert((std::is_same_v<decltype(registry.try_get<int>({})), int *>));
-    static_assert((std::is_same_v<decltype(registry.try_get<int, const char>({})), std::tuple<int *, const char *>>));
+    testing::StaticAssertTypeEq<decltype(registry.try_get<>({})), std::tuple<>>();
+    testing::StaticAssertTypeEq<decltype(registry.try_get<int>({})), int *>();
+    testing::StaticAssertTypeEq<decltype(registry.try_get<int, const char>({})), std::tuple<int *, const char *>>();
 
-    static_assert((std::is_same_v<decltype(registry.ctx().get<int>()), int &>));
-    static_assert((std::is_same_v<decltype(registry.ctx().get<const char>()), const char &>));
+    testing::StaticAssertTypeEq<decltype(registry.ctx().get<int>()), int &>();
+    testing::StaticAssertTypeEq<decltype(registry.ctx().get<const char>()), const char &>();
 
-    static_assert((std::is_same_v<decltype(registry.ctx().find<int>()), int *>));
-    static_assert((std::is_same_v<decltype(registry.ctx().find<const char>()), const char *>));
+    testing::StaticAssertTypeEq<decltype(registry.ctx().find<int>()), int *>();
+    testing::StaticAssertTypeEq<decltype(registry.ctx().find<const char>()), const char *>();
 
-    static_assert((std::is_same_v<decltype(std::as_const(registry).get<>({})), std::tuple<>>));
-    static_assert((std::is_same_v<decltype(std::as_const(registry).get<int>({})), const int &>));
-    static_assert((std::is_same_v<decltype(std::as_const(registry).get<int, const char>({})), std::tuple<const int &, const char &>>));
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).get<>({})), std::tuple<>>();
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).get<int>({})), const int &>();
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).get<int, const char>({})), std::tuple<const int &, const char &>>();
 
-    static_assert((std::is_same_v<decltype(std::as_const(registry).try_get<>({})), std::tuple<>>));
-    static_assert((std::is_same_v<decltype(std::as_const(registry).try_get<int>({})), const int *>));
-    static_assert((std::is_same_v<decltype(std::as_const(registry).try_get<int, const char>({})), std::tuple<const int *, const char *>>));
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).try_get<>({})), std::tuple<>>();
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).try_get<int>({})), const int *>();
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).try_get<int, const char>({})), std::tuple<const int *, const char *>>();
 
-    static_assert((std::is_same_v<decltype(std::as_const(registry).ctx().get<int>()), const int &>));
-    static_assert((std::is_same_v<decltype(std::as_const(registry).ctx().get<const char>()), const char &>));
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).ctx().get<int>()), const int &>();
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).ctx().get<const char>()), const char &>();
 
-    static_assert((std::is_same_v<decltype(std::as_const(registry).ctx().find<int>()), const int *>));
-    static_assert((std::is_same_v<decltype(std::as_const(registry).ctx().find<const char>()), const char *>));
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).ctx().find<int>()), const int *>();
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).ctx().find<const char>()), const char *>();
 }
 
 TEST(Registry, MoveOnlyComponent) {
@@ -2046,11 +2045,11 @@ TEST(Registry, RuntimePools) {
     auto &storage = registry.storage<empty_type>("other"_hs);
     const auto entity = registry.create();
 
-    static_assert(std::is_same_v<decltype(registry.storage<empty_type>()), entt::storage_type_t<empty_type> &>);
-    static_assert(std::is_same_v<decltype(std::as_const(registry).storage<empty_type>()), const entt::storage_type_t<empty_type> *>);
+    testing::StaticAssertTypeEq<decltype(registry.storage<empty_type>()), entt::storage_type_t<empty_type> &>();
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).storage<empty_type>()), const entt::storage_type_t<empty_type> *>();
 
-    static_assert(std::is_same_v<decltype(registry.storage("other"_hs)), entt::storage_type_t<empty_type>::base_type *>);
-    static_assert(std::is_same_v<decltype(std::as_const(registry).storage("other"_hs)), const entt::storage_type_t<empty_type>::base_type *>);
+    testing::StaticAssertTypeEq<decltype(registry.storage("other"_hs)), entt::storage_type_t<empty_type>::base_type *>();
+    testing::StaticAssertTypeEq<decltype(std::as_const(registry).storage("other"_hs)), const entt::storage_type_t<empty_type>::base_type *>();
 
     ASSERT_NE(registry.storage("other"_hs), nullptr);
     ASSERT_EQ(std::as_const(registry).storage("rehto"_hs), nullptr);
@@ -2101,8 +2100,8 @@ TEST(Registry, Storage) {
     storage.emplace(entity);
 
     for(auto [id, pool]: registry.storage()) {
-        static_assert(std::is_same_v<decltype(pool), entt::sparse_set &>);
-        static_assert(std::is_same_v<decltype(id), entt::id_type>);
+        testing::StaticAssertTypeEq<decltype(pool), entt::sparse_set &>();
+        testing::StaticAssertTypeEq<decltype(id), entt::id_type>();
 
         ASSERT_TRUE(pool.contains(entity));
         ASSERT_EQ(std::addressof(storage), std::addressof(pool));
@@ -2110,8 +2109,8 @@ TEST(Registry, Storage) {
     }
 
     for(auto &&curr: std::as_const(registry).storage()) {
-        static_assert(std::is_same_v<decltype(curr.second), const entt::sparse_set &>);
-        static_assert(std::is_same_v<decltype(curr.first), entt::id_type>);
+        testing::StaticAssertTypeEq<decltype(curr.second), const entt::sparse_set &>();
+        testing::StaticAssertTypeEq<decltype(curr.first), entt::id_type>();
 
         ASSERT_TRUE(curr.second.contains(entity));
         ASSERT_EQ(std::addressof(storage), std::addressof(curr.second));
@@ -2184,8 +2183,8 @@ TEST(Registry, RegistryStorageIteratorConversion) {
     typename decltype(proxy)::iterator it = proxy.begin();
     typename decltype(cproxy)::iterator cit = it;
 
-    static_assert(std::is_same_v<decltype(*it), std::pair<entt::id_type, entt::sparse_set &>>);
-    static_assert(std::is_same_v<decltype(*cit), std::pair<entt::id_type, const entt::sparse_set &>>);
+    testing::StaticAssertTypeEq<decltype(*it), std::pair<entt::id_type, entt::sparse_set &>>();
+    testing::StaticAssertTypeEq<decltype(*cit), std::pair<entt::id_type, const entt::sparse_set &>>();
 
     ASSERT_EQ(it->first, entt::type_id<int>().hash());
     ASSERT_EQ((*it).second.type(), entt::type_id<int>());

test/entt/entity/runtime_view.cpp

@@ -1,5 +1,4 @@
 #include <algorithm>
-#include <type_traits>
 #include <utility>
 #include <gtest/gtest.h>
 #include <entt/entity/entity.hpp>
@@ -361,7 +360,7 @@ TYPED_TEST(RuntimeView, StableType) {
     });
 
     for(auto entt: view) {
-        static_assert(std::is_same_v<decltype(entt), entt::entity>);
+        testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
         ASSERT_EQ(e0, entt);
     }
 

test/entt/entity/sparse_set.cpp

@@ -1,7 +1,6 @@
 #include <algorithm>
 #include <functional>
 #include <iterator>
-#include <type_traits>
 #include <utility>
 #include <gtest/gtest.h>
 #include <entt/entity/entity.hpp>
@@ -1204,9 +1203,9 @@ TEST(SparseSet, Contiguous) {
 TEST(SparseSet, Iterator) {
     using iterator = typename entt::sparse_set::iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, entt::entity>);
-    static_assert(std::is_same_v<iterator::pointer, const entt::entity *>);
-    static_assert(std::is_same_v<iterator::reference, const entt::entity &>);
+    testing::StaticAssertTypeEq<iterator::value_type, entt::entity>();
+    testing::StaticAssertTypeEq<iterator::pointer, const entt::entity *>();
+    testing::StaticAssertTypeEq<iterator::reference, const entt::entity &>();
 
     entt::sparse_set set;
     set.push(entt::entity{3});
@@ -1275,9 +1274,9 @@ TEST(SparseSet, Iterator) {
 TEST(SparseSet, ReverseIterator) {
     using reverse_iterator = typename entt::sparse_set::reverse_iterator;
 
-    static_assert(std::is_same_v<reverse_iterator::value_type, entt::entity>);
-    static_assert(std::is_same_v<reverse_iterator::pointer, const entt::entity *>);
-    static_assert(std::is_same_v<reverse_iterator::reference, const entt::entity &>);
+    testing::StaticAssertTypeEq<reverse_iterator::value_type, entt::entity>();
+    testing::StaticAssertTypeEq<reverse_iterator::pointer, const entt::entity *>();
+    testing::StaticAssertTypeEq<reverse_iterator::reference, const entt::entity &>();
 
     entt::sparse_set set;
     set.push(entt::entity{3});

test/entt/entity/storage_entity.cpp

@@ -1,3 +1,6 @@
+#include <algorithm>
+#include <iterator>
+#include <tuple>
 #include <type_traits>
 #include <utility>
 #include <gtest/gtest.h>
@@ -301,9 +304,9 @@ TEST(StorageEntity, Pack) {
 TEST(StorageEntity, Iterable) {
     using iterator = typename entt::storage<entt::entity>::iterable::iterator;
 
-    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<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
+    testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
 
     entt::storage<entt::entity> pool;
 
@@ -337,7 +340,7 @@ TEST(StorageEntity, Iterable) {
     ASSERT_EQ(begin.base(), pool.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{3});
     }
 }
@@ -345,9 +348,9 @@ TEST(StorageEntity, Iterable) {
 TEST(StorageEntity, ConstIterable) {
     using iterator = typename entt::storage<entt::entity>::const_iterable::iterator;
 
-    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<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
+    testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
 
     entt::storage<entt::entity> pool;
 
@@ -381,7 +384,7 @@ TEST(StorageEntity, ConstIterable) {
     ASSERT_EQ(begin.base(), pool.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{3});
     }
 }
@@ -393,8 +396,8 @@ TEST(StorageEntity, IterableIteratorConversion) {
     typename entt::storage<entt::entity>::iterable::iterator it = pool.each().begin();
     typename entt::storage<entt::entity>::const_iterable::iterator cit = it;
 
-    static_assert(std::is_same_v<decltype(*it), std::tuple<entt::entity>>);
-    static_assert(std::is_same_v<decltype(*cit), std::tuple<entt::entity>>);
+    testing::StaticAssertTypeEq<decltype(*it), std::tuple<entt::entity>>();
+    testing::StaticAssertTypeEq<decltype(*cit), std::tuple<entt::entity>>();
 
     ASSERT_EQ(it, cit);
     ASSERT_NE(++cit, it);
@@ -413,9 +416,9 @@ TEST(StorageEntity, IterableAlgorithmCompatibility) {
 TEST(StorageEntity, ReverseIterable) {
     using iterator = typename entt::storage<entt::entity>::reverse_iterable::iterator;
 
-    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<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
+    testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
 
     entt::storage<entt::entity> pool;
 
@@ -449,7 +452,7 @@ TEST(StorageEntity, ReverseIterable) {
     ASSERT_EQ(begin.base(), pool.rbegin() + 2);
 
     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{3});
     }
 }
@@ -457,9 +460,9 @@ TEST(StorageEntity, ReverseIterable) {
 TEST(StorageEntity, ReverseConstIterable) {
     using iterator = typename entt::storage<entt::entity>::const_reverse_iterable::iterator;
 
-    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<typename iterator::pointer, entt::input_iterator_pointer<std::tuple<entt::entity>>>();
+    testing::StaticAssertTypeEq<typename iterator::reference, typename iterator::value_type>();
 
     entt::storage<entt::entity> pool;
 
@@ -493,7 +496,7 @@ TEST(StorageEntity, ReverseConstIterable) {
     ASSERT_EQ(begin.base(), pool.rbegin() + 2);
 
     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{3});
     }
 }
@@ -505,8 +508,8 @@ TEST(StorageEntity, ReverseIterableIteratorConversion) {
     typename entt::storage<entt::entity>::reverse_iterable::iterator it = pool.reach().begin();
     typename entt::storage<entt::entity>::const_reverse_iterable::iterator cit = it;
 
-    static_assert(std::is_same_v<decltype(*it), std::tuple<entt::entity>>);
-    static_assert(std::is_same_v<decltype(*cit), std::tuple<entt::entity>>);
+    testing::StaticAssertTypeEq<decltype(*it), std::tuple<entt::entity>>();
+    testing::StaticAssertTypeEq<decltype(*cit), std::tuple<entt::entity>>();
 
     ASSERT_EQ(it, cit);
     ASSERT_NE(++cit, it);

test/entt/graph/adjacency_matrix.cpp

@@ -203,9 +203,9 @@ TEST(AdjacencyMatrix, Clear) {
 TEST(AdjacencyMatrix, VertexIterator) {
     using iterator = typename entt::adjacency_matrix<entt::directed_tag>::vertex_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::size_t>);
-    static_assert(std::is_same_v<iterator::pointer, void>);
-    static_assert(std::is_same_v<iterator::reference, std::size_t>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::size_t>();
+    testing::StaticAssertTypeEq<iterator::pointer, void>();
+    testing::StaticAssertTypeEq<iterator::reference, std::size_t>();
 
     entt::adjacency_matrix<entt::directed_tag> adjacency_matrix{2u};
     const auto iterable = adjacency_matrix.vertices();
@@ -229,9 +229,9 @@ TEST(AdjacencyMatrix, VertexIterator) {
 TEST(AdjacencyMatrix, EdgeIterator) {
     using iterator = typename entt::adjacency_matrix<entt::directed_tag>::edge_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::pair<std::size_t, std::size_t>>);
-    static_assert(std::is_same_v<iterator::pointer, entt::input_iterator_pointer<std::pair<std::size_t, std::size_t>>>);
-    static_assert(std::is_same_v<iterator::reference, std::pair<std::size_t, std::size_t>>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::pair<std::size_t, std::size_t>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::pair<std::size_t, std::size_t>>>();
+    testing::StaticAssertTypeEq<iterator::reference, std::pair<std::size_t, std::size_t>>();
 
     entt::adjacency_matrix<entt::directed_tag> adjacency_matrix{3u};
 

test/entt/meta/meta_range.cpp

@@ -1,4 +1,4 @@
-#include <type_traits>
+#include <utility>
 #include <gtest/gtest.h>
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/type_info.hpp>
@@ -31,9 +31,9 @@ TEST_F(MetaRange, Iterator) {
 
     using iterator = typename decltype(entt::resolve())::iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::pair<entt::id_type, entt::meta_type>>);
-    static_assert(std::is_same_v<iterator::pointer, entt::input_iterator_pointer<std::pair<entt::id_type, entt::meta_type>>>);
-    static_assert(std::is_same_v<iterator::reference, std::pair<entt::id_type, entt::meta_type>>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::pair<entt::id_type, entt::meta_type>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::pair<entt::id_type, entt::meta_type>>>();
+    testing::StaticAssertTypeEq<iterator::reference, std::pair<entt::id_type, entt::meta_type>>();
 
     auto range = entt::resolve();
 

test/entt/resource/resource.cpp

@@ -1,3 +1,5 @@
+#include <memory>
+#include <utility>
 #include <gtest/gtest.h>
 #include <entt/core/type_info.hpp>
 #include <entt/resource/resource.hpp>
@@ -77,9 +79,9 @@ TEST(Resource, ConstNonConstAndAllInBetween) {
     entt::resource<derived> resource{std::make_shared<derived>()};
     entt::resource<derived> other{resource};
 
-    static_assert(std::is_same_v<decltype(*resource), derived &>);
-    static_assert(std::is_same_v<decltype(*entt::resource<const derived>{other}), const derived &>);
-    static_assert(std::is_same_v<decltype(*std::as_const(resource)), derived &>);
+    testing::StaticAssertTypeEq<decltype(*resource), derived &>();
+    testing::StaticAssertTypeEq<decltype(*entt::resource<const derived>{other}), const derived &>();
+    testing::StaticAssertTypeEq<decltype(*std::as_const(resource)), derived &>();
 
     entt::resource<const derived> copy{resource};
     entt::resource<const derived> move{std::move(other)};

test/entt/resource/resource_cache.cpp

@@ -147,9 +147,9 @@ TEST(ResourceCache, Iterator) {
 
     using iterator = typename entt::resource_cache<int>::iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::pair<entt::id_type, entt::resource<int>>>);
-    static_assert(std::is_same_v<iterator::pointer, entt::input_iterator_pointer<std::pair<entt::id_type, entt::resource<int>>>>);
-    static_assert(std::is_same_v<iterator::reference, std::pair<entt::id_type, entt::resource<int>>>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::pair<entt::id_type, entt::resource<int>>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::pair<entt::id_type, entt::resource<int>>>>();
+    testing::StaticAssertTypeEq<iterator::reference, std::pair<entt::id_type, entt::resource<int>>>();
 
     entt::resource_cache<int> cache;
     cache.load("resource"_hs, 42);
@@ -202,9 +202,9 @@ TEST(ResourceCache, ConstIterator) {
 
     using iterator = typename entt::resource_cache<int>::const_iterator;
 
-    static_assert(std::is_same_v<iterator::value_type, std::pair<entt::id_type, entt::resource<const int>>>);
-    static_assert(std::is_same_v<iterator::pointer, entt::input_iterator_pointer<std::pair<entt::id_type, entt::resource<const int>>>>);
-    static_assert(std::is_same_v<iterator::reference, std::pair<entt::id_type, entt::resource<const int>>>);
+    testing::StaticAssertTypeEq<iterator::value_type, std::pair<entt::id_type, entt::resource<const int>>>();
+    testing::StaticAssertTypeEq<iterator::pointer, entt::input_iterator_pointer<std::pair<entt::id_type, entt::resource<const int>>>>();
+    testing::StaticAssertTypeEq<iterator::reference, std::pair<entt::id_type, entt::resource<const int>>>();
 
     entt::resource_cache<int> cache;
     cache.load("resource"_hs, 42);
@@ -261,8 +261,8 @@ TEST(ResourceCache, IteratorConversion) {
     typename entt::resource_cache<int>::iterator it = cache.begin();
     typename entt::resource_cache<int>::const_iterator cit = it;
 
-    static_assert(std::is_same_v<decltype(*it), std::pair<entt::id_type, entt::resource<int>>>);
-    static_assert(std::is_same_v<decltype(*cit), std::pair<entt::id_type, entt::resource<const int>>>);
+    testing::StaticAssertTypeEq<decltype(*it), std::pair<entt::id_type, entt::resource<int>>>();
+    testing::StaticAssertTypeEq<decltype(*cit), std::pair<entt::id_type, entt::resource<const int>>>();
 
     ASSERT_EQ(it->first, "resource"_hs);
     ASSERT_EQ((*it).second, 42);

test/entt/resource/resource_loader.cpp

@@ -1,4 +1,3 @@
-#include <type_traits>
 #include <gtest/gtest.h>
 #include <entt/resource/loader.hpp>
 
@@ -6,7 +5,7 @@ TEST(ResourceLoader, Functionalities) {
     using loader_type = entt::resource_loader<int>;
     const auto resource = loader_type{}(42);
 
-    static_assert(std::is_same_v<typename loader_type::result_type, std::shared_ptr<int>>);
+    testing::StaticAssertTypeEq<typename loader_type::result_type, std::shared_ptr<int>>();
 
     ASSERT_TRUE(resource);
     ASSERT_EQ(*resource, 42);

test/entt/signal/delegate.cpp

@@ -1,5 +1,4 @@
 #include <memory>
-#include <type_traits>
 #include <utility>
 #include <gtest/gtest.h>
 #include <entt/signal/delegate.hpp>
@@ -275,21 +274,21 @@ TEST(Delegate, DeductionGuide) {
     entt::delegate data_member_v_const{entt::connect_arg<&const_nonconst_noexcept::v>, &std::as_const(functor)};
     entt::delegate lambda{+[](const void *, int) { return 0; }};
 
-    static_assert(std::is_same_v<typename decltype(plain_func)::type, int(const int &)>);
-    static_assert(std::is_same_v<typename decltype(sum_func_with_ref)::type, int(int)>);
-    static_assert(std::is_same_v<typename decltype(sum_func_with_const_ref)::type, int(int)>);
-    static_assert(std::is_same_v<typename decltype(sum_func_with_ptr)::type, int(int)>);
-    static_assert(std::is_same_v<typename decltype(sum_func_with_const_ptr)::type, int(int)>);
-    static_assert(std::is_same_v<typename decltype(member_func_f)::type, void()>);
-    static_assert(std::is_same_v<typename decltype(member_func_g)::type, void()>);
-    static_assert(std::is_same_v<typename decltype(member_func_h)::type, void()>);
-    static_assert(std::is_same_v<typename decltype(member_func_h_const)::type, void()>);
-    static_assert(std::is_same_v<typename decltype(member_func_i)::type, void()>);
-    static_assert(std::is_same_v<typename decltype(member_func_i_const)::type, void()>);
-    static_assert(std::is_same_v<typename decltype(data_member_u)::type, int()>);
-    static_assert(std::is_same_v<typename decltype(data_member_v)::type, const int()>);
-    static_assert(std::is_same_v<typename decltype(data_member_v_const)::type, const int()>);
-    static_assert(std::is_same_v<typename decltype(lambda)::type, int(int)>);
+    testing::StaticAssertTypeEq<typename decltype(plain_func)::type, int(const int &)>();
+    testing::StaticAssertTypeEq<typename decltype(sum_func_with_ref)::type, int(int)>();
+    testing::StaticAssertTypeEq<typename decltype(sum_func_with_const_ref)::type, int(int)>();
+    testing::StaticAssertTypeEq<typename decltype(sum_func_with_ptr)::type, int(int)>();
+    testing::StaticAssertTypeEq<typename decltype(sum_func_with_const_ptr)::type, int(int)>();
+    testing::StaticAssertTypeEq<typename decltype(member_func_f)::type, void()>();
+    testing::StaticAssertTypeEq<typename decltype(member_func_g)::type, void()>();
+    testing::StaticAssertTypeEq<typename decltype(member_func_h)::type, void()>();
+    testing::StaticAssertTypeEq<typename decltype(member_func_h_const)::type, void()>();
+    testing::StaticAssertTypeEq<typename decltype(member_func_i)::type, void()>();
+    testing::StaticAssertTypeEq<typename decltype(member_func_i_const)::type, void()>();
+    testing::StaticAssertTypeEq<typename decltype(data_member_u)::type, int()>();
+    testing::StaticAssertTypeEq<typename decltype(data_member_v)::type, const int()>();
+    testing::StaticAssertTypeEq<typename decltype(data_member_v_const)::type, const int()>();
+    testing::StaticAssertTypeEq<typename decltype(lambda)::type, int(int)>();
 
     ASSERT_TRUE(plain_func);
     ASSERT_TRUE(sum_func_with_ref);