test: full review of entt::any tests

test/entt/core/any.cpp

@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <array>
 #include <cstdint>
 #include <cstring>
 #include <iterator>
@@ -16,50 +17,37 @@
 #include "../common/non_comparable.h"
 #include "../common/non_movable.h"
 
-struct empty {
-    empty() = default;
+template<std::size_t Len>
+struct tracker {
+    tracker(int &cnt)
+        : counter{&cnt} {}
 
-    empty(const empty &) = default;
-    empty &operator=(const empty &) = delete;
+    tracker(const tracker &) = default;
+    tracker &operator=(const tracker &) = delete;
 
-    ~empty() {
-        ++counter;
+    ~tracker() {
+        ++(*counter);
     }
 
-    inline static int counter = 0; // NOLINT
+private:
+    std::array<std::byte, Len> buffer{};
+    int *counter{};
 };
 
 struct fat {
     fat(double v1, double v2, double v3, double v4)
         : value{v1, v2, v3, v4} {}
 
-    fat(const fat &) = default;
-    fat &operator=(const fat &) = default;
-
-    ~fat() {
-        ++counter;
-    }
-
     [[nodiscard]] bool operator==(const fat &other) const {
-        return std::equal(std::begin(value), std::end(value), std::begin(other.value), std::end(other.value));
+        return (value == other.value);
     }
 
-    inline static int counter{0}; // NOLINT
-    double value[4];              // NOLINT
+    std::array<double, 4u> value{};
 };
 
 struct alignas(64u) over_aligned {};
 
-struct Any: ::testing::Test {
-    void SetUp() override {
-        fat::counter = 0;
-        empty::counter = 0;
-    }
-};
-
-using AnyDeathTest = Any;
-
-TEST_F(Any, SBO) {
+TEST(Any, SBO) {
     entt::any any{'c'};
 
     ASSERT_TRUE(any);
@@ -69,7 +57,7 @@ TEST_F(Any, SBO) {
     ASSERT_EQ(entt::any_cast<char>(any), 'c');
 }
 
-TEST_F(Any, NoSBO) {
+TEST(Any, NoSBO) {
     const fat instance{.1, .2, .3, .4};
     entt::any any{instance};
 
@@ -80,7 +68,7 @@ TEST_F(Any, NoSBO) {
     ASSERT_EQ(entt::any_cast<fat>(any), instance);
 }
 
-TEST_F(Any, Empty) {
+TEST(Any, Empty) {
     entt::any any{};
 
     ASSERT_FALSE(any);
@@ -90,7 +78,7 @@ TEST_F(Any, Empty) {
     ASSERT_EQ(any.data(), nullptr);
 }
 
-TEST_F(Any, SBOInPlaceTypeConstruction) {
+TEST(Any, SBOInPlaceTypeConstruction) {
     entt::any any{std::in_place_type<int>, 2};
 
     ASSERT_TRUE(any);
@@ -108,7 +96,7 @@ TEST_F(Any, SBOInPlaceTypeConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST_F(Any, SBOAsRefConstruction) {
+TEST(Any, SBOAsRefConstruction) {
     int value = 2;
     entt::any any{entt::forward_as_any(value)};
 
@@ -144,7 +132,7 @@ TEST_F(Any, SBOAsRefConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST_F(Any, SBOAsConstRefConstruction) {
+TEST(Any, SBOAsConstRefConstruction) {
     const int value = 2;
     entt::any any{entt::forward_as_any(value)};
 
@@ -180,7 +168,7 @@ TEST_F(Any, SBOAsConstRefConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST_F(Any, SBOCopyConstruction) {
+TEST(Any, SBOCopyConstruction) {
     const entt::any any{2};
     entt::any other{any};
 
@@ -192,7 +180,7 @@ TEST_F(Any, SBOCopyConstruction) {
     ASSERT_EQ(entt::any_cast<int>(other), 2);
 }
 
-TEST_F(Any, SBOCopyAssignment) {
+TEST(Any, SBOCopyAssignment) {
     const entt::any any{2};
     entt::any other{3};
 
@@ -206,7 +194,7 @@ TEST_F(Any, SBOCopyAssignment) {
     ASSERT_EQ(entt::any_cast<int>(other), 2);
 }
 
-TEST_F(Any, SBOMoveConstruction) {
+TEST(Any, SBOMoveConstruction) {
     entt::any any{2};
     entt::any other{std::move(any)};
 
@@ -220,7 +208,7 @@ TEST_F(Any, SBOMoveConstruction) {
     ASSERT_EQ(entt::any_cast<int>(other), 2);
 }
 
-TEST_F(Any, SBOMoveAssignment) {
+TEST(Any, SBOMoveAssignment) {
     entt::any any{2};
     entt::any other{3};
 
@@ -235,7 +223,7 @@ TEST_F(Any, SBOMoveAssignment) {
     ASSERT_EQ(entt::any_cast<int>(other), 2);
 }
 
-TEST_F(Any, SBODirectAssignment) {
+TEST(Any, SBODirectAssignment) {
     entt::any any{};
     any = 2;
 
@@ -246,7 +234,7 @@ TEST_F(Any, SBODirectAssignment) {
     ASSERT_EQ(entt::any_cast<int>(any), 2);
 }
 
-TEST_F(Any, SBOAssignValue) {
+TEST(Any, SBOAssignValue) {
     entt::any any{2};
     const entt::any other{3};
     const entt::any invalid{'c'};
@@ -259,7 +247,7 @@ TEST_F(Any, SBOAssignValue) {
     ASSERT_EQ(entt::any_cast<int>(any), 3);
 }
 
-TEST_F(Any, SBOAsRefAssignValue) {
+TEST(Any, SBOAsRefAssignValue) {
     int value = 2;
     entt::any any{entt::forward_as_any(value)};
     const entt::any other{3};
@@ -274,7 +262,7 @@ TEST_F(Any, SBOAsRefAssignValue) {
     ASSERT_EQ(value, 3);
 }
 
-TEST_F(Any, SBOAsConstRefAssignValue) {
+TEST(Any, SBOAsConstRefAssignValue) {
     const int value = 2;
     entt::any any{entt::forward_as_any(value)};
     const entt::any other{3};
@@ -289,7 +277,7 @@ TEST_F(Any, SBOAsConstRefAssignValue) {
     ASSERT_EQ(value, 2);
 }
 
-TEST_F(Any, SBOTransferValue) {
+TEST(Any, SBOTransferValue) {
     entt::any any{2};
 
     ASSERT_TRUE(any);
@@ -300,7 +288,7 @@ TEST_F(Any, SBOTransferValue) {
     ASSERT_EQ(entt::any_cast<int>(any), 3);
 }
 
-TEST_F(Any, SBOTransferConstValue) {
+TEST(Any, SBOTransferConstValue) {
     const int value = 3;
     entt::any any{2};
 
@@ -311,7 +299,7 @@ TEST_F(Any, SBOTransferConstValue) {
     ASSERT_EQ(entt::any_cast<int>(any), 3);
 }
 
-TEST_F(Any, SBOAsRefTransferValue) {
+TEST(Any, SBOAsRefTransferValue) {
     int value = 2;
     entt::any any{entt::forward_as_any(value)};
 
@@ -324,7 +312,7 @@ TEST_F(Any, SBOAsRefTransferValue) {
     ASSERT_EQ(value, 3);
 }
 
-TEST_F(Any, SBOAsConstRefTransferValue) {
+TEST(Any, SBOAsConstRefTransferValue) {
     const int value = 2;
     entt::any any{entt::forward_as_any(value)};
 
@@ -337,7 +325,7 @@ TEST_F(Any, SBOAsConstRefTransferValue) {
     ASSERT_EQ(value, 2);
 }
 
-TEST_F(Any, NoSBOInPlaceTypeConstruction) {
+TEST(Any, NoSBOInPlaceTypeConstruction) {
     const fat instance{.1, .2, .3, .4};
     entt::any any{std::in_place_type<fat>, instance};
 
@@ -356,7 +344,7 @@ TEST_F(Any, NoSBOInPlaceTypeConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST_F(Any, NoSBOAsRefConstruction) {
+TEST(Any, NoSBOAsRefConstruction) {
     fat instance{.1, .2, .3, .4};
     entt::any any{entt::forward_as_any(instance)};
 
@@ -393,7 +381,7 @@ TEST_F(Any, NoSBOAsRefConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST_F(Any, NoSBOAsConstRefConstruction) {
+TEST(Any, NoSBOAsConstRefConstruction) {
     const fat instance{.1, .2, .3, .4};
     entt::any any{entt::forward_as_any(instance)};
 
@@ -429,7 +417,7 @@ TEST_F(Any, NoSBOAsConstRefConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST_F(Any, NoSBOCopyConstruction) {
+TEST(Any, NoSBOCopyConstruction) {
     const fat instance{.1, .2, .3, .4};
     const entt::any any{instance};
     entt::any other{any};
@@ -442,7 +430,7 @@ TEST_F(Any, NoSBOCopyConstruction) {
     ASSERT_EQ(entt::any_cast<fat>(other), instance);
 }
 
-TEST_F(Any, NoSBOCopyAssignment) {
+TEST(Any, NoSBOCopyAssignment) {
     const fat instance{.1, .2, .3, .4};
     const entt::any any{instance};
     entt::any other{3};
@@ -457,7 +445,7 @@ TEST_F(Any, NoSBOCopyAssignment) {
     ASSERT_EQ(entt::any_cast<fat>(other), instance);
 }
 
-TEST_F(Any, NoSBOMoveConstruction) {
+TEST(Any, NoSBOMoveConstruction) {
     const fat instance{.1, .2, .3, .4};
     entt::any any{instance};
     entt::any other{std::move(any)};
@@ -472,7 +460,7 @@ TEST_F(Any, NoSBOMoveConstruction) {
     ASSERT_EQ(entt::any_cast<fat>(other), instance);
 }
 
-TEST_F(Any, NoSBOMoveAssignment) {
+TEST(Any, NoSBOMoveAssignment) {
     const fat instance{.1, .2, .3, .4};
     entt::any any{instance};
     entt::any other{3};
@@ -488,7 +476,7 @@ TEST_F(Any, NoSBOMoveAssignment) {
     ASSERT_EQ(entt::any_cast<fat>(other), instance);
 }
 
-TEST_F(Any, NoSBODirectAssignment) {
+TEST(Any, NoSBODirectAssignment) {
     const fat instance{.1, .2, .3, .4};
     entt::any any{};
     any = instance;
@@ -500,7 +488,7 @@ TEST_F(Any, NoSBODirectAssignment) {
     ASSERT_EQ(entt::any_cast<fat>(any), instance);
 }
 
-TEST_F(Any, NoSBOAssignValue) {
+TEST(Any, NoSBOAssignValue) {
     entt::any any{fat{.1, .2, .3, .4}};
     const entt::any other{fat{.0, .1, .2, .3}};
     const entt::any invalid{'c'};
@@ -516,7 +504,7 @@ TEST_F(Any, NoSBOAssignValue) {
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
-TEST_F(Any, NoSBOAsRefAssignValue) {
+TEST(Any, NoSBOAsRefAssignValue) {
     fat instance{.1, .2, .3, .4};
     entt::any any{entt::forward_as_any(instance)};
     const entt::any other{fat{.0, .1, .2, .3}};
@@ -531,7 +519,7 @@ TEST_F(Any, NoSBOAsRefAssignValue) {
     ASSERT_EQ(instance, (fat{.0, .1, .2, .3}));
 }
 
-TEST_F(Any, NoSBOAsConstRefAssignValue) {
+TEST(Any, NoSBOAsConstRefAssignValue) {
     const fat instance{.1, .2, .3, .4};
     entt::any any{entt::forward_as_any(instance)};
     const entt::any other{fat{.0, .1, .2, .3}};
@@ -546,7 +534,7 @@ TEST_F(Any, NoSBOAsConstRefAssignValue) {
     ASSERT_EQ(instance, (fat{.1, .2, .3, .4}));
 }
 
-TEST_F(Any, NoSBOTransferValue) {
+TEST(Any, NoSBOTransferValue) {
     entt::any any{fat{.1, .2, .3, .4}};
 
     const void *addr = std::as_const(any).data();
@@ -560,7 +548,7 @@ TEST_F(Any, NoSBOTransferValue) {
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
-TEST_F(Any, NoSBOTransferConstValue) {
+TEST(Any, NoSBOTransferConstValue) {
     const fat instance{.0, .1, .2, .3};
     entt::any any{fat{.1, .2, .3, .4}};
 
@@ -574,7 +562,7 @@ TEST_F(Any, NoSBOTransferConstValue) {
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
-TEST_F(Any, NoSBOAsRefTransferValue) {
+TEST(Any, NoSBOAsRefTransferValue) {
     fat instance{.1, .2, .3, .4};
     entt::any any{entt::forward_as_any(instance)};
 
@@ -590,7 +578,7 @@ TEST_F(Any, NoSBOAsRefTransferValue) {
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
-TEST_F(Any, NoSBOAsConstRefTransferValue) {
+TEST(Any, NoSBOAsConstRefTransferValue) {
     const fat instance{.1, .2, .3, .4};
     entt::any any{entt::forward_as_any(instance)};
 
@@ -606,7 +594,7 @@ TEST_F(Any, NoSBOAsConstRefTransferValue) {
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
-TEST_F(Any, VoidInPlaceTypeConstruction) {
+TEST(Any, VoidInPlaceTypeConstruction) {
     entt::any any{std::in_place_type<void>};
 
     ASSERT_FALSE(any);
@@ -615,7 +603,7 @@ TEST_F(Any, VoidInPlaceTypeConstruction) {
     ASSERT_EQ(entt::any_cast<int>(&any), nullptr);
 }
 
-TEST_F(Any, VoidCopyConstruction) {
+TEST(Any, VoidCopyConstruction) {
     entt::any any{std::in_place_type<void>};
     entt::any other{any};
 
@@ -627,7 +615,7 @@ TEST_F(Any, VoidCopyConstruction) {
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
 }
 
-TEST_F(Any, VoidCopyAssignment) {
+TEST(Any, VoidCopyAssignment) {
     entt::any any{std::in_place_type<void>};
     entt::any other{2};
 
@@ -641,7 +629,7 @@ TEST_F(Any, VoidCopyAssignment) {
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
 }
 
-TEST_F(Any, VoidMoveConstruction) {
+TEST(Any, VoidMoveConstruction) {
     entt::any any{std::in_place_type<void>};
     entt::any other{std::move(any)};
 
@@ -654,7 +642,7 @@ TEST_F(Any, VoidMoveConstruction) {
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
 }
 
-TEST_F(Any, VoidMoveAssignment) {
+TEST(Any, VoidMoveAssignment) {
     entt::any any{std::in_place_type<void>};
     entt::any other{2};
 
@@ -668,7 +656,7 @@ TEST_F(Any, VoidMoveAssignment) {
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
 }
 
-TEST_F(Any, SBOMoveValidButUnspecifiedState) {
+TEST(Any, SBOMoveValidButUnspecifiedState) {
     entt::any any{2};
     entt::any other{std::move(any)};
     const entt::any valid = std::move(other);
@@ -681,7 +669,7 @@ TEST_F(Any, SBOMoveValidButUnspecifiedState) {
     ASSERT_TRUE(valid);
 }
 
-TEST_F(Any, NoSBOMoveValidButUnspecifiedState) {
+TEST(Any, NoSBOMoveValidButUnspecifiedState) {
     const fat instance{.1, .2, .3, .4};
     entt::any any{instance};
     entt::any other{std::move(any)};
@@ -695,7 +683,7 @@ TEST_F(Any, NoSBOMoveValidButUnspecifiedState) {
     ASSERT_TRUE(valid);
 }
 
-TEST_F(Any, VoidMoveValidButUnspecifiedState) {
+TEST(Any, VoidMoveValidButUnspecifiedState) {
     entt::any any{std::in_place_type<void>};
     entt::any other{std::move(any)};
     const entt::any valid = std::move(other);
@@ -708,36 +696,44 @@ TEST_F(Any, VoidMoveValidButUnspecifiedState) {
     ASSERT_FALSE(valid);
 }
 
-TEST_F(Any, SBODestruction) {
+TEST(Any, SBODestruction) {
+    using tracker_type = tracker<0u>;
+
+    int counter{};
+
     {
-        entt::any any{std::in_place_type<empty>};
-        any.emplace<empty>();
-        any = empty{};
+        entt::any any{std::in_place_type<tracker_type>, counter};
+        any.emplace<tracker_type>(counter);
+        any = tracker_type{counter};
         entt::any other{std::move(any)};
         any = std::move(other);
     }
 
-    ASSERT_EQ(empty::counter, 6);
+    ASSERT_EQ(counter, 6);
 }
 
-TEST_F(Any, NoSBODestruction) {
+TEST(Any, NoSBODestruction) {
+    using tracker_type = tracker<entt::any::length>;
+
+    int counter{};
+
     {
-        entt::any any{std::in_place_type<fat>, 1., 2., 3., 4.};
-        any.emplace<fat>(1., 2., 3., 4.);
-        any = fat{1., 2., 3., 4.};
+        entt::any any{std::in_place_type<tracker_type>, counter};
+        any.emplace<tracker_type>(counter);
+        any = tracker_type{counter};
         entt::any other{std::move(any)};
         any = std::move(other);
     }
 
-    ASSERT_EQ(fat::counter, 4);
+    ASSERT_EQ(counter, 4);
 }
 
-TEST_F(Any, VoidDestruction) {
+TEST(Any, VoidDestruction) {
     // just let asan tell us if everything is ok here
     [[maybe_unused]] const entt::any any{std::in_place_type<void>};
 }
 
-TEST_F(Any, Emplace) {
+TEST(Any, Emplace) {
     entt::any any{};
     any.emplace<int>(2);
 
@@ -748,7 +744,7 @@ TEST_F(Any, Emplace) {
     ASSERT_EQ(entt::any_cast<int>(any), 2);
 }
 
-TEST_F(Any, EmplaceVoid) {
+TEST(Any, EmplaceVoid) {
     entt::any any{};
     any.emplace<void>();
 
@@ -757,7 +753,7 @@ TEST_F(Any, EmplaceVoid) {
     ASSERT_EQ(any.type(), entt::type_id<void>());
 }
 
-TEST_F(Any, Reset) {
+TEST(Any, Reset) {
     entt::any any{2};
 
     ASSERT_TRUE(any);
@@ -784,7 +780,7 @@ TEST_F(Any, Reset) {
     ASSERT_EQ(any.type(), entt::type_id<void>());
 }
 
-TEST_F(Any, SBOSwap) {
+TEST(Any, SBOSwap) {
     entt::any lhs{'c'};
     entt::any rhs{2};
 
@@ -801,7 +797,7 @@ TEST_F(Any, SBOSwap) {
     ASSERT_EQ(entt::any_cast<char>(rhs), 'c');
 }
 
-TEST_F(Any, NoSBOSwap) {
+TEST(Any, NoSBOSwap) {
     entt::any lhs{fat{.1, .2, .3, .4}};
     entt::any rhs{fat{.4, .3, .2, .1}};
 
@@ -814,7 +810,7 @@ TEST_F(Any, NoSBOSwap) {
     ASSERT_EQ(entt::any_cast<fat>(rhs), (fat{.1, .2, .3, .4}));
 }
 
-TEST_F(Any, VoidSwap) {
+TEST(Any, VoidSwap) {
     entt::any lhs{std::in_place_type<void>};
     entt::any rhs{std::in_place_type<void>};
     const auto *pre = lhs.data();
@@ -827,7 +823,7 @@ TEST_F(Any, VoidSwap) {
     ASSERT_EQ(pre, lhs.data());
 }
 
-TEST_F(Any, SBOWithNoSBOSwap) {
+TEST(Any, SBOWithNoSBOSwap) {
     entt::any lhs{fat{.1, .2, .3, .4}};
     entt::any rhs{'c'};
 
@@ -844,7 +840,7 @@ TEST_F(Any, SBOWithNoSBOSwap) {
     ASSERT_EQ(entt::any_cast<fat>(rhs), (fat{.1, .2, .3, .4}));
 }
 
-TEST_F(Any, SBOWithRefSwap) {
+TEST(Any, SBOWithRefSwap) {
     int value = 3;
     entt::any lhs{entt::forward_as_any(value)};
     entt::any rhs{'c'};
@@ -863,7 +859,7 @@ TEST_F(Any, SBOWithRefSwap) {
     ASSERT_EQ(rhs.data(), &value);
 }
 
-TEST_F(Any, SBOWithConstRefSwap) {
+TEST(Any, SBOWithConstRefSwap) {
     const int value = 3;
     entt::any lhs{entt::forward_as_any(value)};
     entt::any rhs{'c'};
@@ -883,7 +879,7 @@ TEST_F(Any, SBOWithConstRefSwap) {
     ASSERT_EQ(std::as_const(rhs).data(), &value);
 }
 
-TEST_F(Any, SBOWithEmptySwap) {
+TEST(Any, SBOWithEmptySwap) {
     entt::any lhs{'c'};
     entt::any rhs{};
 
@@ -906,7 +902,7 @@ TEST_F(Any, SBOWithEmptySwap) {
     ASSERT_EQ(entt::any_cast<char>(lhs), 'c');
 }
 
-TEST_F(Any, SBOWithVoidSwap) {
+TEST(Any, SBOWithVoidSwap) {
     entt::any lhs{'c'};
     entt::any rhs{std::in_place_type<void>};
 
@@ -929,7 +925,7 @@ TEST_F(Any, SBOWithVoidSwap) {
     ASSERT_EQ(entt::any_cast<char>(lhs), 'c');
 }
 
-TEST_F(Any, NoSBOWithRefSwap) {
+TEST(Any, NoSBOWithRefSwap) {
     int value = 3;
     entt::any lhs{entt::forward_as_any(value)};
     entt::any rhs{fat{.1, .2, .3, .4}};
@@ -948,7 +944,7 @@ TEST_F(Any, NoSBOWithRefSwap) {
     ASSERT_EQ(rhs.data(), &value);
 }
 
-TEST_F(Any, NoSBOWithConstRefSwap) {
+TEST(Any, NoSBOWithConstRefSwap) {
     const int value = 3;
     entt::any lhs{entt::forward_as_any(value)};
     entt::any rhs{fat{.1, .2, .3, .4}};
@@ -968,7 +964,7 @@ TEST_F(Any, NoSBOWithConstRefSwap) {
     ASSERT_EQ(std::as_const(rhs).data(), &value);
 }
 
-TEST_F(Any, NoSBOWithEmptySwap) {
+TEST(Any, NoSBOWithEmptySwap) {
     entt::any lhs{fat{.1, .2, .3, .4}};
     entt::any rhs{};
 
@@ -991,7 +987,7 @@ TEST_F(Any, NoSBOWithEmptySwap) {
     ASSERT_EQ(entt::any_cast<fat>(lhs), (fat{.1, .2, .3, .4}));
 }
 
-TEST_F(Any, NoSBOWithVoidSwap) {
+TEST(Any, NoSBOWithVoidSwap) {
     entt::any lhs{fat{.1, .2, .3, .4}};
     entt::any rhs{std::in_place_type<void>};
 
@@ -1014,7 +1010,7 @@ TEST_F(Any, NoSBOWithVoidSwap) {
     ASSERT_EQ(entt::any_cast<fat>(lhs), (fat{.1, .2, .3, .4}));
 }
 
-TEST_F(Any, AsRef) {
+TEST(Any, AsRef) {
     entt::any any{2};
     auto ref = any.as_ref();
     auto cref = std::as_const(any).as_ref();
@@ -1092,7 +1088,7 @@ TEST_F(Any, AsRef) {
     ASSERT_NE(entt::any_cast<int>(&cref), any.data());
 }
 
-TEST_F(Any, Comparable) {
+TEST(Any, Comparable) {
     const entt::any any{'c'};
     const entt::any other{'a'};
 
@@ -1106,7 +1102,7 @@ TEST_F(Any, Comparable) {
     ASSERT_TRUE(entt::any{} != any);
 }
 
-TEST_F(Any, NoSBOComparable) {
+TEST(Any, NoSBOComparable) {
     const entt::any any{fat{.1, .2, .3, .4}};
     const entt::any other{fat{.0, .1, .2, .3}};
 
@@ -1120,7 +1116,7 @@ TEST_F(Any, NoSBOComparable) {
     ASSERT_TRUE(entt::any{} != any);
 }
 
-TEST_F(Any, RefComparable) {
+TEST(Any, RefComparable) {
     int value = 2;
     const entt::any any{entt::forward_as_any(value)};
     const entt::any other{3};
@@ -1135,7 +1131,7 @@ TEST_F(Any, RefComparable) {
     ASSERT_TRUE(entt::any{} != any);
 }
 
-TEST_F(Any, ConstRefComparable) {
+TEST(Any, ConstRefComparable) {
     int value = 2;
     const entt::any any{3};
     const entt::any other{entt::make_any<const int &>(value)};
@@ -1150,7 +1146,7 @@ TEST_F(Any, ConstRefComparable) {
     ASSERT_TRUE(entt::any{} != any);
 }
 
-TEST_F(Any, UnrelatedComparable) {
+TEST(Any, UnrelatedComparable) {
     const entt::any any{'c'};
     const entt::any other{2};
 
@@ -1164,7 +1160,7 @@ TEST_F(Any, UnrelatedComparable) {
     ASSERT_TRUE(entt::any{} != any);
 }
 
-TEST_F(Any, NonComparable) {
+TEST(Any, NonComparable) {
     const test::non_comparable instance{};
     auto any = entt::forward_as_any(instance);
 
@@ -1177,7 +1173,7 @@ TEST_F(Any, NonComparable) {
     ASSERT_TRUE(entt::any{} != any);
 }
 
-TEST_F(Any, AssociativeContainerOfNonComparable) {
+TEST(Any, AssociativeContainerOfNonComparable) {
     const std::unordered_map<int, test::non_comparable> instance{};
     auto any = entt::forward_as_any(instance);
 
@@ -1190,7 +1186,7 @@ TEST_F(Any, AssociativeContainerOfNonComparable) {
     ASSERT_TRUE(entt::any{} != any);
 }
 
-TEST_F(Any, SequenceContainerOfNonComparable) {
+TEST(Any, SequenceContainerOfNonComparable) {
     const std::vector<test::non_comparable> instance{};
     auto any = entt::forward_as_any(instance);
 
@@ -1203,7 +1199,7 @@ TEST_F(Any, SequenceContainerOfNonComparable) {
     ASSERT_TRUE(entt::any{} != any);
 }
 
-TEST_F(Any, CompareVoid) {
+TEST(Any, CompareVoid) {
     const entt::any any{std::in_place_type<void>};
 
     ASSERT_EQ(any, any);
@@ -1218,7 +1214,7 @@ TEST_F(Any, CompareVoid) {
     ASSERT_FALSE(entt::any{} != any);
 }
 
-TEST_F(Any, AnyCast) {
+TEST(Any, AnyCast) {
     entt::any any{2};
     const auto &cany = any;
 
@@ -1238,7 +1234,7 @@ TEST_F(Any, AnyCast) {
     ASSERT_EQ(entt::any_cast<int>(entt::any{2}), 2);
 }
 
-ENTT_DEBUG_TEST_F(AnyDeathTest, AnyCast) {
+ENTT_DEBUG_TEST(AnyDeathTest, AnyCast) {
     entt::any any{2};
     const auto &cany = any;
 
@@ -1253,7 +1249,7 @@ ENTT_DEBUG_TEST_F(AnyDeathTest, AnyCast) {
     ASSERT_DEATH([[maybe_unused]] auto elem = entt::any_cast<double>(entt::any{2}), "");
 }
 
-TEST_F(Any, MakeAny) {
+TEST(Any, MakeAny) {
     int value = 2;
     auto any = entt::make_any<int>(value);
     auto ext = entt::make_any<int, sizeof(int), alignof(int)>(value);
@@ -1280,7 +1276,7 @@ TEST_F(Any, MakeAny) {
     ASSERT_EQ(ref.data(), &value);
 }
 
-TEST_F(Any, ForwardAsAny) {
+TEST(Any, ForwardAsAny) {
     int value = 2;
     auto ref = entt::forward_as_any(value);
     auto cref = entt::forward_as_any(std::as_const(value));
@@ -1306,7 +1302,7 @@ TEST_F(Any, ForwardAsAny) {
     ASSERT_EQ(ref.data(), &value);
 }
 
-TEST_F(Any, NonCopyableType) {
+TEST(Any, NonCopyableType) {
     const std::unique_ptr<int> value{};
     entt::any any{std::in_place_type<std::unique_ptr<int>>};
     entt::any other = entt::forward_as_any(value);
@@ -1338,7 +1334,7 @@ TEST_F(Any, NonCopyableType) {
     ASSERT_EQ(copy.policy(), entt::any_policy::owner);
 }
 
-TEST_F(Any, NonCopyableValueType) {
+TEST(Any, NonCopyableValueType) {
     std::vector<entt::any> vec{};
     vec.emplace_back(std::in_place_type<std::unique_ptr<int>>);
     vec.shrink_to_fit();
@@ -1355,7 +1351,7 @@ TEST_F(Any, NonCopyableValueType) {
     ASSERT_TRUE(vec[1u]);
 }
 
-TEST_F(Any, NonMovableType) {
+TEST(Any, NonMovableType) {
     entt::any any{std::in_place_type<test::non_movable>};
     entt::any other{std::in_place_type<test::non_movable>};
 
@@ -1386,24 +1382,29 @@ TEST_F(Any, NonMovableType) {
     ASSERT_EQ(copy.policy(), entt::any_policy::owner);
 }
 
-TEST_F(Any, Array) {
-    entt::any any{std::in_place_type<int[1]>}; // NOLINT
+TEST(Any, Array) {
+    // NOLINTNEXTLINE(*-avoid-c-arrays)
+    entt::any any{std::in_place_type<int[1]>};
     const entt::any copy{any};
 
     ASSERT_TRUE(any);
     ASSERT_FALSE(copy);
 
-    ASSERT_EQ(any.type(), entt::type_id<int[1]>());   // NOLINT
-    ASSERT_NE(entt::any_cast<int[1]>(&any), nullptr); // NOLINT
-    ASSERT_EQ(entt::any_cast<int[2]>(&any), nullptr); // NOLINT
+    // NOLINTBEGIN(*-avoid-c-arrays)
+    ASSERT_EQ(any.type(), entt::type_id<int[1]>());
+    ASSERT_NE(entt::any_cast<int[1]>(&any), nullptr);
+    ASSERT_EQ(entt::any_cast<int[2]>(&any), nullptr);
+    // NOLINTEND(*-avoid-c-arrays)
     ASSERT_EQ(entt::any_cast<int *>(&any), nullptr);
 
-    entt::any_cast<int(&)[1]>(any)[0] = 2; // NOLINT
+    // NOLINTNEXTLINE(*-avoid-c-arrays)
+    entt::any_cast<int(&)[1]>(any)[0] = 2;
 
-    ASSERT_EQ(entt::any_cast<const int(&)[1]>(std::as_const(any))[0], 2); // NOLINT
+    // NOLINTNEXTLINE(*-avoid-c-arrays)
+    ASSERT_EQ(entt::any_cast<const int(&)[1]>(std::as_const(any))[0], 2);
 }
 
-TEST_F(Any, CopyMoveReference) {
+TEST(Any, CopyMoveReference) {
     int value = 3;
     auto any = entt::forward_as_any(value);
     entt::any move = std::move(any);
@@ -1433,7 +1434,7 @@ TEST_F(Any, CopyMoveReference) {
     ASSERT_EQ(entt::any_cast<int &>(copy), 3);
 }
 
-TEST_F(Any, CopyMoveConstReference) {
+TEST(Any, CopyMoveConstReference) {
     int value = 3;
     auto any = entt::forward_as_any(std::as_const(value));
     entt::any move = std::move(any);
@@ -1463,7 +1464,7 @@ TEST_F(Any, CopyMoveConstReference) {
     ASSERT_EQ(entt::any_cast<const int &>(copy), 3);
 }
 
-TEST_F(Any, SBOVsZeroedSBOSize) {
+TEST(Any, SBOVsZeroedSBOSize) {
     entt::any sbo{2};
     const auto *broken = sbo.data();
     entt::any other = std::move(sbo);
@@ -1477,9 +1478,11 @@ TEST_F(Any, SBOVsZeroedSBOSize) {
     ASSERT_EQ(valid, same.data());
 }
 
-TEST_F(Any, SboAlignment) {
+TEST(Any, SboAlignment) {
     constexpr auto alignment = alignof(over_aligned);
-    entt::basic_any<alignment, alignment> sbo[2] = {over_aligned{}, over_aligned{}}; // NOLINT
+    using any_type = entt::basic_any<alignment, alignment>;
+
+    std::array<any_type, 2u> sbo = {over_aligned{}, over_aligned{}};
     const auto *data = sbo[0].data();
 
     // NOLINTBEGIN(*-reinterpret-cast)
@@ -1497,9 +1500,11 @@ TEST_F(Any, SboAlignment) {
     ASSERT_NE(data, sbo[1].data());
 }
 
-TEST_F(Any, NoSboAlignment) {
+TEST(Any, NoSboAlignment) {
     constexpr auto alignment = alignof(over_aligned);
-    entt::basic_any<alignment> nosbo[2] = {over_aligned{}, over_aligned{}}; // NOLINT
+    using any_type = entt::basic_any<alignment>;
+
+    std::array<any_type, 2u> nosbo = {over_aligned{}, over_aligned{}};
     const auto *data = nosbo[0].data();
 
     // NOLINTBEGIN(*-reinterpret-cast)
@@ -1517,12 +1522,12 @@ TEST_F(Any, NoSboAlignment) {
     ASSERT_EQ(data, nosbo[1].data());
 }
 
-TEST_F(Any, AggregatesMustWork) {
+TEST(Any, AggregatesMustWork) {
     // the goal of this test is to enforce the requirements for aggregate types
     entt::any{std::in_place_type<test::aggregate>, 2}.emplace<test::aggregate>(2);
 }
 
-TEST_F(Any, DeducedArrayType) {
+TEST(Any, DeducedArrayType) {
     entt::any any{"array of char"};
 
     ASSERT_TRUE(any);