test: code coverage (and try to please new gcov)

.github/workflows/coverage.yml

@@ -13,7 +13,7 @@ jobs:
     - name: Compile tests
       working-directory: build
       env:
-        CXXFLAGS: "--coverage -O0 -fprofile-arcs -ftest-coverage -fno-inline -fno-inline-small-functions -fno-default-inline"
+        CXXFLAGS: "--coverage -fno-inline"
         CXX: g++
       run: |
         cmake -DENTT_BUILD_TESTING=ON -DENTT_BUILD_LIB=ON -DENTT_BUILD_EXAMPLE=ON ..
@@ -30,4 +30,4 @@ jobs:
       run: |
         wget https://codecov.io/bash -O codecov
         chmod +x codecov
-        ./codecov -t $CODECOV_TOKEN -B $GITHUB_REF -s .
+        ./codecov -a "-u" -t $CODECOV_TOKEN -B $GITHUB_REF -s .

src/entt/entity/registry.hpp

@@ -776,7 +776,7 @@ public:
     template<typename... Component>
     [[nodiscard]] bool any_of(const entity_type entity) const {
         ENTT_ASSERT(valid(entity));
-        return (all_of<Component>(entity) || ...);
+        return [entity](const auto *... cpool) { return ((cpool && cpool->contains(entity)) || ...); }(pool_if_exists<Component>()...);
     }
 
     /**

src/entt/entity/view.hpp

@@ -259,7 +259,7 @@ class basic_view<Entity, exclude_t<Exclude...>, Component...> final {
             }
         } else {
             auto it = std::get<storage_type<Comp> *>(pools)->begin();
-        
+
             for(const auto entt: static_cast<const basic_sparse_set<entity_type> &>(*std::get<storage_type<Comp> *>(pools))) {
                 if(((std::is_same_v<Comp, Component> || std::get<storage_type<Component> *>(pools)->contains(entt)) && ...)
                     && !(std::get<const storage_type<Exclude> *>(filter)->contains(entt) || ...))
@@ -270,7 +270,7 @@ class basic_view<Entity, exclude_t<Exclude...>, Component...> final {
                         std::apply(func, std::tuple_cat(dispatch_get<Component>(it, entt)...));
                     }
                 }
-        
+
                 ++it;
             }
         }

test/entt/core/any.cpp

@@ -806,8 +806,11 @@ TEST(Any, AnyCast) {
     ASSERT_EQ(*entt::any_cast<int>(&any), 42);
     ASSERT_EQ(*entt::any_cast<int>(&cany), 42);
     ASSERT_EQ(entt::any_cast<int &>(any), 42);
+    ASSERT_DEATH(entt::any_cast<double &>(any), "");
     ASSERT_EQ(entt::any_cast<const int &>(cany), 42);
+    ASSERT_DEATH(entt::any_cast<const double &>(cany), "");
     ASSERT_EQ(entt::any_cast<int>(entt::any{42}), 42);
+    ASSERT_DEATH(entt::any_cast<double>(entt::any{42}), "");
 }
 
 TEST(Any, NotCopyableType) {

test/entt/core/utility.cpp

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

test/entt/entity/group.cpp

@@ -28,10 +28,10 @@ TEST(NonOwningGroup, Functionalities) {
     registry.emplace<char>(e1, '2');
 
     ASSERT_FALSE(group.empty());
-    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_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_NE(group.begin(), group.end());
     ASSERT_NE(cgroup.begin(), cgroup.end());
@@ -90,7 +90,7 @@ TEST(NonOwningGroup, Invalid) {
     ASSERT_TRUE(group.empty());
     ASSERT_EQ(group.size(), 0u);
     ASSERT_EQ(group.capacity(), 0u);
-    ASSERT_NO_THROW(group.shrink_to_fit());
+    ASSERT_NO_FATAL_FAILURE(group.shrink_to_fit());
 
     ASSERT_EQ(group.data(), nullptr);
 
@@ -108,8 +108,8 @@ TEST(NonOwningGroup, Invalid) {
     for([[maybe_unused]] auto all: group.each()) { FAIL(); }
     for(auto first = group.each().rbegin(), last = group.each().rend(); first != last; ++first) { FAIL(); }
 
-    ASSERT_NO_THROW(group.sort([](const auto, const auto) { FAIL(), true; }));
-    ASSERT_NO_THROW(group.sort<const empty_type>());
+    ASSERT_NO_FATAL_FAILURE(group.sort([](const auto, const auto) { FAIL(), true; }));
+    ASSERT_NO_FATAL_FAILURE(group.sort<const empty_type>());
 }
 
 TEST(NonOwningGroup, ElementAccess) {
@@ -637,10 +637,10 @@ TEST(OwningGroup, Functionalities) {
     registry.emplace<char>(e1, '2');
 
     ASSERT_FALSE(group.empty());
-    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_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_NE(group.begin(), group.end());
     ASSERT_NE(cgroup.begin(), cgroup.end());

test/entt/entity/organizer.cpp

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

test/entt/entity/registry.cpp

@@ -148,9 +148,9 @@ TEST(Registry, Functionalities) {
 
     ASSERT_EQ(registry.size(), 0u);
     ASSERT_EQ(registry.alive(), 0u);
-    ASSERT_NO_THROW((registry.reserve<int, char>(8)));
-    ASSERT_NO_THROW(registry.reserve_pools(16));
-    ASSERT_NO_THROW(registry.reserve(42));
+    ASSERT_NO_FATAL_FAILURE((registry.reserve<int, char>(8)));
+    ASSERT_NO_FATAL_FAILURE(registry.reserve_pools(16));
+    ASSERT_NO_FATAL_FAILURE(registry.reserve(42));
     ASSERT_TRUE(registry.empty());
 
     ASSERT_EQ(registry.capacity(), 42u);
@@ -192,8 +192,8 @@ TEST(Registry, Functionalities) {
 
     ASSERT_EQ(registry.emplace<int>(e0, 42), 42);
     ASSERT_EQ(registry.emplace<char>(e0, 'c'), 'c');
-    ASSERT_NO_THROW(registry.remove<int>(e1));
-    ASSERT_NO_THROW(registry.remove<char>(e1));
+    ASSERT_NO_FATAL_FAILURE(registry.remove<int>(e1));
+    ASSERT_NO_FATAL_FAILURE(registry.remove<char>(e1));
 
     ASSERT_TRUE((registry.all_of<int, char>(e0)));
     ASSERT_FALSE((registry.all_of<int, char>(e1)));
@@ -228,8 +228,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_THROW(registry.emplace_or_replace<int>(e0, 1));
-    ASSERT_NO_THROW(registry.emplace_or_replace<int>(e1, 1));
+    ASSERT_NO_FATAL_FAILURE(registry.emplace_or_replace<int>(e0, 1));
+    ASSERT_NO_FATAL_FAILURE(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);
 
@@ -239,7 +239,7 @@ TEST(Registry, Functionalities) {
 
     ASSERT_EQ(registry.version(e2), 0u);
     ASSERT_EQ(registry.current(e2), 0u);
-    ASSERT_NO_THROW(registry.destroy(e2));
+    ASSERT_NO_FATAL_FAILURE(registry.destroy(e2));
     ASSERT_EQ(registry.version(e2), 0u);
     ASSERT_EQ(registry.current(e2), 1u);
 
@@ -251,7 +251,7 @@ TEST(Registry, Functionalities) {
     ASSERT_EQ(registry.alive(), 2u);
     ASSERT_FALSE(registry.empty());
 
-    ASSERT_NO_THROW(registry.clear());
+    ASSERT_NO_FATAL_FAILURE(registry.clear());
 
     ASSERT_EQ(registry.size(), 3u);
     ASSERT_EQ(registry.alive(), 0u);
@@ -270,14 +270,14 @@ TEST(Registry, Functionalities) {
     ASSERT_EQ(registry.get<int>(e3), 3);
     ASSERT_EQ(registry.get<char>(e3), 'c');
 
-    ASSERT_NO_THROW(registry.clear<int>());
+    ASSERT_NO_FATAL_FAILURE(registry.clear<int>());
 
     ASSERT_EQ(registry.size<int>(), 0u);
     ASSERT_EQ(registry.size<char>(), 1u);
     ASSERT_TRUE(registry.empty<int>());
     ASSERT_FALSE(registry.empty<char>());
 
-    ASSERT_NO_THROW(registry.clear());
+    ASSERT_NO_FATAL_FAILURE(registry.clear());
 
     ASSERT_EQ(registry.size<int>(), 0u);
     ASSERT_EQ(registry.size<char>(), 0u);

test/entt/entity/runtime_view.cpp

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

test/entt/entity/view.cpp

@@ -20,10 +20,10 @@ TEST(SingleComponentView, Functionalities) {
     registry.emplace<int>(e1);
     registry.emplace<char>(e1);
 
-    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_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_NE(view.begin(), view.end());
     ASSERT_NE(cview.begin(), cview.end());
@@ -400,10 +400,10 @@ TEST(MultiComponentView, Functionalities) {
     ASSERT_EQ(++view.begin(), (view.end()));
     ASSERT_EQ(++view.rbegin(), (view.rend()));
 
-    ASSERT_NO_THROW((view.begin()++));
-    ASSERT_NO_THROW((++cview.begin()));
-    ASSERT_NO_THROW(view.rbegin()++);
-    ASSERT_NO_THROW(++cview.rbegin());
+    ASSERT_NO_FATAL_FAILURE((view.begin()++));
+    ASSERT_NO_FATAL_FAILURE((++cview.begin()));
+    ASSERT_NO_FATAL_FAILURE(view.rbegin()++);
+    ASSERT_NO_FATAL_FAILURE(++cview.rbegin());
 
     ASSERT_NE(view.begin(), view.end());
     ASSERT_NE(cview.begin(), cview.end());
@@ -488,6 +488,21 @@ TEST(MultiComponentView, Iterator) {
 
     ASSERT_EQ(*begin, entity);
     ASSERT_EQ(*begin.operator->(), entity);
+
+    registry.emplace<int>(registry.create());
+    registry.emplace<char>(registry.create());
+
+    const auto other = registry.create();
+    registry.emplace<int>(other);
+    registry.emplace<char>(other);
+
+    begin = view.begin();
+
+    ASSERT_EQ(*(begin++), other);
+    ASSERT_EQ(*(begin++), entity);
+    ASSERT_EQ(begin--, end);
+    ASSERT_EQ(*(begin--), entity);
+    ASSERT_EQ(*begin, other);
 }
 
 TEST(MultiComponentView, ReverseIterator) {
@@ -800,80 +815,85 @@ TEST(MultiComponentView, EmptyTypes) {
     const auto entity = registry.create();
     registry.emplace<int>(entity);
     registry.emplace<char>(entity);
-    registry.emplace<double>(entity);
     registry.emplace<empty_type>(entity);
 
     const auto other = registry.create();
     registry.emplace<int>(other);
     registry.emplace<char>(other);
+    registry.emplace<double>(other);
+    registry.emplace<empty_type>(other);
+
+    const auto ignored = registry.create();
+    registry.emplace<int>(ignored);
+    registry.emplace<char>(ignored);
 
-    registry.view<int, char, empty_type>().each([entity](const auto entt, int, char) {
+    registry.view<int, char, empty_type>(entt::exclude<double>).each([entity](const auto entt, int, char) {
         ASSERT_EQ(entity, entt);
     });
 
-    for(auto [entt, iv, cv]: registry.view<int, char, empty_type>().each()) {
+    for(auto [entt, iv, cv]: registry.view<int, char, empty_type>(entt::exclude<double>).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 &>);
         ASSERT_EQ(entity, entt);
     }
 
-    registry.view<int, empty_type, char>().each([check = true](int, char) mutable {
+    registry.view<int, empty_type, char>(entt::exclude<double>).each([check = true](int, char) mutable {
         ASSERT_TRUE(check);
         check = false;
     });
 
-    for(auto [entt, iv, cv]: registry.view<int, empty_type, char>().each()) {
+    for(auto [entt, iv, cv]: registry.view<int, empty_type, char>(entt::exclude<double>).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 &>);
         ASSERT_EQ(entity, entt);
     }
 
-    registry.view<empty_type, int, char>().each([entity](const auto entt, int, char) {
+    registry.view<empty_type, int, char>(entt::exclude<double>).each([entity](const auto entt, int, char) {
         ASSERT_EQ(entity, entt);
     });
 
-    for(auto [entt, iv, cv]: registry.view<empty_type, int, char>().each()) {
+    for(auto [entt, iv, cv]: registry.view<empty_type, int, char>(entt::exclude<double>).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 &>);
         ASSERT_EQ(entity, entt);
     }
 
-    registry.view<empty_type, int, char>().each<empty_type>([entity](const auto entt, int, char) {
+    registry.view<empty_type, int, char>(entt::exclude<double>).each<empty_type>([entity](const auto entt, int, char) {
         ASSERT_EQ(entity, entt);
     });
 
-    for(auto [entt, iv, cv]: registry.view<empty_type, int, char>().each<empty_type>()) {
+    for(auto [entt, iv, cv]: registry.view<empty_type, int, char>(entt::exclude<double>).each<empty_type>()) {
         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 &>);
         ASSERT_EQ(entity, entt);
     }
 
-    registry.view<int, empty_type, char>().each<empty_type>([check = true](int, char) mutable {
+    registry.view<int, empty_type, char>(entt::exclude<double>).each<empty_type>([check = true](int, char) mutable {
         ASSERT_TRUE(check);
         check = false;
     });
 
-    for(auto [entt, iv, cv]: registry.view<int, empty_type, char>().each<empty_type>()) {
+    for(auto [entt, iv, cv]: registry.view<int, empty_type, char>(entt::exclude<double>).each<empty_type>()) {
         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 &>);
         ASSERT_EQ(entity, entt);
     }
 
-    registry.view<int, char, double>().each([entity](const auto entt, int, char, double) {
-        ASSERT_EQ(entity, entt);
+    registry.view<int, char, double>(entt::exclude<empty_type>).each([other](const auto entt, int, char, double) {
+        ASSERT_EQ(other, entt);
     });
 
-    for(auto [entt, iv, cv, dv]: registry.view<int, char, double>().each()) {
+    for(auto [entt, iv, cv, dv]: registry.view<int, char, double>(entt::exclude<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 &>);
         static_assert(std::is_same_v<decltype(dv), double &>);
-        ASSERT_EQ(entity, entt);
+        ASSERT_EQ(other, entt);
     }
 }
 

test/entt/resource/resource.cpp

@@ -55,14 +55,14 @@ TEST(Resource, Functionalities) {
     ASSERT_EQ((*cache.handle(hs1)).value, 42);
     ASSERT_EQ(cache.handle(hs2)->value, 42);
 
-    ASSERT_NO_THROW(cache.discard(hs1));
+    ASSERT_NO_FATAL_FAILURE(cache.discard(hs1));
 
     ASSERT_FALSE(cache.contains(hs1));
     ASSERT_TRUE(cache.contains(hs2));
     ASSERT_EQ(cache.handle(hs2)->value, 42);
 
     ASSERT_TRUE(cache.load<loader>(hs1, 42));
-    ASSERT_NO_THROW(cache.clear());
+    ASSERT_NO_FATAL_FAILURE(cache.clear());
 
     ASSERT_EQ(cache.size(), 0u);
     ASSERT_TRUE(cache.empty());
@@ -78,7 +78,7 @@ TEST(Resource, Functionalities) {
 
     ASSERT_TRUE(cache.handle(hs1));
     ASSERT_EQ(&cache.handle(hs1).get(), &static_cast<const resource &>(cache.handle(hs1)));
-    ASSERT_NO_THROW(cache.clear());
+    ASSERT_NO_FATAL_FAILURE(cache.clear());
 
     ASSERT_EQ(cache.size(), 0u);
     ASSERT_TRUE(cache.empty());

test/entt/signal/sigh.cpp

@@ -43,16 +43,16 @@ struct const_nonconst_noexcept {
 TEST_F(SigH, Lifetime) {
     using signal = entt::sigh<void(void)>;
 
-    ASSERT_NO_THROW(signal{});
+    ASSERT_NO_FATAL_FAILURE(signal{});
 
     signal src{}, other{};
 
-    ASSERT_NO_THROW(signal{src});
-    ASSERT_NO_THROW(signal{std::move(other)});
-    ASSERT_NO_THROW(src = other);
-    ASSERT_NO_THROW(src = std::move(other));
+    ASSERT_NO_FATAL_FAILURE(signal{src});
+    ASSERT_NO_FATAL_FAILURE(signal{std::move(other)});
+    ASSERT_NO_FATAL_FAILURE(src = other);
+    ASSERT_NO_FATAL_FAILURE(src = std::move(other));
 
-    ASSERT_NO_THROW(delete new signal{});
+    ASSERT_NO_FATAL_FAILURE(delete new signal{});
 }
 
 TEST_F(SigH, Clear) {