Scarfski/entt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Michele Caini
2021-03-28 14:49:01 +02:00
parent 02ef5db6e3
commit 7dbfb3d9ae
12 changed files with 93 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.github/workflows/coverage.yml vendored
View File

@@ -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 .

2
src/entt/entity/registry.hpp
View File

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

4
src/entt/entity/view.hpp
View File

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

3
test/entt/core/any.cpp
View File

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

8
test/entt/core/utility.cpp
View File

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

22
test/entt/entity/group.cpp
View File

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

10
test/entt/entity/organizer.cpp
View File

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

22
test/entt/entity/registry.cpp
View File

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

4
test/entt/entity/runtime_view.cpp
View File

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

66
test/entt/entity/view.cpp
View File

@@ -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);
registry.view<int, char, empty_type>().each([entity](const auto entt, int, char) {
const auto ignored = registry.create();
registry.emplace<int>(ignored);
registry.emplace<char>(ignored);
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);
}
}

6
test/entt/resource/resource.cpp
View File

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

12
test/entt/signal/sigh.cpp
View File

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