test: minor changes

test/entt/core/iterator.cpp

@@ -8,7 +8,7 @@ struct clazz {
     int value{0};
 };
 
-TEST(Iterator, InputIteratorPointer) {
+TEST(InputIteratorPointer, Functionalities) {
     static_assert(!std::is_default_constructible_v<entt::input_iterator_pointer<clazz>>);
     static_assert(!std::is_copy_constructible_v<entt::input_iterator_pointer<clazz>>);
     static_assert(std::is_move_constructible_v<entt::input_iterator_pointer<clazz>>);
@@ -23,7 +23,7 @@ TEST(Iterator, InputIteratorPointer) {
     ASSERT_EQ(ptr->value, 42);
 }
 
-TEST(Iterator, IterableAdaptor) {
+TEST(IterableAdaptor, Functionalities) {
     std::vector<int> vec{1, 2};
     entt::iterable_adaptor iterable{vec.begin(), vec.end()};
     decltype(iterable) other{};

test/entt/core/memory.cpp

@@ -11,7 +11,7 @@
 #include "../common/throwing_type.hpp"
 #include "../common/tracked_memory_resource.hpp"
 
-TEST(Memory, ToAddress) {
+TEST(ToAddress, Functionalities) {
     std::shared_ptr<int> shared = std::make_shared<int>();
     auto *plain = std::addressof(*shared);
 
@@ -19,7 +19,7 @@ TEST(Memory, ToAddress) {
     ASSERT_EQ(entt::to_address(plain), plain);
 }
 
-TEST(Memory, PoccaPocmaAndPocs) {
+TEST(PoccaPocmaAndPocs, Functionalities) {
     test::basic_test_allocator<int> lhs, rhs;
     // honestly, I don't even know how one is supposed to test such a thing :)
     entt::propagate_on_container_copy_assignment(lhs, rhs);
@@ -27,7 +27,7 @@ TEST(Memory, PoccaPocmaAndPocs) {
     entt::propagate_on_container_swap(lhs, rhs);
 }
 
-TEST(Memory, IsPowerOfTwo) {
+TEST(IsPowerOfTwo, Functionalities) {
     // constexpr-ness guaranteed
     constexpr auto zero_is_power_of_two = entt::is_power_of_two(0u);
 
@@ -40,7 +40,7 @@ TEST(Memory, IsPowerOfTwo) {
     ASSERT_FALSE(entt::is_power_of_two(200u));
 }
 
-TEST(Memory, NextPowerOfTwo) {
+TEST(NextPowerOfTwo, Functionalities) {
     // constexpr-ness guaranteed
     constexpr auto next_power_of_two_of_zero = entt::next_power_of_two(0u);
 
@@ -55,11 +55,11 @@ TEST(Memory, NextPowerOfTwo) {
     ASSERT_EQ(entt::next_power_of_two(std::pow(2, 16) + 1u), std::pow(2, 17));
 }
 
-TEST(MemoryDeathTest, NextPowerOfTwo) {
+TEST(NextPowerOfTwoDeathTest, Functionalities) {
     ASSERT_DEATH(static_cast<void>(entt::next_power_of_two((std::size_t{1u} << (std::numeric_limits<std::size_t>::digits - 1)) + 1)), "");
 }
 
-TEST(Memory, FastMod) {
+TEST(FastMod, Functionalities) {
     // constexpr-ness guaranteed
     constexpr auto fast_mod_of_zero = entt::fast_mod(0u, 8u);
 
@@ -68,7 +68,7 @@ TEST(Memory, FastMod) {
     ASSERT_EQ(entt::fast_mod(8u, 8u), 0u);
 }
 
-TEST(Memory, AllocateUnique) {
+TEST(AllocateUnique, Functionalities) {
     test::throwing_allocator<test::throwing_type> allocator{};
     test::throwing_allocator<test::throwing_type>::trigger_on_allocate = true;
     test::throwing_type::trigger_on_value = 0;
@@ -88,7 +88,7 @@ TEST(Memory, AllocateUnique) {
 
 #if defined(ENTT_HAS_TRACKED_MEMORY_RESOURCE)
 
-TEST(Memory, NoUsesAllocatorConstruction) {
+TEST(AllocateUnique, NoUsesAllocatorConstruction) {
     test::tracked_memory_resource memory_resource{};
     std::pmr::polymorphic_allocator<int> allocator{&memory_resource};
 
@@ -100,7 +100,7 @@ TEST(Memory, NoUsesAllocatorConstruction) {
     ASSERT_EQ(memory_resource.do_deallocate_counter(), 0u);
 }
 
-TEST(Memory, UsesAllocatorConstruction) {
+TEST(AllocateUnique, UsesAllocatorConstruction) {
     using string_type = typename test::tracked_memory_resource::string_type;
 
     test::tracked_memory_resource memory_resource{};

test/entt/core/type_traits.cpp

@@ -20,14 +20,14 @@ struct nlohmann_json_like final {
     }
 };
 
-TEST(TypeTraits, SizeOf) {
+TEST(SizeOf, Functionalities) {
     static_assert(entt::size_of_v<void> == 0u);
     static_assert(entt::size_of_v<char> == sizeof(char));
     static_assert(entt::size_of_v<int[]> == 0u);
     static_assert(entt::size_of_v<int[3]> == sizeof(int[3]));
 }
 
-TEST(TypeTraits, UnpackAsType) {
+TEST(UnpackAsType, Functionalities) {
     auto test = [](auto &&...args) {
         return [](entt::unpack_as_type<int, decltype(args)>... value) {
             return (value + ... + 0);
@@ -37,7 +37,7 @@ TEST(TypeTraits, UnpackAsType) {
     ASSERT_EQ(test('c', 42., true)(1, 2, 3), 6);
 }
 
-TEST(TypeTraits, UnpackAsValue) {
+TEST(UnpackAsValue, Functionalities) {
     auto test = [](auto &&...args) {
         return (entt::unpack_as_value<2, decltype(args)> + ... + 0);
     };
@@ -45,19 +45,19 @@ TEST(TypeTraits, UnpackAsValue) {
     ASSERT_EQ(test('c', 42., true), 6);
 }
 
-TEST(TypeTraits, IntegralConstant) {
+TEST(IntegralConstant, Functionalities) {
     entt::integral_constant<3> constant{};
 
     static_assert(std::is_same_v<typename entt::integral_constant<3>::value_type, int>);
     static_assert(constant.value == 3);
 }
 
-TEST(TypeTraits, Choice) {
+TEST(Choice, Functionalities) {
     static_assert(std::is_base_of_v<entt::choice_t<0>, entt::choice_t<1>>);
     static_assert(!std::is_base_of_v<entt::choice_t<1>, entt::choice_t<0>>);
 }
 
-TEST(TypeTraits, TypeList) {
+TEST(TypeList, Functionalities) {
     using type = entt::type_list<int, char>;
     using other = entt::type_list<double>;
 
@@ -85,7 +85,7 @@ TEST(TypeTraits, TypeList) {
     static_assert(std::is_same_v<entt::type_list_diff_t<entt::type_list<int, char, double>, entt::type_list<char>>, entt::type_list<int, double>>);
 }
 
-TEST(TypeTraits, ValueList) {
+TEST(ValueList, Functionalities) {
     using value = entt::value_list<0, 2>;
     using other = entt::value_list<1>;
 
@@ -102,7 +102,7 @@ TEST(TypeTraits, ValueList) {
     static_assert(entt::value_list_element_v<0u, other> == 1);
 }
 
-TEST(TypeTraits, IsApplicable) {
+TEST(IsApplicable, Functionalities) {
     static_assert(entt::is_applicable_v<void(int, char), std::tuple<double, char>>);
     static_assert(!entt::is_applicable_v<void(int, char), std::tuple<int>>);
 
@@ -111,12 +111,12 @@ TEST(TypeTraits, IsApplicable) {
     static_assert(!entt::is_applicable_r_v<int, int(int, char), std::tuple<void>>);
 }
 
-TEST(TypeTraits, IsComplete) {
+TEST(IsComplete, Functionalities) {
     static_assert(!entt::is_complete_v<void>);
     static_assert(entt::is_complete_v<int>);
 }
 
-TEST(TypeTraits, IsIterator) {
+TEST(IsIterator, Functionalities) {
     static_assert(!entt::is_iterator_v<void>);
     static_assert(!entt::is_iterator_v<int>);
 
@@ -128,21 +128,21 @@ TEST(TypeTraits, IsIterator) {
     static_assert(entt::is_iterator_v<std::vector<int>::reverse_iterator>);
 }
 
-TEST(TypeTraits, IsEBCOEligible) {
+TEST(IsEBCOEligible, Functionalities) {
     static_assert(entt::is_ebco_eligible_v<not_comparable>);
     static_assert(!entt::is_ebco_eligible_v<nlohmann_json_like>);
     static_assert(!entt::is_ebco_eligible_v<double>);
     static_assert(!entt::is_ebco_eligible_v<void>);
 }
 
-TEST(TypeTraits, IsTransparent) {
+TEST(IsTransparent, Functionalities) {
     static_assert(!entt::is_transparent_v<std::less<int>>);
     static_assert(entt::is_transparent_v<std::less<void>>);
     static_assert(!entt::is_transparent_v<std::logical_not<double>>);
     static_assert(entt::is_transparent_v<std::logical_not<void>>);
 }
 
-TEST(TypeTraits, IsEqualityComparable) {
+TEST(IsEqualityComparable, Functionalities) {
     static_assert(entt::is_equality_comparable_v<int>);
     static_assert(entt::is_equality_comparable_v<const int>);
     static_assert(entt::is_equality_comparable_v<std::vector<int>>);
@@ -165,7 +165,7 @@ TEST(TypeTraits, IsEqualityComparable) {
     static_assert(!entt::is_equality_comparable_v<void>);
 }
 
-TEST(TypeTraits, IsStdHashable) {
+TEST(IsStdHashable, Functionalities) {
     static_assert(entt::is_std_hashable_v<int>);
     static_assert(entt::is_std_hashable_v<char>);
     static_assert(entt::is_std_hashable_v<double>);
@@ -174,14 +174,14 @@ TEST(TypeTraits, IsStdHashable) {
     static_assert(!entt::is_std_hashable_v<void>);
 }
 
-TEST(TypeTraits, ConstnessAs) {
+TEST(ConstnessAs, Functionalities) {
     static_assert(std::is_same_v<entt::constness_as_t<int, char>, int>);
     static_assert(std::is_same_v<entt::constness_as_t<const int, char>, int>);
     static_assert(std::is_same_v<entt::constness_as_t<int, const char>, const int>);
     static_assert(std::is_same_v<entt::constness_as_t<const int, const char>, const int>);
 }
 
-TEST(TypeTraits, MemberClass) {
+TEST(MemberClass, Functionalities) {
     struct clazz {
         char foo(int) {
             return {};
@@ -199,7 +199,7 @@ TEST(TypeTraits, MemberClass) {
     static_assert(std::is_same_v<clazz, entt::member_class_t<decltype(&clazz::quux)>>);
 }
 
-TEST(TypeTraits, Tag) {
+TEST(Tag, Functionalities) {
     using namespace entt::literals;
     static_assert(entt::tag<"foobar"_hs>::value == entt::hashed_string::value("foobar"));
     static_assert(std::is_same_v<typename entt::tag<"foobar"_hs>::value_type, entt::id_type>);

test/entt/core/utility.cpp

@@ -11,7 +11,7 @@ struct functions {
     void bar() {}
 };
 
-TEST(Utility, Identity) {
+TEST(Identity, Functionalities) {
     entt::identity identity;
     int value = 42;
 
@@ -20,7 +20,7 @@ TEST(Utility, Identity) {
     ASSERT_EQ(&identity(value), &value);
 }
 
-TEST(Utility, Overload) {
+TEST(Overload, Functionalities) {
     ASSERT_EQ(entt::overload<void(int)>(&functions::foo), static_cast<void (*)(int)>(&functions::foo));
     ASSERT_EQ(entt::overload<void()>(&functions::foo), static_cast<void (*)()>(&functions::foo));
 
@@ -36,7 +36,7 @@ TEST(Utility, Overload) {
     ASSERT_NO_FATAL_FAILURE((instance.*entt::overload<void()>(&functions::bar))());
 }
 
-TEST(Utility, Overloaded) {
+TEST(Overloaded, Functionalities) {
     int iv = 0;
     char cv = '\0';
 
@@ -51,7 +51,7 @@ TEST(Utility, Overloaded) {
     ASSERT_EQ(cv, 'c');
 }
 
-TEST(Utility, YCombinator) {
+TEST(YCombinator, Functionalities) {
     entt::y_combinator gauss([](const auto &self, auto value) -> unsigned int {
         return value ? (value + self(value - 1u)) : 0;
     });