test: suppress all death tests in release

test/entt/container/dense_map.cpp

@@ -11,6 +11,7 @@
 #include <entt/core/iterator.hpp>
 #include <entt/core/memory.hpp>
 #include <entt/core/utility.hpp>
+#include "../common/config.h"
 #include "../common/throwing_allocator.hpp"
 #include "../common/tracked_memory_resource.hpp"
 
@@ -931,7 +932,7 @@ TEST(DenseMap, Indexing) {
     ASSERT_EQ(map.at(key), 99);
 }
 
-TEST(DenseMapDeathTest, Indexing) {
+ENTT_DEBUG_TEST(DenseMapDeathTest, Indexing) {
     entt::dense_map<int, int> map;
 
     ASSERT_DEATH([[maybe_unused]] auto value = std::as_const(map).at(0), "");

test/entt/core/any.cpp

@@ -9,6 +9,7 @@
 #include <gtest/gtest.h>
 #include <entt/core/any.hpp>
 #include <entt/core/type_info.hpp>
+#include "../common/config.h"
 
 struct empty {
     ~empty() {
@@ -1192,7 +1193,7 @@ TEST_F(Any, AnyCast) {
     ASSERT_EQ(entt::any_cast<int>(entt::any{42}), 42);
 }
 
-TEST_F(AnyDeathTest, AnyCast) {
+ENTT_DEBUG_TEST_F(AnyDeathTest, AnyCast) {
     entt::any any{42};
     const auto &cany = any;
 

test/entt/core/memory.cpp

@@ -9,6 +9,7 @@
 #include <gtest/gtest.h>
 #include <entt/core/memory.hpp>
 #include "../common/basic_test_allocator.hpp"
+#include "../common/config.h"
 #include "../common/throwing_allocator.hpp"
 #include "../common/throwing_type.hpp"
 #include "../common/tracked_memory_resource.hpp"
@@ -57,7 +58,7 @@ TEST(NextPowerOfTwo, Functionalities) {
     ASSERT_EQ(entt::next_power_of_two(std::pow(2, 16) + 1u), std::pow(2, 17));
 }
 
-TEST(NextPowerOfTwoDeathTest, Functionalities) {
+ENTT_DEBUG_TEST(NextPowerOfTwoDeathTest, Functionalities) {
     ASSERT_DEATH(static_cast<void>(entt::next_power_of_two((std::size_t{1u} << (std::numeric_limits<std::size_t>::digits - 1)) + 1)), "");
 }
 

test/entt/entity/registry.cpp

@@ -11,6 +11,7 @@
 #include <entt/core/type_info.hpp>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/registry.hpp>
+#include "../common/config.h"
 
 struct empty_type {};
 
@@ -583,7 +584,7 @@ TEST(Registry, DestroyVersion) {
     ASSERT_EQ(registry.current(e1), 3u);
 }
 
-TEST(RegistryDeathTest, DestroyVersion) {
+ENTT_DEBUG_TEST(RegistryDeathTest, DestroyVersion) {
     entt::registry registry;
     const auto entity = registry.create();
 
@@ -709,7 +710,7 @@ TEST(Registry, ReleaseVersion) {
     ASSERT_EQ(registry.current(entities[1u]), 3u);
 }
 
-TEST(RegistryDeathTest, ReleaseVersion) {
+ENTT_DEBUG_TEST(RegistryDeathTest, ReleaseVersion) {
     entt::registry registry;
     entt::entity entity = registry.create();
 
@@ -1519,7 +1520,7 @@ TEST(Registry, Erase) {
     ASSERT_TRUE(registry.orphan(entities[2u]));
 }
 
-TEST(RegistryDeathTest, Erase) {
+ENTT_DEBUG_TEST(RegistryDeathTest, Erase) {
     entt::registry registry;
     const entt::entity entities[1u]{registry.create()};
 
@@ -1978,7 +1979,7 @@ TEST(Registry, RuntimePools) {
     ASSERT_FALSE(registry.any_of<empty_type>(entity));
 }
 
-TEST(RegistryDeathTest, RuntimePools) {
+ENTT_DEBUG_TEST(RegistryDeathTest, RuntimePools) {
     using namespace entt::literals;
 
     entt::registry registry;

test/entt/entity/sparse_set.cpp

@@ -6,6 +6,7 @@
 #include <gtest/gtest.h>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/sparse_set.hpp>
+#include "../common/config.h"
 #include "../common/throwing_allocator.hpp"
 
 struct empty_type {};
@@ -163,7 +164,7 @@ TEST(SparseSet, Index) {
     ASSERT_EQ(set.index(traits_type::construct(3, 3)), 0u);
 }
 
-TEST(SparseSetDeathTest, Index) {
+ENTT_DEBUG_TEST(SparseSetDeathTest, Index) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::sparse_set set{};
@@ -290,7 +291,7 @@ TEST(SparseSet, Emplace) {
     ASSERT_EQ(set.index(entities[1u]), 0u);
 }
 
-TEST(SparseSetDeathTest, Emplace) {
+ENTT_DEBUG_TEST(SparseSetDeathTest, Emplace) {
     entt::sparse_set set{entt::deletion_policy::in_place};
     set.emplace(entt::entity{42});
 
@@ -334,7 +335,7 @@ TEST(SparseSet, Bump) {
     ASSERT_EQ(set.current(entities[2u]), 0u);
 }
 
-TEST(SparseSetDeathTest, Bump) {
+ENTT_DEBUG_TEST(SparseSetDeathTest, Bump) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::sparse_set set{entt::deletion_policy::in_place};
@@ -426,7 +427,7 @@ TEST(SparseSet, Erase) {
     ASSERT_EQ(*set.begin(), entities[2u]);
 }
 
-TEST(SparseSetDeathTest, Erase) {
+ENTT_DEBUG_TEST(SparseSetDeathTest, Erase) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::sparse_set set;
@@ -550,7 +551,7 @@ TEST(SparseSet, StableErase) {
     ASSERT_NE(set.current(entities[2u]), traits_type::to_version(entt::tombstone));
 }
 
-TEST(SparseSetDeathTest, StableErase) {
+ENTT_DEBUG_TEST(SparseSetDeathTest, StableErase) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::sparse_set set{entt::deletion_policy::in_place};
@@ -811,7 +812,7 @@ TEST(SparseSet, SwapEntity) {
     ASSERT_EQ(set.index(traits_type::construct(42, 99)), 1u);
 }
 
-TEST(SparseSetDeathTest, SwapEntity) {
+ENTT_DEBUG_TEST(SparseSetDeathTest, SwapEntity) {
     entt::sparse_set set;
 
     ASSERT_TRUE(set.empty());
@@ -1106,7 +1107,7 @@ TEST(SparseSet, SortRange) {
     ASSERT_EQ(begin, end);
 }
 
-TEST(SparseSetDeathTest, SortRange) {
+ENTT_DEBUG_TEST(SparseSetDeathTest, SortRange) {
     entt::sparse_set set{entt::deletion_policy::in_place};
     entt::entity entity{42};
 

test/entt/locator/locator.cpp

@@ -1,6 +1,7 @@
 #include <memory>
 #include <gtest/gtest.h>
 #include <entt/locator/locator.hpp>
+#include "../common/config.h"
 
 struct base_service {
     virtual ~base_service() = default;
@@ -59,7 +60,7 @@ TEST(ServiceLocator, Functionalities) {
     ASSERT_TRUE(derived_service::invoked);
 }
 
-TEST(ServiceLocatorDeathTest, UninitializedValue) {
+ENTT_DEBUG_TEST(ServiceLocatorDeathTest, UninitializedValue) {
     ASSERT_NO_FATAL_FAILURE(entt::locator<base_service>::value_or().invoke());
 
     entt::locator<base_service>::reset();

test/entt/meta/meta_any.cpp

@@ -8,6 +8,7 @@
 #include <entt/meta/factory.hpp>
 #include <entt/meta/meta.hpp>
 #include <entt/meta/resolve.hpp>
+#include "../common/config.h"
 
 struct clazz_t {
     clazz_t()
@@ -234,7 +235,7 @@ TEST_F(MetaAny, SBOAsConstRefConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST_F(MetaAnyDeathTest, SBOAsConstRefConstruction) {
+ENTT_DEBUG_TEST_F(MetaAnyDeathTest, SBOAsConstRefConstruction) {
     const int value = 3;
     auto any = entt::forward_as_meta(value);
 
@@ -499,7 +500,7 @@ TEST_F(MetaAny, NoSBOAsConstRefConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST_F(MetaAnyDeathTest, NoSBOAsConstRefConstruction) {
+ENTT_DEBUG_TEST_F(MetaAnyDeathTest, NoSBOAsConstRefConstruction) {
     const fat_t instance{.1, .2, .3, .4};
     auto any = entt::forward_as_meta(instance);
 
@@ -1026,7 +1027,7 @@ TEST_F(MetaAny, AsRef) {
     ASSERT_FALSE(cref);
 }
 
-TEST_F(MetaAnyDeathTest, AsRef) {
+ENTT_DEBUG_TEST_F(MetaAnyDeathTest, AsRef) {
     entt::meta_any any{42};
     auto cref = std::as_const(any).as_ref();
 

test/entt/meta/meta_container.cpp

@@ -11,6 +11,7 @@
 #include <entt/meta/factory.hpp>
 #include <entt/meta/meta.hpp>
 #include <entt/meta/resolve.hpp>
+#include "../common/config.h"
 
 struct invalid_type {};
 
@@ -537,7 +538,7 @@ TEST_F(MetaContainer, ConstSequenceContainer) {
     ASSERT_EQ(view.size(), 1u);
 }
 
-TEST_F(MetaContainerDeathTest, ConstSequenceContainer) {
+ENTT_DEBUG_TEST_F(MetaContainerDeathTest, ConstSequenceContainer) {
     std::vector<int> vec{};
     auto any = entt::forward_as_meta(std::as_const(vec));
     auto view = any.as_sequence_container();
@@ -579,7 +580,7 @@ TEST_F(MetaContainer, ConstKeyValueAssociativeContainer) {
     ASSERT_EQ(view.size(), 1u);
 }
 
-TEST_F(MetaContainerDeathTest, ConstKeyValueAssociativeContainer) {
+ENTT_DEBUG_TEST_F(MetaContainerDeathTest, ConstKeyValueAssociativeContainer) {
     std::map<int, char> map{};
     auto any = entt::forward_as_meta(std::as_const(map));
     auto view = any.as_associative_container();
@@ -641,7 +642,7 @@ TEST_F(MetaContainer, SequenceContainerConstMetaAny) {
     test(entt::forward_as_meta(std::as_const(vec)));
 }
 
-TEST_F(MetaContainerDeathTest, SequenceContainerConstMetaAny) {
+ENTT_DEBUG_TEST_F(MetaContainerDeathTest, SequenceContainerConstMetaAny) {
     auto test = [](const entt::meta_any any) {
         auto view = any.as_sequence_container();
 
@@ -672,7 +673,7 @@ TEST_F(MetaContainer, KeyValueAssociativeContainerConstMetaAny) {
     test(entt::forward_as_meta(std::as_const(map)));
 }
 
-TEST_F(MetaContainerDeathTest, KeyValueAssociativeContainerConstMetaAny) {
+ENTT_DEBUG_TEST_F(MetaContainerDeathTest, KeyValueAssociativeContainerConstMetaAny) {
     auto test = [](const entt::meta_any any) {
         auto view = any.as_associative_container();
 

test/entt/meta/meta_data.cpp

@@ -8,6 +8,7 @@
 #include <entt/meta/meta.hpp>
 #include <entt/meta/node.hpp>
 #include <entt/meta/resolve.hpp>
+#include "../common/config.h"
 
 struct base_t {
     virtual ~base_t() = default;
@@ -617,7 +618,7 @@ TEST_F(MetaData, AsConstRef) {
     ASSERT_EQ(instance.i, 0);
 }
 
-TEST_F(MetaDataDeathTest, AsConstRef) {
+ENTT_DEBUG_TEST_F(MetaDataDeathTest, AsConstRef) {
     using namespace entt::literals;
 
     clazz_t instance{};
@@ -685,7 +686,7 @@ TEST_F(MetaData, NameCollision) {
     ASSERT_TRUE(entt::resolve<clazz_t>().data("cj"_hs));
 }
 
-TEST_F(MetaDataDeathTest, NameCollision) {
+ENTT_DEBUG_TEST_F(MetaDataDeathTest, NameCollision) {
     using namespace entt::literals;
 
     ASSERT_DEATH(entt::meta<clazz_t>().data<&clazz_t::j>("i"_hs), "");

test/entt/meta/meta_func.cpp

@@ -7,6 +7,7 @@
 #include <entt/meta/factory.hpp>
 #include <entt/meta/meta.hpp>
 #include <entt/meta/resolve.hpp>
+#include "../common/config.h"
 
 struct base_t {
     base_t() {}
@@ -504,7 +505,7 @@ TEST_F(MetaFunc, AsConstRef) {
     ASSERT_EQ(func.invoke(instance).cast<int>(), 3);
 }
 
-TEST_F(MetaFuncDeathTest, AsConstRef) {
+ENTT_DEBUG_TEST_F(MetaFuncDeathTest, AsConstRef) {
     using namespace entt::literals;
 
     func_t instance{};

test/entt/meta/meta_pointer.cpp

@@ -5,6 +5,7 @@
 #include <entt/meta/meta.hpp>
 #include <entt/meta/pointer.hpp>
 #include <entt/meta/resolve.hpp>
+#include "../common/config.h"
 
 template<typename Type>
 struct wrapped_shared_ptr {
@@ -120,7 +121,7 @@ TEST(MetaPointerLike, DereferenceOperatorConstType) {
     ASSERT_EQ(deref.cast<const int &>(), 42);
 }
 
-TEST(MetaPointerLikeDeathTest, DereferenceOperatorConstType) {
+ENTT_DEBUG_TEST(MetaPointerLikeDeathTest, DereferenceOperatorConstType) {
     const int value = 42;
     entt::meta_any any{&value};
     auto deref = *any;
@@ -160,7 +161,7 @@ TEST(MetaPointerLike, DereferenceOperatorConstAnyConstType) {
     ASSERT_EQ(deref.cast<const int &>(), 42);
 }
 
-TEST(MetaPointerLikeDeathTest, DereferenceOperatorConstAnyConstType) {
+ENTT_DEBUG_TEST(MetaPointerLikeDeathTest, DereferenceOperatorConstAnyConstType) {
     const int value = 42;
     const entt::meta_any any{&value};
     auto deref = *any;
@@ -306,7 +307,7 @@ TEST(MetaPointerLike, DereferencePointerToConstOverload) {
     test(spec_wrapped_shared_ptr<const int>{42});
 }
 
-TEST(MetaPointerLikeDeathTest, DereferencePointerToConstOverload) {
+ENTT_DEBUG_TEST(MetaPointerLikeDeathTest, DereferencePointerToConstOverload) {
     auto test = [](entt::meta_any any) {
         auto deref = *any;
 

test/entt/meta/meta_type.cpp

@@ -14,6 +14,7 @@
 #include <entt/meta/pointer.hpp>
 #include <entt/meta/resolve.hpp>
 #include <entt/meta/template.hpp>
+#include "../common/config.h"
 
 template<typename Type>
 void set(Type &prop, Type value) {
@@ -715,7 +716,7 @@ TEST_F(MetaType, NameCollision) {
     ASSERT_TRUE(entt::resolve("quux"_hs));
 }
 
-TEST_F(MetaTypeDeathTest, NameCollision) {
+ENTT_DEBUG_TEST_F(MetaTypeDeathTest, NameCollision) {
     using namespace entt::literals;
 
     ASSERT_DEATH(entt::meta<clazz_t>().type("abstract"_hs), "");

test/entt/poly/poly.cpp

@@ -5,6 +5,7 @@
 #include <entt/core/type_info.hpp>
 #include <entt/core/type_traits.hpp>
 #include <entt/poly/poly.hpp>
+#include "../common/config.h"
 
 template<typename Base>
 struct common_type: Base {
@@ -297,7 +298,7 @@ TYPED_TEST(Poly, Reference) {
     ASSERT_EQ(poly->mul(3), 3);
 }
 
-TYPED_TEST(Poly, ConstReference) {
+ENTT_DEBUG_TYPED_TEST(Poly, ConstReference) {
     using poly_type = typename TestFixture::template type<>;
 
     impl instance{};

test/entt/signal/delegate.cpp

@@ -3,6 +3,7 @@
 #include <utility>
 #include <gtest/gtest.h>
 #include <entt/signal/delegate.hpp>
+#include "../common/config.h"
 
 int delegate_function(const int &i) {
     return i * i;
@@ -108,7 +109,7 @@ TEST(Delegate, Functionalities) {
     ASSERT_NE(mf_del, lf_del);
 }
 
-TEST(DelegateDeathTest, InvokeEmpty) {
+ENTT_DEBUG_TEST(DelegateDeathTest, InvokeEmpty) {
     entt::delegate<int(int)> del;
 
     ASSERT_FALSE(del);