test: avoid using ASSERT_NO_FATAL_FAILURE improperly

test/entt/container/dense_map.cpp

@@ -21,7 +21,7 @@ TEST(DenseMap, Functionalities) {
     entt::dense_map<int, int, entt::identity, test::transparent_equal_to> map;
     const auto &cmap = map;
 
-    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = map.get_allocator());
+    ASSERT_NO_THROW([[maybe_unused]] auto alloc = map.get_allocator());
 
     ASSERT_TRUE(map.empty());
     ASSERT_EQ(map.size(), 0u);

test/entt/container/dense_set.cpp

@@ -19,7 +19,7 @@ TEST(DenseSet, Functionalities) {
     entt::dense_set<int, entt::identity, test::transparent_equal_to> set;
     const auto &cset = set;
 
-    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = set.get_allocator());
+    ASSERT_NO_THROW([[maybe_unused]] auto alloc = set.get_allocator());
 
     ASSERT_TRUE(set.empty());
     ASSERT_EQ(set.size(), 0u);

test/entt/core/iterator.cpp

@@ -36,8 +36,8 @@ TEST(IterableAdaptor, Functionalities) {
     entt::iterable_adaptor iterable{vec.begin(), vec.end()};
     decltype(iterable) other{};
 
-    ASSERT_NO_FATAL_FAILURE(other = iterable);
-    ASSERT_NO_FATAL_FAILURE(std::swap(other, iterable));
+    ASSERT_NO_THROW(other = iterable);
+    ASSERT_NO_THROW(std::swap(other, iterable));
 
     ASSERT_EQ(iterable.begin(), vec.begin());
     ASSERT_EQ(iterable.end(), vec.end());

test/entt/core/memory.cpp

@@ -28,7 +28,7 @@ TEST(PoccaPocmaAndPocs, Functionalities) {
 
     // code coverage purposes
     ASSERT_FALSE(lhs == rhs);
-    ASSERT_NO_FATAL_FAILURE(entt::propagate_on_container_swap(no_pocs, no_pocs));
+    ASSERT_NO_THROW(entt::propagate_on_container_swap(no_pocs, no_pocs));
 
     // honestly, I don't even know how one is supposed to test such a thing :)
     entt::propagate_on_container_copy_assignment(lhs, rhs);

test/entt/core/utility.cpp

@@ -29,11 +29,11 @@ TEST(Overload, Functionalities) {
 
     functions instance; // NOLINT
 
-    ASSERT_NO_FATAL_FAILURE(entt::overload<void(int)>(&functions::foo)(0));
-    ASSERT_NO_FATAL_FAILURE(entt::overload<void()>(&functions::foo)());
+    ASSERT_NO_THROW(entt::overload<void(int)>(&functions::foo)(0));
+    ASSERT_NO_THROW(entt::overload<void()>(&functions::foo)());
 
-    ASSERT_NO_FATAL_FAILURE((instance.*entt::overload<void(int)>(&functions::bar))(0));
-    ASSERT_NO_FATAL_FAILURE((instance.*entt::overload<void()>(&functions::bar))());
+    ASSERT_NO_THROW((instance.*entt::overload<void(int)>(&functions::bar))(0));
+    ASSERT_NO_THROW((instance.*entt::overload<void()>(&functions::bar))());
 }
 
 TEST(Overloaded, Functionalities) {

test/entt/entity/group.cpp

@@ -27,10 +27,10 @@ TEST(NonOwningGroup, Functionalities) {
     registry.emplace<char>(e1, '2');
 
     ASSERT_FALSE(group.empty());
-    ASSERT_NO_FATAL_FAILURE(group.begin()++);
-    ASSERT_NO_FATAL_FAILURE(++cgroup.begin());
-    ASSERT_NO_FATAL_FAILURE([](auto it) { return it++; }(group.rbegin()));
-    ASSERT_NO_FATAL_FAILURE([](auto it) { return ++it; }(cgroup.rbegin()));
+    ASSERT_NO_THROW(group.begin()++);
+    ASSERT_NO_THROW(++cgroup.begin());
+    ASSERT_NO_THROW([](auto it) { return it++; }(group.rbegin()));
+    ASSERT_NO_THROW([](auto it) { return ++it; }(cgroup.rbegin()));
 
     ASSERT_NE(group.begin(), group.end());
     ASSERT_NE(cgroup.begin(), cgroup.end());
@@ -109,7 +109,7 @@ TEST(NonOwningGroup, Invalid) {
     ASSERT_TRUE(group.empty());
     ASSERT_EQ(group.size(), 0u);
     ASSERT_EQ(group.capacity(), 0u);
-    ASSERT_NO_FATAL_FAILURE(group.shrink_to_fit());
+    ASSERT_NO_THROW(group.shrink_to_fit());
 
     ASSERT_EQ(group.begin(), group.end());
     ASSERT_EQ(group.rbegin(), group.rend());
@@ -190,7 +190,7 @@ TEST(NonOwningGroup, Each) {
     auto citerable = cgroup.each();
 
     ASSERT_NE(citerable.begin(), citerable.end());
-    ASSERT_NO_FATAL_FAILURE(iterable.begin()->operator=(*iterable.begin()));
+    ASSERT_NO_THROW(iterable.begin()->operator=(*iterable.begin()));
     ASSERT_EQ(decltype(iterable.end()){}, iterable.end());
 
     auto it = iterable.begin();
@@ -780,10 +780,10 @@ TEST(OwningGroup, Functionalities) {
     registry.emplace<char>(e1, '2');
 
     ASSERT_FALSE(group.empty());
-    ASSERT_NO_FATAL_FAILURE(group.begin()++);
-    ASSERT_NO_FATAL_FAILURE(++cgroup.begin());
-    ASSERT_NO_FATAL_FAILURE([](auto it) { return it++; }(group.rbegin()));
-    ASSERT_NO_FATAL_FAILURE([](auto it) { return ++it; }(cgroup.rbegin()));
+    ASSERT_NO_THROW(group.begin()++);
+    ASSERT_NO_THROW(++cgroup.begin());
+    ASSERT_NO_THROW([](auto it) { return it++; }(group.rbegin()));
+    ASSERT_NO_THROW([](auto it) { return ++it; }(cgroup.rbegin()));
 
     ASSERT_NE(group.begin(), group.end());
     ASSERT_NE(cgroup.begin(), cgroup.end());
@@ -939,7 +939,7 @@ TEST(OwningGroup, Each) {
     auto citerable = cgroup.each();
 
     ASSERT_NE(citerable.begin(), citerable.end());
-    ASSERT_NO_FATAL_FAILURE(iterable.begin()->operator=(*iterable.begin()));
+    ASSERT_NO_THROW(iterable.begin()->operator=(*iterable.begin()));
     ASSERT_EQ(decltype(iterable.end()){}, iterable.end());
 
     auto it = iterable.begin();

test/entt/entity/organizer.cpp

@@ -74,7 +74,7 @@ TEST(Organizer, EmplaceFreeFunction) {
     ASSERT_EQ(graph[2u].children()[0u], 3u);
 
     for(auto &&vertex: graph) {
-        ASSERT_NO_FATAL_FAILURE(vertex.callback()(vertex.data(), registry));
+        ASSERT_NO_THROW(vertex.callback()(vertex.data(), registry));
     }
 
     organizer.clear();
@@ -130,7 +130,7 @@ TEST(Organizer, EmplaceMemberFunction) {
     ASSERT_EQ(graph[2u].children()[0u], 3u);
 
     for(auto &&vertex: graph) {
-        ASSERT_NO_FATAL_FAILURE(vertex.callback()(vertex.data(), registry));
+        ASSERT_NO_THROW(vertex.callback()(vertex.data(), registry));
     }
 
     organizer.clear();
@@ -194,7 +194,7 @@ TEST(Organizer, EmplaceFreeFunctionWithPayload) {
     ASSERT_EQ(graph[3u].children()[0u], 4u);
 
     for(auto &&vertex: graph) {
-        ASSERT_NO_FATAL_FAILURE(vertex.callback()(vertex.data(), registry));
+        ASSERT_NO_THROW(vertex.callback()(vertex.data(), registry));
     }
 
     organizer.clear();
@@ -267,7 +267,7 @@ TEST(Organizer, EmplaceDirectFunction) {
     ASSERT_EQ(graph[2u].children()[0u], 3u);
 
     for(auto &&vertex: graph) {
-        ASSERT_NO_FATAL_FAILURE(vertex.callback()(vertex.data(), registry));
+        ASSERT_NO_THROW(vertex.callback()(vertex.data(), registry));
     }
 
     organizer.clear();
@@ -320,7 +320,7 @@ TEST(Organizer, SyncPoint) {
     ASSERT_EQ(graph[4u].children()[0u], 5u);
 
     for(auto &&vertex: graph) {
-        ASSERT_NO_FATAL_FAILURE(vertex.callback()(vertex.data(), registry));
+        ASSERT_NO_THROW(vertex.callback()(vertex.data(), registry));
     }
 }
 

test/entt/entity/registry.cpp

@@ -229,11 +229,11 @@ TEST(Registry, Functionalities) {
 
     entt::registry registry;
 
-    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = registry.get_allocator());
+    ASSERT_NO_THROW([[maybe_unused]] auto alloc = registry.get_allocator());
 
     ASSERT_EQ(registry.storage<entt::entity>().size(), 0u);
     ASSERT_EQ(registry.storage<entt::entity>().free_list(), 0u);
-    ASSERT_NO_FATAL_FAILURE(registry.storage<entt::entity>().reserve(42));
+    ASSERT_NO_THROW(registry.storage<entt::entity>().reserve(42));
     ASSERT_EQ(registry.storage<entt::entity>().capacity(), 42u);
     ASSERT_TRUE(registry.storage<entt::entity>().empty());
 
@@ -272,8 +272,8 @@ TEST(Registry, Functionalities) {
 
     ASSERT_EQ(registry.emplace<int>(e0, 42), 42);
     ASSERT_EQ(registry.emplace<char>(e0, 'c'), 'c');
-    ASSERT_NO_FATAL_FAILURE(registry.erase<int>(e1));
-    ASSERT_NO_FATAL_FAILURE(registry.erase<char>(e1));
+    ASSERT_NO_THROW(registry.erase<int>(e1));
+    ASSERT_NO_THROW(registry.erase<char>(e1));
 
     ASSERT_TRUE((registry.all_of<const int, char>(e0)));
     ASSERT_FALSE((registry.all_of<int, const char>(e1)));
@@ -308,8 +308,8 @@ TEST(Registry, Functionalities) {
     ASSERT_EQ(registry.patch<int>(e0, [](auto &instance) { instance = 2; }), 2);
     ASSERT_EQ(registry.replace<int>(e0, 3), 3);
 
-    ASSERT_NO_FATAL_FAILURE(registry.emplace_or_replace<int>(e0, 1));
-    ASSERT_NO_FATAL_FAILURE(registry.emplace_or_replace<int>(e1, 1));
+    ASSERT_NO_THROW(registry.emplace_or_replace<int>(e0, 1));
+    ASSERT_NO_THROW(registry.emplace_or_replace<int>(e1, 1));
     ASSERT_EQ(static_cast<const entt::registry &>(registry).get<int>(e0), 1);
     ASSERT_EQ(static_cast<const entt::registry &>(registry).get<int>(e1), 1);
 
@@ -318,7 +318,7 @@ TEST(Registry, Functionalities) {
 
     ASSERT_EQ(traits_type::to_version(e2), 0u);
     ASSERT_EQ(registry.current(e2), 0u);
-    ASSERT_NO_FATAL_FAILURE(registry.destroy(e2));
+    ASSERT_NO_THROW(registry.destroy(e2));
     ASSERT_EQ(traits_type::to_version(e2), 0u);
     ASSERT_EQ(registry.current(e2), 1u);
 
@@ -329,7 +329,7 @@ TEST(Registry, Functionalities) {
     ASSERT_EQ(registry.storage<entt::entity>().size(), 3u);
     ASSERT_EQ(registry.storage<entt::entity>().free_list(), 2u);
 
-    ASSERT_NO_FATAL_FAILURE(registry.clear());
+    ASSERT_NO_THROW(registry.clear());
 
     ASSERT_EQ(registry.storage<entt::entity>().size(), 3u);
     ASSERT_EQ(registry.storage<entt::entity>().free_list(), 0u);
@@ -348,14 +348,14 @@ TEST(Registry, Functionalities) {
     ASSERT_EQ(registry.get<int>(e3), 3);
     ASSERT_EQ(registry.get<char>(e3), 'c');
 
-    ASSERT_NO_FATAL_FAILURE(registry.clear<int>());
+    ASSERT_NO_THROW(registry.clear<int>());
 
     ASSERT_EQ(registry.storage<int>().size(), 0u);
     ASSERT_EQ(registry.storage<char>().size(), 1u);
     ASSERT_TRUE(registry.storage<int>().empty());
     ASSERT_FALSE(registry.storage<char>().empty());
 
-    ASSERT_NO_FATAL_FAILURE(registry.clear());
+    ASSERT_NO_THROW(registry.clear());
 
     ASSERT_EQ(registry.storage<int>().size(), 0u);
     ASSERT_EQ(registry.storage<char>().size(), 0u);
@@ -694,7 +694,7 @@ TEST(Registry, DestroyRange) {
     registry.destroy(iview.begin(), iview.end());
 
     ASSERT_FALSE(registry.valid(entity[2u]));
-    ASSERT_NO_FATAL_FAILURE(registry.destroy(iview.rbegin(), iview.rend()));
+    ASSERT_NO_THROW(registry.destroy(iview.rbegin(), iview.rend()));
     ASSERT_EQ(iview.size(), 0u);
     ASSERT_EQ(icview.size_hint(), 0u);
 
@@ -1523,7 +1523,7 @@ TEST(Registry, Erase) {
     registry.erase<int>(iview.begin(), iview.end());
 
     ASSERT_FALSE(registry.any_of<int>(entity[2u]));
-    ASSERT_NO_FATAL_FAILURE(registry.erase<int>(iview.rbegin(), iview.rend()));
+    ASSERT_NO_THROW(registry.erase<int>(iview.rbegin(), iview.rend()));
 
     ASSERT_EQ(registry.storage<int>().size(), 0u);
     ASSERT_EQ(registry.storage<char>().size(), 0u);

test/entt/entity/runtime_view.cpp

@@ -51,8 +51,8 @@ TYPED_TEST(RuntimeView, Functionalities) {
     ASSERT_EQ(*it, e1);
     ASSERT_EQ(++it, (view.end()));
 
-    ASSERT_NO_FATAL_FAILURE((view.begin()++));
-    ASSERT_NO_FATAL_FAILURE((++view.begin()));
+    ASSERT_NO_THROW((view.begin()++));
+    ASSERT_NO_THROW((++view.begin()));
 
     ASSERT_NE(view.begin(), view.end());
     ASSERT_EQ(view.size_hint(), 1u);

test/entt/entity/sigh_mixin.cpp

@@ -553,7 +553,7 @@ TYPED_TEST(SighMixin, ThrowingAllocator) {
 
     ASSERT_THROW(pool.emplace(entt::entity{0}, 0), test::throwing_allocator_exception);
     ASSERT_FALSE(pool.contains(entt::entity{0}));
-    ASSERT_NO_FATAL_FAILURE(pool.compact());
+    ASSERT_NO_THROW(pool.compact());
     ASSERT_TRUE(pool.empty());
 
     pool.emplace(entt::entity{0}, 0);

test/entt/entity/snapshot.cpp

@@ -31,7 +31,7 @@ TEST(BasicSnapshot, Constructors) {
     entt::basic_snapshot snapshot{registry};
     entt::basic_snapshot other{std::move(snapshot)};
 
-    ASSERT_NO_FATAL_FAILURE(snapshot = std::move(other));
+    ASSERT_NO_THROW(snapshot = std::move(other));
 }
 
 TEST(BasicSnapshot, GetEntityType) {
@@ -225,7 +225,7 @@ TEST(BasicSnapshotLoader, Constructors) {
     entt::basic_snapshot_loader loader{registry};
     entt::basic_snapshot_loader other{std::move(loader)};
 
-    ASSERT_NO_FATAL_FAILURE(loader = std::move(other));
+    ASSERT_NO_THROW(loader = std::move(other));
 }
 
 ENTT_DEBUG_TEST(BasicSnapshotLoaderDeathTest, Constructors) {
@@ -501,7 +501,7 @@ TEST(BasicContinuousLoader, Constructors) {
     entt::basic_continuous_loader loader{registry};
     entt::basic_continuous_loader other{std::move(loader)};
 
-    ASSERT_NO_FATAL_FAILURE(loader = std::move(other));
+    ASSERT_NO_THROW(loader = std::move(other));
 }
 
 TEST(BasicContinuousLoader, GetEntityType) {

test/entt/entity/sparse_set.cpp

@@ -56,25 +56,25 @@ TYPED_TEST(SparseSet, Constructors) {
         sparse_set_type set{};
 
         ASSERT_EQ(set.policy(), entt::deletion_policy::swap_and_pop);
-        ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = set.get_allocator());
+        ASSERT_NO_THROW([[maybe_unused]] auto alloc = set.get_allocator());
         ASSERT_EQ(set.type(), entt::type_id<void>());
 
         set = sparse_set_type{allocator_type{}};
 
         ASSERT_EQ(set.policy(), entt::deletion_policy::swap_and_pop);
-        ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = set.get_allocator());
+        ASSERT_NO_THROW([[maybe_unused]] auto alloc = set.get_allocator());
         ASSERT_EQ(set.type(), entt::type_id<void>());
 
         set = sparse_set_type{policy, allocator_type{}};
 
         ASSERT_EQ(set.policy(), policy);
-        ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = set.get_allocator());
+        ASSERT_NO_THROW([[maybe_unused]] auto alloc = set.get_allocator());
         ASSERT_EQ(set.type(), entt::type_id<void>());
 
         set = sparse_set_type{entt::type_id<int>(), policy, allocator_type{}};
 
         ASSERT_EQ(set.policy(), policy);
-        ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = set.get_allocator());
+        ASSERT_NO_THROW([[maybe_unused]] auto alloc = set.get_allocator());
         ASSERT_EQ(set.type(), entt::type_id<int>());
     }
 }
@@ -260,8 +260,8 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, FreeList) {
             ASSERT_DEATH(set.free_list(0u), "");
         } break;
         case entt::deletion_policy::swap_only: {
-            ASSERT_NO_FATAL_FAILURE(set.free_list(0u));
-            ASSERT_NO_FATAL_FAILURE(set.free_list(1u));
+            ASSERT_NO_THROW(set.free_list(0u));
+            ASSERT_NO_THROW(set.free_list(1u));
             ASSERT_DEATH(set.free_list(2u), "");
         } break;
         }
@@ -441,7 +441,7 @@ TYPED_TEST(SparseSet, Bind) {
     for(const auto policy: this->deletion_policy) {
         sparse_set_type set{policy};
 
-        ASSERT_NO_FATAL_FAILURE(set.bind(entt::any{}));
+        ASSERT_NO_THROW(set.bind(entt::any{}));
     }
 }
 
@@ -1842,7 +1842,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortN) {
         } break;
         case entt::deletion_policy::swap_only: {
             ASSERT_EQ(set.size(), 2u);
-            ASSERT_NO_FATAL_FAILURE(set.sort_n(1u, std::less{}));
+            ASSERT_NO_THROW(set.sort_n(1u, std::less{}));
             ASSERT_DEATH(set.sort_n(2u, std::less{}), "");
         } break;
         }

test/entt/entity/storage.cpp

@@ -84,13 +84,13 @@ TYPED_TEST(Storage, Constructors) {
     entt::storage<value_type> pool;
 
     ASSERT_EQ(pool.policy(), entt::deletion_policy{traits_type::in_place_delete});
-    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = pool.get_allocator());
+    ASSERT_NO_THROW([[maybe_unused]] auto alloc = pool.get_allocator());
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
 
     pool = entt::storage<value_type>{std::allocator<value_type>{}};
 
     ASSERT_EQ(pool.policy(), entt::deletion_policy{traits_type::in_place_delete});
-    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = pool.get_allocator());
+    ASSERT_NO_THROW([[maybe_unused]] auto alloc = pool.get_allocator());
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
 }
 
@@ -1764,7 +1764,7 @@ TYPED_TEST(Storage, ThrowingAllocator) {
 
     ASSERT_THROW(pool.emplace(entt::entity{0}, 0), test::throwing_allocator_exception);
     ASSERT_FALSE(pool.contains(entt::entity{0}));
-    ASSERT_NO_FATAL_FAILURE(pool.compact());
+    ASSERT_NO_THROW(pool.compact());
     ASSERT_TRUE(pool.empty());
 
     pool.emplace(entt::entity{0}, 0);

test/entt/entity/storage_entity.cpp

@@ -16,13 +16,13 @@ TEST(StorageEntity, Constructors) {
     entt::storage<entt::entity> pool;
 
     ASSERT_EQ(pool.policy(), entt::deletion_policy::swap_only);
-    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = pool.get_allocator());
+    ASSERT_NO_THROW([[maybe_unused]] auto alloc = pool.get_allocator());
     ASSERT_EQ(pool.type(), entt::type_id<void>());
 
     pool = entt::storage<entt::entity>{std::allocator<entt::entity>{}};
 
     ASSERT_EQ(pool.policy(), entt::deletion_policy::swap_only);
-    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = pool.get_allocator());
+    ASSERT_NO_THROW([[maybe_unused]] auto alloc = pool.get_allocator());
     ASSERT_EQ(pool.type(), entt::type_id<void>());
 }
 
@@ -118,8 +118,8 @@ TEST(StorageEntity, Getters) {
     testing::StaticAssertTypeEq<decltype(pool.get_as_tuple({})), std::tuple<>>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get_as_tuple({})), std::tuple<>>();
 
-    ASSERT_NO_FATAL_FAILURE(pool.get(entt::entity{41}));
-    ASSERT_NO_FATAL_FAILURE(std::as_const(pool).get(entt::entity{41}));
+    ASSERT_NO_THROW(pool.get(entt::entity{41}));
+    ASSERT_NO_THROW(std::as_const(pool).get(entt::entity{41}));
 
     ASSERT_EQ(pool.get_as_tuple(entt::entity{41}), std::make_tuple());
     ASSERT_EQ(std::as_const(pool).get_as_tuple(entt::entity{41}), std::make_tuple());

test/entt/entity/storage_no_instance.cpp

@@ -58,13 +58,13 @@ TYPED_TEST(StorageNoInstance, Constructors) {
     entt::storage<value_type> pool;
 
     ASSERT_EQ(pool.policy(), entt::deletion_policy::swap_and_pop);
-    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = pool.get_allocator());
+    ASSERT_NO_THROW([[maybe_unused]] auto alloc = pool.get_allocator());
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
 
     pool = entt::storage<value_type>{std::allocator<value_type>{}};
 
     ASSERT_EQ(pool.policy(), entt::deletion_policy::swap_and_pop);
-    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = pool.get_allocator());
+    ASSERT_NO_THROW([[maybe_unused]] auto alloc = pool.get_allocator());
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
 }
 
@@ -163,8 +163,8 @@ TYPED_TEST(StorageNoInstance, Getters) {
     testing::StaticAssertTypeEq<decltype(pool.get_as_tuple({})), std::tuple<>>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get_as_tuple({})), std::tuple<>>();
 
-    ASSERT_NO_FATAL_FAILURE(pool.get(entt::entity{41}));
-    ASSERT_NO_FATAL_FAILURE(std::as_const(pool).get(entt::entity{41}));
+    ASSERT_NO_THROW(pool.get(entt::entity{41}));
+    ASSERT_NO_THROW(std::as_const(pool).get(entt::entity{41}));
 
     ASSERT_EQ(pool.get_as_tuple(entt::entity{41}), std::make_tuple());
     ASSERT_EQ(std::as_const(pool).get_as_tuple(entt::entity{41}), std::make_tuple());
@@ -205,8 +205,8 @@ TYPED_TEST(StorageNoInstance, Emplace) {
 
     testing::StaticAssertTypeEq<decltype(pool.emplace({})), void>();
 
-    ASSERT_NO_FATAL_FAILURE(pool.emplace(entity[0u]));
-    ASSERT_NO_FATAL_FAILURE(this->emplace_instance(pool, entity[1u]));
+    ASSERT_NO_THROW(pool.emplace(entity[0u]));
+    ASSERT_NO_THROW(this->emplace_instance(pool, entity[1u]));
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Emplace) {

test/entt/entity/view.cpp

@@ -25,10 +25,10 @@ TEST(SingleComponentView, Functionalities) {
 
     registry.emplace<char>(e1);
 
-    ASSERT_NO_FATAL_FAILURE(view.begin()++);
-    ASSERT_NO_FATAL_FAILURE(++cview.begin());
-    ASSERT_NO_FATAL_FAILURE([](auto it) { return it++; }(view.rbegin()));
-    ASSERT_NO_FATAL_FAILURE([](auto it) { return ++it; }(cview.rbegin()));
+    ASSERT_NO_THROW(view.begin()++);
+    ASSERT_NO_THROW(++cview.begin());
+    ASSERT_NO_THROW([](auto it) { return it++; }(view.rbegin()));
+    ASSERT_NO_THROW([](auto it) { return ++it; }(cview.rbegin()));
 
     ASSERT_NE(view.begin(), view.end());
     ASSERT_NE(cview.begin(), cview.end());
@@ -222,7 +222,7 @@ TEST(SingleComponentView, Each) {
     auto citerable = cview.each();
 
     ASSERT_NE(citerable.begin(), citerable.end());
-    ASSERT_NO_FATAL_FAILURE(iterable.begin()->operator=(*iterable.begin()));
+    ASSERT_NO_THROW(iterable.begin()->operator=(*iterable.begin()));
     ASSERT_EQ(decltype(iterable.end()){}, iterable.end());
 
     auto it = iterable.begin();
@@ -618,8 +618,8 @@ TEST(MultiComponentView, Functionalities) {
     ASSERT_EQ(++view.begin(), (view.end()));
     ASSERT_EQ(++cview.begin(), (cview.end()));
 
-    ASSERT_NO_FATAL_FAILURE((view.begin()++));
-    ASSERT_NO_FATAL_FAILURE((++cview.begin()));
+    ASSERT_NO_THROW((view.begin()++));
+    ASSERT_NO_THROW((++cview.begin()));
 
     ASSERT_NE(view.begin(), view.end());
     ASSERT_NE(cview.begin(), cview.end());
@@ -899,7 +899,7 @@ TEST(MultiComponentView, Each) {
     auto citerable = cview.each();
 
     ASSERT_NE(citerable.begin(), citerable.end());
-    ASSERT_NO_FATAL_FAILURE(iterable.begin()->operator=(*iterable.begin()));
+    ASSERT_NO_THROW(iterable.begin()->operator=(*iterable.begin()));
     ASSERT_EQ(decltype(iterable.end()){}, iterable.end());
 
     auto it = iterable.begin();

test/entt/graph/flow.cpp

@@ -282,8 +282,8 @@ ENTT_DEBUG_TEST(FlowDeathTest, NoBind) {
 
     flow.bind(0);
 
-    ASSERT_NO_FATAL_FAILURE(flow.ro(1));
-    ASSERT_NO_FATAL_FAILURE(flow.rw(2));
+    ASSERT_NO_THROW(flow.ro(1));
+    ASSERT_NO_THROW(flow.rw(2));
 }
 
 TEST(Flow, DirectRebind) {

test/entt/meta/meta_data.cpp

@@ -664,8 +664,8 @@ TEST_F(MetaData, CollisionAndReuse) {
     ASSERT_FALSE(entt::resolve<clazz_t>().data("cj"_hs));
     ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs).is_const());
 
-    ASSERT_NO_FATAL_FAILURE(entt::meta<clazz_t>().data<&clazz_t::i>("j"_hs));
-    ASSERT_NO_FATAL_FAILURE(entt::meta<clazz_t>().data<&clazz_t::j>("cj"_hs));
+    ASSERT_NO_THROW(entt::meta<clazz_t>().data<&clazz_t::i>("j"_hs));
+    ASSERT_NO_THROW(entt::meta<clazz_t>().data<&clazz_t::j>("cj"_hs));
 
     ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs));
     ASSERT_TRUE(entt::resolve<clazz_t>().data("cj"_hs));

test/entt/meta/meta_type.cpp

@@ -774,10 +774,10 @@ TEST_F(MetaType, ReRegistration) {
 TEST_F(MetaType, NameCollision) {
     using namespace entt::literals;
 
-    ASSERT_NO_FATAL_FAILURE(entt::meta<clazz_t>().type("clazz"_hs));
+    ASSERT_NO_THROW(entt::meta<clazz_t>().type("clazz"_hs));
     ASSERT_TRUE(entt::resolve("clazz"_hs));
 
-    ASSERT_NO_FATAL_FAILURE(entt::meta<clazz_t>().type("quux"_hs));
+    ASSERT_NO_THROW(entt::meta<clazz_t>().type("quux"_hs));
     ASSERT_FALSE(entt::resolve("clazz"_hs));
     ASSERT_TRUE(entt::resolve("quux"_hs));
 }

test/entt/resource/resource_cache.cpp

@@ -39,7 +39,7 @@ TEST(ResourceCache, Functionalities) {
 
     entt::resource_cache<int> cache;
 
-    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = cache.get_allocator());
+    ASSERT_NO_THROW([[maybe_unused]] auto alloc = cache.get_allocator());
 
     ASSERT_TRUE(cache.empty());
     ASSERT_EQ(cache.size(), 0u);

test/entt/signal/sigh.cpp

@@ -54,16 +54,16 @@ void connect_and_auto_disconnect(entt::sigh<void(int &)> &sigh, const int &) {
 TEST(SigH, Lifetime) {
     using signal = entt::sigh<void(void)>;
 
-    ASSERT_NO_FATAL_FAILURE(signal{});
+    ASSERT_NO_THROW(signal{});
 
     signal src{}, other{};
 
-    ASSERT_NO_FATAL_FAILURE(signal{src});
-    ASSERT_NO_FATAL_FAILURE(signal{std::move(other)});
-    ASSERT_NO_FATAL_FAILURE(src = other);            // NOLINT
-    ASSERT_NO_FATAL_FAILURE(src = std::move(other)); // NOLINT
+    ASSERT_NO_THROW(signal{src});
+    ASSERT_NO_THROW(signal{std::move(other)});
+    ASSERT_NO_THROW(src = other);            // NOLINT
+    ASSERT_NO_THROW(src = std::move(other)); // NOLINT
 
-    ASSERT_NO_FATAL_FAILURE(delete new signal{});
+    ASSERT_NO_THROW(delete new signal{});
 }
 
 TEST(SigH, Clear) {