tests: review

test/entt/core/utility.cpp

@@ -23,4 +23,12 @@ TEST(Utility, Overload) {
 
     ASSERT_EQ(entt::overload<void(int)>(&Functions::bar), static_cast<void(Functions:: *)(int)>(&Functions::bar));
     ASSERT_EQ(entt::overload<void()>(&Functions::bar), static_cast<void(Functions:: *)()>(&Functions::bar));
+
+    Functions instance;
+
+    ASSERT_NO_THROW(entt::overload<void(int)>(&Functions::foo)(0));
+    ASSERT_NO_THROW(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))());
 }

test/entt/entity/group.cpp

@@ -468,8 +468,7 @@ TEST(NonOwningGroup, TrackEntitiesOnComponentDestruction) {
 
 TEST(NonOwningGroup, Less) {
     entt::registry registry;
-    const auto entity = std::get<0>(registry.create<int, entt::tag<"empty"_hs>>());
-    registry.create<char>();
+    const auto entity = std::get<0>(registry.create<int, char, entt::tag<"empty"_hs>>());
 
     registry.group(entt::get<int, char, entt::tag<"empty"_hs>>).less([entity](const auto entt, int, char) {
         ASSERT_EQ(entity, entt);
@@ -484,8 +483,8 @@ TEST(NonOwningGroup, Less) {
         ASSERT_EQ(entity, entt);
     });
 
-    registry.group(entt::get<int, char, double>).less([entity](const auto entt, int, char, double) {
-        ASSERT_EQ(entity, entt);
+    registry.group(entt::get<int, char, double>).less([](const auto, int, char, double) {
+        FAIL();
     });
 }
 
@@ -1043,8 +1042,7 @@ TEST(OwningGroup, TrackEntitiesOnComponentDestruction) {
 
 TEST(OwningGroup, Less) {
     entt::registry registry;
-    const auto entity = std::get<0>(registry.create<int, entt::tag<"empty"_hs>>());
-    registry.create<char>();
+    const auto entity = std::get<0>(registry.create<int, char, entt::tag<"empty"_hs>>());
 
     registry.group<int>(entt::get<char, entt::tag<"empty"_hs>>).less([entity](const auto entt, int, char) {
         ASSERT_EQ(entity, entt);
@@ -1059,8 +1057,8 @@ TEST(OwningGroup, Less) {
         ASSERT_EQ(entity, entt);
     });
 
-    registry.group<double>(entt::get<int, char>).less([entity](const auto entt, double, int, char) {
-        ASSERT_EQ(entity, entt);
+    registry.group<double>(entt::get<int, char>).less([](const auto, double, int, char) {
+        FAIL();
     });
 }
 

test/entt/entity/sparse_set.cpp

@@ -486,9 +486,7 @@ TEST(SparseSet, ArrangeRange) {
     entt::entity entities[5]{entt::entity{9}, entt::entity{7}, entt::entity{3}, entt::entity{12}, entt::entity{42}};
     set.batch(std::begin(entities), std::end(entities));
 
-    set.arrange(set.end(), set.end(), [&set, &entities](const auto lhs, const auto rhs) {
-        std::swap(entities[set.index(lhs)], entities[set.index(rhs)]);
-    }, std::less{});
+    set.arrange(set.end(), set.end(), [](const auto, const auto) { FAIL(); }, std::less{});
 
     ASSERT_EQ(*(set.data() + 0u), entt::entity{9});
     ASSERT_EQ(*(set.data() + 1u), entt::entity{7});
@@ -496,9 +494,7 @@ TEST(SparseSet, ArrangeRange) {
     ASSERT_EQ(*(set.data() + 3u), entt::entity{12});
     ASSERT_EQ(*(set.data() + 4u), entt::entity{42});
 
-    set.arrange(set.begin(), set.begin(), [&set, &entities](const auto lhs, const auto rhs) {
-        std::swap(entities[set.index(lhs)], entities[set.index(rhs)]);
-    }, std::less{});
+    set.arrange(set.begin(), set.begin(), [](const auto, const auto) { FAIL(); }, std::less{});
 
     ASSERT_EQ(*(set.data() + 0u), entt::entity{9});
     ASSERT_EQ(*(set.data() + 1u), entt::entity{7});
@@ -506,9 +502,7 @@ TEST(SparseSet, ArrangeRange) {
     ASSERT_EQ(*(set.data() + 3u), entt::entity{12});
     ASSERT_EQ(*(set.data() + 4u), entt::entity{42});
 
-    set.arrange(set.begin()+2, set.begin()+3, [&set, &entities](const auto lhs, const auto rhs) {
-        std::swap(entities[set.index(lhs)], entities[set.index(rhs)]);
-    }, std::less{});
+    set.arrange(set.begin()+2, set.begin()+3, [](const auto, const auto) { FAIL(); }, std::less{});
 
     ASSERT_EQ(*(set.data() + 0u), entt::entity{9});
     ASSERT_EQ(*(set.data() + 1u), entt::entity{7});

test/entt/entity/storage.cpp

@@ -460,9 +460,7 @@ TEST(Storage, SortRange) {
     ASSERT_EQ(pool.get(entt::entity{3}).value, 9);
     ASSERT_EQ(pool.get(entt::entity{9}).value, 12);
 
-    pool.sort(pool.end(), pool.end(), [](auto lhs, auto rhs) {
-        return lhs.value < rhs.value;
-    });
+    pool.sort(pool.end(), pool.end(), std::less{});
 
     ASSERT_EQ(pool.get(entt::entity{12}).value, 6);
     ASSERT_EQ(pool.get(entt::entity{42}).value, 3);
@@ -470,9 +468,7 @@ TEST(Storage, SortRange) {
     ASSERT_EQ(pool.get(entt::entity{3}).value, 9);
     ASSERT_EQ(pool.get(entt::entity{9}).value, 12);
 
-    pool.sort(pool.begin(), pool.begin(), [](auto lhs, auto rhs) {
-        return lhs.value < rhs.value;
-    });
+    pool.sort(pool.begin(), pool.begin(), std::less{});
 
     ASSERT_EQ(pool.get(entt::entity{12}).value, 6);
     ASSERT_EQ(pool.get(entt::entity{42}).value, 3);
@@ -480,9 +476,7 @@ TEST(Storage, SortRange) {
     ASSERT_EQ(pool.get(entt::entity{3}).value, 9);
     ASSERT_EQ(pool.get(entt::entity{9}).value, 12);
 
-    pool.sort(pool.begin()+2, pool.begin()+3, [](auto lhs, auto rhs) {
-        return lhs.value < rhs.value;
-    });
+    pool.sort(pool.begin()+2, pool.begin()+3, std::less{});
 
     ASSERT_EQ(pool.get(entt::entity{12}).value, 6);
     ASSERT_EQ(pool.get(entt::entity{42}).value, 3);
@@ -787,8 +781,9 @@ TEST(Storage, ConstructorExceptionDoesNotAddToStorage) {
 
     try {
         pool.construct(entt::entity{0});
-        FAIL() << "Expected constructor_exception to be thrown";
     } catch (const throwing_component::constructor_exception &) {
         ASSERT_TRUE(pool.empty());
     }
+
+    ASSERT_TRUE(pool.empty());
 }

test/entt/meta/meta.cpp

@@ -52,10 +52,6 @@ union union_type {
     double d;
 };
 
-bool operator!=(const fat_type &lhs, const fat_type &rhs) {
-    return !(lhs == rhs);
-}
-
 struct base_type {
     virtual ~base_type() = default;
 };

test/entt/process/scheduler.cpp

@@ -100,9 +100,7 @@ TEST(Scheduler, Functor) {
         ASSERT_FALSE(second_functor);
         second_functor = true;
         reject();
-    }).then([](auto...){
-        FAIL();
-    });
+    }).then([](auto...){ FAIL(); });
 
     for(auto i = 0; i < 8; ++i) {
         scheduler.update(0);