test: a handful of minor changes to please all compilers from the CI and remove some lambdas

test/entt/core/enum.cpp

@@ -26,7 +26,7 @@ struct Enum: testing::Test {
 
 using EnumTypes = ::testing::Types<detected, registered>;
 
-TYPED_TEST_SUITE(Enum, EnumTypes);
+TYPED_TEST_SUITE(Enum, EnumTypes, );
 
 TYPED_TEST(Enum, Functionalities) {
     using enum_type = typename TestFixture::type;

test/entt/entity/registry.cpp

@@ -830,14 +830,12 @@ TEST(Registry, View) {
 
 TEST(Registry, NonOwningGroupInitOnFirstUse) {
     entt::registry registry;
-    auto create = [&](auto... component) {
-        const auto entity = registry.create();
-        (registry.emplace<decltype(component)>(entity, component), ...);
-    };
+    entt::entity entities[3u];
 
-    create(0, 'c');
-    create(0);
-    create(0, 'c');
+    registry.create(std::begin(entities), std::end(entities));
+    registry.insert<int>(std::begin(entities), std::end(entities), 0);
+    registry.emplace<char>(entities[0u], 'c');
+    registry.emplace<char>(entities[2u], 'c');
 
     std::size_t cnt{};
     auto group = registry.group<>(entt::get<int, char>);
@@ -849,15 +847,13 @@ TEST(Registry, NonOwningGroupInitOnFirstUse) {
 
 TEST(Registry, NonOwningGroupInitOnEmplace) {
     entt::registry registry;
+    entt::entity entities[3u];
     auto group = registry.group<>(entt::get<int, char>);
-    auto create = [&](auto... component) {
-        const auto entity = registry.create();
-        (registry.emplace<decltype(component)>(entity, component), ...);
-    };
 
-    create(0, 'c');
-    create(0);
-    create(0, 'c');
+    registry.create(std::begin(entities), std::end(entities));
+    registry.insert<int>(std::begin(entities), std::end(entities), 0);
+    registry.emplace<char>(entities[0u], 'c');
+    registry.emplace<char>(entities[2u], 'c');
 
     std::size_t cnt{};
     group.each([&cnt](auto...) { ++cnt; });
@@ -868,14 +864,12 @@ TEST(Registry, NonOwningGroupInitOnEmplace) {
 
 TEST(Registry, FullOwningGroupInitOnFirstUse) {
     entt::registry registry;
-    auto create = [&](auto... component) {
-        const auto entity = registry.create();
-        (registry.emplace<decltype(component)>(entity, component), ...);
-    };
+    entt::entity entities[3u];
 
-    create(0, 'c');
-    create(0);
-    create(0, 'c');
+    registry.create(std::begin(entities), std::end(entities));
+    registry.insert<int>(std::begin(entities), std::end(entities), 0);
+    registry.emplace<char>(entities[0u], 'c');
+    registry.emplace<char>(entities[2u], 'c');
 
     std::size_t cnt{};
     auto group = registry.group<int, char>();
@@ -889,15 +883,13 @@ TEST(Registry, FullOwningGroupInitOnFirstUse) {
 
 TEST(Registry, FullOwningGroupInitOnEmplace) {
     entt::registry registry;
+    entt::entity entities[3u];
     auto group = registry.group<int, char>();
-    auto create = [&](auto... component) {
-        const auto entity = registry.create();
-        (registry.emplace<decltype(component)>(entity, component), ...);
-    };
 
-    create(0, 'c');
-    create(0);
-    create(0, 'c');
+    registry.create(std::begin(entities), std::end(entities));
+    registry.insert<int>(std::begin(entities), std::end(entities), 0);
+    registry.emplace<char>(entities[0u], 'c');
+    registry.emplace<char>(entities[2u], 'c');
 
     std::size_t cnt{};
     group.each([&cnt](auto...) { ++cnt; });
@@ -910,14 +902,12 @@ TEST(Registry, FullOwningGroupInitOnEmplace) {
 
 TEST(Registry, PartialOwningGroupInitOnFirstUse) {
     entt::registry registry;
-    auto create = [&](auto... component) {
-        const auto entity = registry.create();
-        (registry.emplace<decltype(component)>(entity, component), ...);
-    };
+    entt::entity entities[3u];
 
-    create(0, 'c');
-    create(0);
-    create(0, 'c');
+    registry.create(std::begin(entities), std::end(entities));
+    registry.insert<int>(std::begin(entities), std::end(entities), 0);
+    registry.emplace<char>(entities[0u], 'c');
+    registry.emplace<char>(entities[2u], 'c');
 
     std::size_t cnt{};
     auto group = registry.group<int>(entt::get<char>);
@@ -931,15 +921,13 @@ TEST(Registry, PartialOwningGroupInitOnFirstUse) {
 
 TEST(Registry, PartialOwningGroupInitOnEmplace) {
     entt::registry registry;
+    entt::entity entities[3u];
     auto group = registry.group<int>(entt::get<char>);
-    auto create = [&](auto... component) {
-        const auto entity = registry.create();
-        (registry.emplace<decltype(component)>(entity, component), ...);
-    };
 
-    create(0, 'c');
-    create(0);
-    create(0, 'c');
+    registry.create(std::begin(entities), std::end(entities));
+    registry.insert<int>(std::begin(entities), std::end(entities), 0);
+    registry.emplace<char>(entities[0u], 'c');
+    registry.emplace<char>(entities[2u], 'c');
 
     std::size_t cnt{};
     group.each([&cnt](auto...) { ++cnt; });
@@ -1924,7 +1912,7 @@ TEST(RegistryDeathTest, RuntimePools) {
     using namespace entt::literals;
 
     entt::registry registry;
-    auto &storage = registry.storage<empty_type>("other"_hs);
+    registry.storage<empty_type>("other"_hs);
 
     ASSERT_DEATH(registry.storage<int>("other"_hs), "");
     ASSERT_DEATH(std::as_const(registry).storage<int>("other"_hs), "");

test/entt/entity/sparse_set.cpp

@@ -262,8 +262,6 @@ TEST(SparseSet, Pagination) {
 }
 
 TEST(SparseSet, Emplace) {
-    using traits_type = entt::entt_traits<entt::entity>;
-
     entt::sparse_set set{entt::deletion_policy::in_place};
     entt::entity entities[2u]{entt::entity{3}, entt::entity{42}};
 

test/entt/poly/poly.cpp

@@ -145,8 +145,8 @@ using PolyDeathTest = Poly<Type>;
 
 using PolyTypes = ::testing::Types<Deduced, Defined>;
 
-TYPED_TEST_SUITE(Poly, PolyTypes);
-TYPED_TEST_SUITE(PolyDeathTest, PolyTypes);
+TYPED_TEST_SUITE(Poly, PolyTypes, );
+TYPED_TEST_SUITE(PolyDeathTest, PolyTypes, );
 
 TYPED_TEST(Poly, Functionalities) {
     using poly_type = typename TestFixture::basic;
@@ -335,9 +335,9 @@ TYPED_TEST(Poly, SBOVsZeroedSBOSize) {
     using poly_type = typename TestFixture::basic;
     using zeroed_type = typename TestFixture::zeroed;
 
-    poly_type sbo{impl{}};
-    const auto broken = sbo.data();
-    poly_type other = std::move(sbo);
+    poly_type poly{impl{}};
+    const auto broken = poly.data();
+    poly_type other = std::move(poly);
 
     ASSERT_NE(broken, other.data());
 
@@ -354,33 +354,29 @@ TYPED_TEST(Poly, SBOVsZeroedSBOSize) {
 }
 
 TYPED_TEST(Poly, SboAlignment) {
-    using poly_type = typename TestFixture::basic;
-
     const auto *data = TestFixture::sbo[0].data();
 
-    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::sbo[0u].data()) % alignment) == 0u);
-    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::sbo[1u].data()) % alignment) == 0u);
+    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::sbo[0u].data()) % TestFixture::alignment) == 0u);
+    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::sbo[1u].data()) % TestFixture::alignment) == 0u);
 
     std::swap(TestFixture::sbo[0], TestFixture::sbo[1]);
 
-    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::sbo[0u].data()) % alignment) == 0u);
-    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::sbo[1u].data()) % alignment) == 0u);
+    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::sbo[0u].data()) % TestFixture::alignment) == 0u);
+    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::sbo[1u].data()) % TestFixture::alignment) == 0u);
 
     ASSERT_NE(data, TestFixture::sbo[1].data());
 }
 
 TYPED_TEST(Poly, NoSboAlignment) {
-    using poly_type = typename TestFixture::basic;
-
     const auto *data = TestFixture::nosbo[0].data();
 
-    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::nosbo[0u].data()) % alignment) == 0u);
-    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::nosbo[1u].data()) % alignment) == 0u);
+    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::nosbo[0u].data()) % TestFixture::alignment) == 0u);
+    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::nosbo[1u].data()) % TestFixture::alignment) == 0u);
 
     std::swap(TestFixture::nosbo[0], TestFixture::nosbo[1]);
 
-    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::nosbo[0u].data()) % alignment) == 0u);
-    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::nosbo[1u].data()) % alignment) == 0u);
+    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::nosbo[0u].data()) % TestFixture::alignment) == 0u);
+    ASSERT_TRUE((reinterpret_cast<std::uintptr_t>(TestFixture::nosbo[1u].data()) % TestFixture::alignment) == 0u);
 
     ASSERT_EQ(data, TestFixture::nosbo[1].data());
 }