any: no redundant copies, better perf

TODO

@@ -7,7 +7,9 @@
 * custom pools example (multi instance, tables, enable/disable, and so on...)
 
 WIP:
+* HP: see msvc only issue at https://godbolt.org/z/8KW9PhG4c
 * HP: scheduler, use any (or poly?) instead of unique_ptr
+* HP: any and the like: remove constructor that accepts reference wrapper, allow only in-place T& and entt::make_any<T>(...)
 * HP: resource, forward the id to the loader from the cache and if constexpr the call to load, update doc and describe customization points
 * HP: make it possible to create views of the type `view<T, T>`, add get by index and such, allow to register custom pools by name with the registry
 * HP: add user data to type_info
@@ -22,7 +24,6 @@ WIP:
 * HP: make runtime views use opaque storage and therefore return also elements.
 * HP: add exclude-only views to combine with packs
 * HP: entity-aware observer, add observer functions aside observer class
-* HP: any and the like: remove constructor that accepts reference wrapper, allow only in-place T&?
 * deprecate non-owning groups in favor of owning views and view packs, introduce lazy owning views
 * pagination doesn't work nicely across boundaries probably, give it a look. RO operations are fine, adding components maybe not.
 * snapshot: support for range-based archives

src/entt/core/any.hpp

@@ -48,117 +48,143 @@ class basic_any {
 
     template<typename Type>
     static const void * basic_vtable([[maybe_unused]] const operation op, [[maybe_unused]] const basic_any &from, [[maybe_unused]] const void *to) {
-        if constexpr(!std::is_void_v<Type>) {
-            if constexpr(std::is_lvalue_reference_v<Type>) {
-                using base_type = std::remove_const_t<std::remove_reference_t<Type>>;
-
-                switch(op) {
-                case operation::COPY:
-                    if constexpr(std::is_copy_constructible_v<base_type>) {
-                        as<basic_any>(to).template emplace<base_type>(*static_cast<const base_type *>(from.instance));
-                    }
-                    break;
-                case operation::MOVE:
-                    as<basic_any>(to).instance = from.instance;
-                    [[fallthrough]];
-                case operation::DTOR:
-                    break;
-                case operation::COMP:
-                    return compare<base_type>(from.instance, to) ? to : nullptr;
-                case operation::ADDR:
-                    return std::is_const_v<std::remove_reference_t<Type>> ? nullptr : from.instance;
-                case operation::CADDR:
-                    return from.instance;
-                case operation::REF:
-                    as<basic_any>(to).instance = from.instance;
-                    as<basic_any>(to).vtable = basic_vtable<Type>;
-                    break;
-                case operation::CREF:
-                    as<basic_any>(to).instance = from.instance;
-                    as<basic_any>(to).vtable = basic_vtable<const base_type &>;
-                    break;
-                case operation::TYPE:
-                    as<type_info>(to) = type_id<base_type>();
-                    break;
+        if constexpr(std::is_void_v<Type>) {
+            switch(op) {
+            case operation::COPY:
+            case operation::MOVE:
+            case operation::REF:
+            case operation::CREF:
+                as<basic_any>(to).vtable = from.vtable;
+                break;
+            default:
+                break;
+            }
+        } else if constexpr(std::is_lvalue_reference_v<Type>) {
+            using base_type = std::decay_t<Type>;
+
+            switch(op) {
+            case operation::COPY:
+                if constexpr(std::is_copy_constructible_v<base_type>) {
+                    as<basic_any>(to) = *static_cast<const base_type *>(from.instance);
                 }
-            } else if constexpr(in_situ<Type>) {
-                #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606L
-                auto *instance = const_cast<Type *>(std::launder(reinterpret_cast<const Type *>(&from.storage)));
-                #else
-                auto *instance = const_cast<Type *>(reinterpret_cast<const Type *>(&from.storage));
-                #endif
-
-                switch(op) {
-                case operation::COPY:
-                    if constexpr(std::is_copy_constructible_v<Type>) {
-                        new (&as<basic_any>(to).storage) Type{std::as_const(*instance)};
-                        as<basic_any>(to).vtable = from.vtable;
-                    }
-                    break;
-                case operation::MOVE:
-                    new (&as<basic_any>(to).storage) Type{std::move(*instance)};
-                    [[fallthrough]];
-                case operation::DTOR:
-                    instance->~Type();
-                    break;
-                case operation::COMP:
-                    return compare<Type>(instance, to) ? to : nullptr;
-                case operation::ADDR:
-                case operation::CADDR:
-                    return instance;
-                case operation::REF:
-                    as<basic_any>(to).instance = instance;
-                    as<basic_any>(to).vtable = basic_vtable<Type &>;
-                    break;
-                case operation::CREF:
-                    as<basic_any>(to).instance = instance;
-                    as<basic_any>(to).vtable = basic_vtable<const Type &>;
-                    break;
-                case operation::TYPE:
-                    as<type_info>(to) = type_id<Type>();
-                    break;
+                break;
+            case operation::MOVE:
+                as<basic_any>(to).instance = from.instance;
+                as<basic_any>(to).vtable = from.vtable;
+                [[fallthrough]];
+            case operation::DTOR:
+                break;
+            case operation::COMP:
+                return compare<base_type>(from.instance, to) ? to : nullptr;
+            case operation::ADDR:
+                return std::is_const_v<std::remove_reference_t<Type>> ? nullptr : from.instance;
+            case operation::CADDR:
+                return from.instance;
+            case operation::REF:
+                as<basic_any>(to).instance = from.instance;
+                as<basic_any>(to).vtable = basic_vtable<Type>;
+                break;
+            case operation::CREF:
+                as<basic_any>(to).instance = from.instance;
+                as<basic_any>(to).vtable = basic_vtable<const base_type &>;
+                break;
+            case operation::TYPE:
+                as<type_info>(to) = type_id<base_type>();
+                break;
+            }
+        } else if constexpr(in_situ<Type>) {
+            #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606L
+            auto *instance = const_cast<Type *>(std::launder(reinterpret_cast<const Type *>(&from.storage)));
+            #else
+            auto *instance = const_cast<Type *>(reinterpret_cast<const Type *>(&from.storage));
+            #endif
+
+            switch(op) {
+            case operation::COPY:
+                if constexpr(std::is_copy_constructible_v<Type>) {
+                    new (&as<basic_any>(to).storage) Type{std::as_const(*instance)};
+                    as<basic_any>(to).vtable = from.vtable;
                 }
-            } else {
-                switch(op) {
-                case operation::COPY:
-                    if constexpr(std::is_copy_constructible_v<Type>) {
-                        as<basic_any>(to).instance = new Type{*static_cast<const Type *>(from.instance)};
-                        as<basic_any>(to).vtable = from.vtable;
-                    }
-                    break;
-                case operation::MOVE:
-                    as<basic_any>(to).instance = from.instance;
-                    break;
-                case operation::DTOR:
-                    if constexpr(std::is_array_v<Type>) {
-                        delete[] static_cast<const Type *>(from.instance);
-                    } else {
-                        delete static_cast<const Type *>(from.instance);
-                    }
-                    break;
-                case operation::COMP:
-                    return compare<Type>(from.instance, to) ? to : nullptr;
-                case operation::ADDR:
-                case operation::CADDR:
-                    return from.instance;
-                case operation::REF:
-                    as<basic_any>(to).instance = from.instance;
-                    as<basic_any>(to).vtable = basic_vtable<Type &>;
-                    break;
-                case operation::CREF:
-                    as<basic_any>(to).instance = from.instance;
-                    as<basic_any>(to).vtable = basic_vtable<const Type &>;
-                    break;
-                case operation::TYPE:
-                    as<type_info>(to) = type_id<Type>();
-                    break;
+                break;
+            case operation::MOVE:
+                new (&as<basic_any>(to).storage) Type{std::move(*instance)};
+                as<basic_any>(to).vtable = from.vtable;
+                break;
+            case operation::DTOR:
+                instance->~Type();
+                break;
+            case operation::COMP:
+                return compare<Type>(instance, to) ? to : nullptr;
+            case operation::ADDR:
+            case operation::CADDR:
+                return instance;
+            case operation::REF:
+                as<basic_any>(to).instance = instance;
+                as<basic_any>(to).vtable = basic_vtable<Type &>;
+                break;
+            case operation::CREF:
+                as<basic_any>(to).instance = instance;
+                as<basic_any>(to).vtable = basic_vtable<const Type &>;
+                break;
+            case operation::TYPE:
+                as<type_info>(to) = type_id<Type>();
+                break;
+            }
+        } else {
+            switch(op) {
+            case operation::COPY:
+                if constexpr(std::is_copy_constructible_v<Type>) {
+                    as<basic_any>(to).instance = new Type{*static_cast<const Type *>(from.instance)};
+                    as<basic_any>(to).vtable = from.vtable;
                 }
+                break;
+            case operation::MOVE:
+                as<basic_any>(to).instance = std::exchange(as<basic_any>(&from).instance, nullptr);
+                as<basic_any>(to).vtable = from.vtable;
+                break;
+            case operation::DTOR:
+                if constexpr(std::is_array_v<Type>) {
+                    delete[] static_cast<const Type *>(from.instance);
+                } else {
+                    delete static_cast<const Type *>(from.instance);
+                }
+                break;
+            case operation::COMP:
+                return compare<Type>(from.instance, to) ? to : nullptr;
+            case operation::ADDR:
+            case operation::CADDR:
+                return from.instance;
+            case operation::REF:
+                as<basic_any>(to).instance = from.instance;
+                as<basic_any>(to).vtable = basic_vtable<Type &>;
+                break;
+            case operation::CREF:
+                as<basic_any>(to).instance = from.instance;
+                as<basic_any>(to).vtable = basic_vtable<const Type &>;
+                break;
+            case operation::TYPE:
+                as<type_info>(to) = type_id<Type>();
+                break;
             }
         }
 
         return nullptr;
     }
 
+    template<typename Type, typename... Args>
+    void initialize([[maybe_unused]] Args &&... args) {
+        if constexpr(!std::is_void_v<Type>) {
+            if constexpr(std::is_lvalue_reference_v<Type>) {
+                static_assert(sizeof...(Args) == 1u && (std::is_lvalue_reference_v<Args> && ...), "Invalid arguments");
+                instance = (std::addressof(args), ...);
+            } else if constexpr(in_situ<Type>) {
+                new (&storage) Type{std::forward<Args>(args)...};
+            } else {
+                instance = new Type{std::forward<Args>(args)...};
+            }
+        }
+    }
+
 public:
     /*! @brief Default constructor. */
     basic_any() ENTT_NOEXCEPT
@@ -172,20 +198,11 @@ public:
      * @param args Parameters to use to construct the instance.
      */
     template<typename Type, typename... Args>
-    explicit basic_any(std::in_place_type_t<Type>, [[maybe_unused]] Args &&... args)
+    explicit basic_any(std::in_place_type_t<Type>, Args &&... args)
         : instance{},
           vtable{&basic_vtable<Type>}
     {
-        if constexpr(!std::is_void_v<Type>) {
-            if constexpr(std::is_lvalue_reference_v<Type>) {
-                static_assert(sizeof...(Args) == 1u && (std::is_lvalue_reference_v<Args> && ...), "Invalid arguments");
-                instance = (std::addressof(args), ...);
-            } else if constexpr(in_situ<Type>) {
-                new (&storage) Type{std::forward<Args>(args)...};
-            } else {
-                instance = new Type{std::forward<Args>(args)...};
-            }
-        }
+        initialize<Type>(std::forward<Args>(args)...);
     }
 
     /**
@@ -213,7 +230,7 @@ public:
      * @param other The instance to copy from.
      */
     basic_any(const basic_any &other)
-        : basic_any{}
+        : basic_any{std::in_place_type<void>}
     {
         other.vtable(operation::COPY, other, this);
     }
@@ -223,10 +240,9 @@ public:
      * @param other The instance to move from.
      */
     basic_any(basic_any &&other) ENTT_NOEXCEPT
-        : basic_any{}
+        : basic_any{std::in_place_type<void>}
     {
         other.vtable(operation::MOVE, other, this);
-        vtable = std::exchange(other.vtable, &basic_vtable<void>);
     }
 
     /*! @brief Frees the internal storage, whatever it means. */
@@ -235,12 +251,49 @@ public:
     }
 
     /**
-     * @brief Assignment operator.
-     * @param other The instance to assign from.
+     * @brief Copy assignment operator.
+     * @param other The instance to copy from.
+     * @return This any object.
+     */
+    basic_any & operator=(const basic_any &other) {
+        vtable(operation::DTOR, *this, nullptr);
+        other.vtable(operation::COPY, other, this);
+        return *this;
+    }
+
+    /**
+     * @brief Move assignment operator.
+     * @param other The instance to move from.
+     * @return This any object.
+     */
+    basic_any & operator=(basic_any &&other) {
+        vtable(operation::DTOR, *this, nullptr);
+        other.vtable(operation::MOVE, other, this);
+        return *this;
+    }
+
+    /**
+     * @brief Value assignment operator.
+     * @tparam Type Type of object to use to initialize the wrapper.
+     * @param value An instance of an object to use to initialize the wrapper.
      * @return This any object.
      */
-    basic_any & operator=(basic_any other) {
-        swap(*this, other);
+    template<typename Type>
+    basic_any & operator=(std::reference_wrapper<Type> value) ENTT_NOEXCEPT {
+        emplace<Type &>(value.get());
+        return *this;
+    }
+
+    /**
+     * @brief Value assignment operator.
+     * @tparam Type Type of object to use to initialize the wrapper.
+     * @param value An instance of an object to use to initialize the wrapper.
+     * @return This any object.
+     */
+    template<typename Type>
+    std::enable_if_t<!std::is_same_v<std::decay_t<Type>, basic_any>, basic_any &>
+    operator=(Type &&value) {
+        emplace<std::decay_t<Type>>(std::forward<Type>(value));
         return *this;
     }
 
@@ -249,7 +302,7 @@ public:
      * @return The type of the contained object, if any.
      */
     [[nodiscard]] type_info type() const ENTT_NOEXCEPT {
-        type_info info;
+        type_info info{};
         vtable(operation::TYPE, *this, &info);
         return info;
     }
@@ -275,12 +328,13 @@ public:
      */
     template<typename Type, typename... Args>
     void emplace(Args &&... args) {
-        *this = basic_any{std::in_place_type<Type>, std::forward<Args>(args)...};
+        std::exchange(vtable, &basic_vtable<Type>)(operation::DTOR, *this, nullptr);
+        initialize<Type>(std::forward<Args>(args)...);
     }
 
     /*! @brief Destroys contained object */
     void reset() {
-        *this = basic_any{};
+        std::exchange(vtable, &basic_vtable<void>)(operation::DTOR, *this, nullptr);
     }
 
     /**
@@ -300,19 +354,6 @@ public:
         return type() == other.type() && (vtable(operation::COMP, *this, other.data()) == other.data());
     }
 
-    /**
-     * @brief Swaps two any objects.
-     * @param lhs A valid any object.
-     * @param rhs A valid any object.
-     */
-    friend void swap(basic_any &lhs, basic_any &rhs) {
-        basic_any tmp{};
-        lhs.vtable(operation::MOVE, lhs, &tmp);
-        rhs.vtable(operation::MOVE, rhs, &lhs);
-        lhs.vtable(operation::MOVE, tmp, &rhs);
-        std::swap(lhs.vtable, rhs.vtable);
-    }
-
     /**
      * @brief Aliasing constructor.
      * @return An any that shares a reference to an unmanaged object.

test/entt/core/any.cpp

@@ -4,24 +4,24 @@
 #include <gtest/gtest.h>
 #include <entt/core/any.hpp>
 
+struct empty {
+    ~empty() { ++counter; }
+    inline static int counter = 0;
+};
+
 struct fat {
     fat(double v1, double v2, double v3, double v4)
         : value{v1, v2, v3, v4}
     {}
 
-    double value[4];
-    inline static int counter{0};
-
     ~fat() { ++counter; }
 
     bool operator==(const fat &other) const {
         return std::equal(std::begin(value), std::end(value), std::begin(other.value), std::end(other.value));
     }
-};
 
-struct empty {
-    inline static int counter = 0;
-    ~empty() { ++counter; }
+    inline static int counter{0};
+    double value[4];
 };
 
 struct not_comparable {
@@ -40,7 +40,14 @@ struct not_copyable {
 
 struct alignas(64u) over_aligned {};
 
-TEST(Any, SBO) {
+struct Any: ::testing::Test {
+    void SetUp() override {
+        fat::counter = 0;
+        empty::counter = 0;
+    }
+};
+
+TEST_F(Any, SBO) {
     entt::any any{'c'};
 
     ASSERT_TRUE(any);
@@ -49,7 +56,7 @@ TEST(Any, SBO) {
     ASSERT_EQ(entt::any_cast<char>(any), 'c');
 }
 
-TEST(Any, NoSBO) {
+TEST_F(Any, NoSBO) {
     fat instance{.1, .2, .3, .4};
     entt::any any{instance};
 
@@ -59,7 +66,7 @@ TEST(Any, NoSBO) {
     ASSERT_EQ(entt::any_cast<fat>(any), instance);
 }
 
-TEST(Any, Empty) {
+TEST_F(Any, Empty) {
     entt::any any{};
 
     ASSERT_FALSE(any);
@@ -68,7 +75,7 @@ TEST(Any, Empty) {
     ASSERT_EQ(any.data(), nullptr);
 }
 
-TEST(Any, SBOInPlaceTypeConstruction) {
+TEST_F(Any, SBOInPlaceTypeConstruction) {
     entt::any any{std::in_place_type<int>, 42};
 
     ASSERT_TRUE(any);
@@ -84,7 +91,7 @@ TEST(Any, SBOInPlaceTypeConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST(Any, SBOAsRefConstruction) {
+TEST_F(Any, SBOAsRefConstruction) {
     int value = 42;
     entt::any any{std::ref(value)};
 
@@ -103,6 +110,12 @@ TEST(Any, SBOAsRefConstruction) {
     ASSERT_EQ(any.data(), &value);
     ASSERT_EQ(std::as_const(any).data(), &value);
 
+    any = std::ref(value);
+
+    ASSERT_TRUE(any);
+    ASSERT_EQ(any.type(), entt::type_id<int>());
+    ASSERT_EQ(entt::any_cast<int>(&any), &value);
+
     auto other = any.as_ref();
 
     ASSERT_TRUE(other);
@@ -111,7 +124,7 @@ TEST(Any, SBOAsRefConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST(Any, SBOAsConstRefConstruction) {
+TEST_F(Any, SBOAsConstRefConstruction) {
     int value = 42;
     entt::any any{std::cref(value)};
 
@@ -130,6 +143,12 @@ TEST(Any, SBOAsConstRefConstruction) {
     ASSERT_EQ(any.data(), nullptr);
     ASSERT_EQ(std::as_const(any).data(), &value);
 
+    any = std::cref(value);
+
+    ASSERT_TRUE(any);
+    ASSERT_EQ(any.type(), entt::type_id<int>());
+    ASSERT_EQ(entt::any_cast<const int>(&any), &value);
+
     auto other = any.as_ref();
 
     ASSERT_TRUE(other);
@@ -138,7 +157,7 @@ TEST(Any, SBOAsConstRefConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST(Any, SBOCopyConstruction) {
+TEST_F(Any, SBOCopyConstruction) {
     entt::any any{42};
     entt::any other{any};
 
@@ -150,7 +169,7 @@ TEST(Any, SBOCopyConstruction) {
     ASSERT_EQ(entt::any_cast<int>(other), 42);
 }
 
-TEST(Any, SBOCopyAssignment) {
+TEST_F(Any, SBOCopyAssignment) {
     entt::any any{42};
     entt::any other{3};
 
@@ -164,33 +183,35 @@ TEST(Any, SBOCopyAssignment) {
     ASSERT_EQ(entt::any_cast<int>(other), 42);
 }
 
-TEST(Any, SBOMoveConstruction) {
+TEST_F(Any, SBOMoveConstruction) {
     entt::any any{42};
     entt::any other{std::move(any)};
 
-    ASSERT_FALSE(any);
+    ASSERT_TRUE(any);
     ASSERT_TRUE(other);
-    ASSERT_FALSE(any.type());
+    ASSERT_NE(any.data(), nullptr);
+    ASSERT_EQ(any.type(), entt::type_id<int>());
     ASSERT_EQ(other.type(), entt::type_id<int>());
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
     ASSERT_EQ(entt::any_cast<int>(other), 42);
 }
 
-TEST(Any, SBOMoveAssignment) {
+TEST_F(Any, SBOMoveAssignment) {
     entt::any any{42};
     entt::any other{3};
 
     other = std::move(any);
 
-    ASSERT_FALSE(any);
+    ASSERT_TRUE(any);
     ASSERT_TRUE(other);
-    ASSERT_FALSE(any.type());
+    ASSERT_NE(any.data(), nullptr);
+    ASSERT_EQ(any.type(), entt::type_id<int>());
     ASSERT_EQ(other.type(), entt::type_id<int>());
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
     ASSERT_EQ(entt::any_cast<int>(other), 42);
 }
 
-TEST(Any, SBODirectAssignment) {
+TEST_F(Any, SBODirectAssignment) {
     entt::any any{};
     any = 42;
 
@@ -200,7 +221,7 @@ TEST(Any, SBODirectAssignment) {
     ASSERT_EQ(entt::any_cast<int>(any), 42);
 }
 
-TEST(Any, NoSBOInPlaceTypeConstruction) {
+TEST_F(Any, NoSBOInPlaceTypeConstruction) {
     fat instance{.1, .2, .3, .4};
     entt::any any{std::in_place_type<fat>, instance};
 
@@ -217,7 +238,7 @@ TEST(Any, NoSBOInPlaceTypeConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST(Any, NoSBOAsRefConstruction) {
+TEST_F(Any, NoSBOAsRefConstruction) {
     fat instance{.1, .2, .3, .4};
     entt::any any{std::ref(instance)};
 
@@ -236,6 +257,12 @@ TEST(Any, NoSBOAsRefConstruction) {
     ASSERT_EQ(any.data(), &instance);
     ASSERT_EQ(std::as_const(any).data(), &instance);
 
+    any = std::ref(instance);
+
+    ASSERT_TRUE(any);
+    ASSERT_EQ(any.type(), entt::type_id<fat>());
+    ASSERT_EQ(entt::any_cast<fat>(&any), &instance);
+
     auto other = any.as_ref();
 
     ASSERT_TRUE(other);
@@ -244,7 +271,7 @@ TEST(Any, NoSBOAsRefConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST(Any, NoSBOAsConstRefConstruction) {
+TEST_F(Any, NoSBOAsConstRefConstruction) {
     fat instance{.1, .2, .3, .4};
     entt::any any{std::cref(instance)};
 
@@ -263,6 +290,12 @@ TEST(Any, NoSBOAsConstRefConstruction) {
     ASSERT_EQ(any.data(), nullptr);
     ASSERT_EQ(std::as_const(any).data(), &instance);
 
+    any = std::cref(instance);
+
+    ASSERT_TRUE(any);
+    ASSERT_EQ(any.type(), entt::type_id<fat>());
+    ASSERT_EQ(entt::any_cast<const fat>(&any), &instance);
+
     auto other = any.as_ref();
 
     ASSERT_TRUE(other);
@@ -271,7 +304,7 @@ TEST(Any, NoSBOAsConstRefConstruction) {
     ASSERT_EQ(other.data(), any.data());
 }
 
-TEST(Any, NoSBOCopyConstruction) {
+TEST_F(Any, NoSBOCopyConstruction) {
     fat instance{.1, .2, .3, .4};
     entt::any any{instance};
     entt::any other{any};
@@ -284,7 +317,7 @@ TEST(Any, NoSBOCopyConstruction) {
     ASSERT_EQ(entt::any_cast<fat>(other), instance);
 }
 
-TEST(Any, NoSBOCopyAssignment) {
+TEST_F(Any, NoSBOCopyAssignment) {
     fat instance{.1, .2, .3, .4};
     entt::any any{instance};
     entt::any other{3};
@@ -299,19 +332,21 @@ TEST(Any, NoSBOCopyAssignment) {
     ASSERT_EQ(entt::any_cast<fat>(other), instance);
 }
 
-TEST(Any, NoSBOMoveConstruction) {
+TEST_F(Any, NoSBOMoveConstruction) {
     fat instance{.1, .2, .3, .4};
     entt::any any{instance};
     entt::any other{std::move(any)};
 
     ASSERT_FALSE(any);
     ASSERT_TRUE(other);
+    ASSERT_EQ(any.data(), nullptr);
+    ASSERT_EQ(any.type(), entt::type_id<fat>());
     ASSERT_EQ(other.type(), entt::type_id<fat>());
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
     ASSERT_EQ(entt::any_cast<fat>(other), instance);
 }
 
-TEST(Any, NoSBOMoveAssignment) {
+TEST_F(Any, NoSBOMoveAssignment) {
     fat instance{.1, .2, .3, .4};
     entt::any any{instance};
     entt::any other{3};
@@ -320,12 +355,14 @@ TEST(Any, NoSBOMoveAssignment) {
 
     ASSERT_FALSE(any);
     ASSERT_TRUE(other);
+    ASSERT_EQ(any.data(), nullptr);
+    ASSERT_EQ(any.type(), entt::type_id<fat>());
     ASSERT_EQ(other.type(), entt::type_id<fat>());
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
     ASSERT_EQ(entt::any_cast<fat>(other), instance);
 }
 
-TEST(Any, NoSBODirectAssignment) {
+TEST_F(Any, NoSBODirectAssignment) {
     fat instance{.1, .2, .3, .4};
     entt::any any{};
     any = instance;
@@ -336,7 +373,7 @@ TEST(Any, NoSBODirectAssignment) {
     ASSERT_EQ(entt::any_cast<fat>(any), instance);
 }
 
-TEST(Any, VoidInPlaceTypeConstruction) {
+TEST_F(Any, VoidInPlaceTypeConstruction) {
     entt::any any{std::in_place_type<void>};
 
     ASSERT_FALSE(any);
@@ -344,7 +381,7 @@ TEST(Any, VoidInPlaceTypeConstruction) {
     ASSERT_EQ(entt::any_cast<int>(&any), nullptr);
 }
 
-TEST(Any, VoidCopyConstruction) {
+TEST_F(Any, VoidCopyConstruction) {
     entt::any any{std::in_place_type<void>};
     entt::any other{any};
 
@@ -356,9 +393,9 @@ TEST(Any, VoidCopyConstruction) {
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
 }
 
-TEST(Any, VoidCopyAssignment) {
+TEST_F(Any, VoidCopyAssignment) {
     entt::any any{std::in_place_type<void>};
-    entt::any other{std::in_place_type<void>};
+    entt::any other{42};
 
     other = any;
 
@@ -370,7 +407,7 @@ TEST(Any, VoidCopyAssignment) {
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
 }
 
-TEST(Any, VoidMoveConstruction) {
+TEST_F(Any, VoidMoveConstruction) {
     entt::any any{std::in_place_type<void>};
     entt::any other{std::move(any)};
 
@@ -382,9 +419,9 @@ TEST(Any, VoidMoveConstruction) {
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
 }
 
-TEST(Any, VoidMoveAssignment) {
+TEST_F(Any, VoidMoveAssignment) {
     entt::any any{std::in_place_type<void>};
-    entt::any other{std::in_place_type<void>};
+    entt::any other{42};
 
     other = std::move(any);
 
@@ -396,17 +433,17 @@ TEST(Any, VoidMoveAssignment) {
     ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
 }
 
-TEST(Any, SBOMoveInvalidate) {
+TEST_F(Any, SBOMoveValidButUnspecifiedState) {
     entt::any any{42};
     entt::any other{std::move(any)};
     entt::any valid = std::move(other);
 
-    ASSERT_FALSE(any);
-    ASSERT_FALSE(other);
+    ASSERT_TRUE(any);
+    ASSERT_TRUE(other);
     ASSERT_TRUE(valid);
 }
 
-TEST(Any, NoSBOMoveInvalidate) {
+TEST_F(Any, NoSBOMoveValidButUnspecifiedState) {
     fat instance{.1, .2, .3, .4};
     entt::any any{instance};
     entt::any other{std::move(any)};
@@ -417,7 +454,7 @@ TEST(Any, NoSBOMoveInvalidate) {
     ASSERT_TRUE(valid);
 }
 
-TEST(Any, VoidMoveInvalidate) {
+TEST_F(Any, VoidMoveValidButUnspecifiedState) {
     entt::any any{std::in_place_type<void>};
     entt::any other{std::move(any)};
     entt::any valid = std::move(other);
@@ -427,30 +464,36 @@ TEST(Any, VoidMoveInvalidate) {
     ASSERT_FALSE(valid);
 }
 
-TEST(Any, SBODestruction) {
+TEST_F(Any, SBODestruction) {
     {
-        entt::any any{empty{}};
-        empty::counter = 0;
+        entt::any any{std::in_place_type<empty>};
+        any.emplace<empty>();
+        any = empty{};
+        entt::any other{std::move(any)};
+        any = std::move(other);
     }
 
-    ASSERT_EQ(empty::counter, 1);
+    ASSERT_EQ(empty::counter, 6);
 }
 
-TEST(Any, NoSBODestruction) {
+TEST_F(Any, NoSBODestruction) {
     {
-        entt::any any{fat{1., 2., 3., 4.}};
-        fat::counter = 0;
+        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 other{std::move(any)};
+        any = std::move(other);
     }
 
-    ASSERT_EQ(fat::counter, 1);
+    ASSERT_EQ(fat::counter, 4);
 }
 
-TEST(Any, VoidDestruction) {
+TEST_F(Any, VoidDestruction) {
     // just let asan tell us if everything is ok here
     [[maybe_unused]] entt::any any{std::in_place_type<void>};
 }
 
-TEST(Any, Emplace) {
+TEST_F(Any, Emplace) {
     entt::any any{};
     any.emplace<int>(42);
 
@@ -460,7 +503,7 @@ TEST(Any, Emplace) {
     ASSERT_EQ(entt::any_cast<int>(any), 42);
 }
 
-TEST(Any, EmplaceVoid) {
+TEST_F(Any, EmplaceVoid) {
     entt::any any{};
     any.emplace<void>();
 
@@ -468,7 +511,7 @@ TEST(Any, EmplaceVoid) {
     ASSERT_FALSE(any.type());
  }
 
-TEST(Any, Reset) {
+TEST_F(Any, Reset) {
     entt::any any{42};
 
     ASSERT_TRUE(any);
@@ -480,7 +523,7 @@ TEST(Any, Reset) {
     ASSERT_EQ(any.type(), entt::type_info{});
 }
 
-TEST(Any, SBOSwap) {
+TEST_F(Any, SBOSwap) {
     entt::any lhs{'c'};
     entt::any rhs{42};
 
@@ -494,7 +537,7 @@ TEST(Any, SBOSwap) {
     ASSERT_EQ(entt::any_cast<char>(rhs), 'c');
 }
 
-TEST(Any, NoSBOSwap) {
+TEST_F(Any, NoSBOSwap) {
     entt::any lhs{fat{.1, .2, .3, .4}};
     entt::any rhs{fat{.4, .3, .2, .1}};
 
@@ -504,7 +547,7 @@ TEST(Any, NoSBOSwap) {
     ASSERT_EQ(entt::any_cast<fat>(rhs), (fat{.1, .2, .3, .4}));
 }
 
-TEST(Any, VoidSwap) {
+TEST_F(Any, VoidSwap) {
     entt::any lhs{std::in_place_type<void>};
     entt::any rhs{std::in_place_type<void>};
     const auto *pre = lhs.data();
@@ -514,7 +557,7 @@ TEST(Any, VoidSwap) {
     ASSERT_EQ(pre, lhs.data());
 }
 
-TEST(Any, SBOWithNoSBOSwap) {
+TEST_F(Any, SBOWithNoSBOSwap) {
     entt::any lhs{fat{.1, .2, .3, .4}};
     entt::any rhs{'c'};
 
@@ -528,7 +571,7 @@ TEST(Any, SBOWithNoSBOSwap) {
     ASSERT_EQ(entt::any_cast<fat>(rhs), (fat{.1, .2, .3, .4}));
 }
 
-TEST(Any, SBOWithRefSwap) {
+TEST_F(Any, SBOWithRefSwap) {
     int value = 3;
     entt::any lhs{std::ref(value)};
     entt::any rhs{'c'};
@@ -544,7 +587,7 @@ TEST(Any, SBOWithRefSwap) {
     ASSERT_EQ(rhs.data(), &value);
 }
 
-TEST(Any, SBOWithConstRefSwap) {
+TEST_F(Any, SBOWithConstRefSwap) {
     int value = 3;
     entt::any lhs{std::cref(value)};
     entt::any rhs{'c'};
@@ -561,7 +604,7 @@ TEST(Any, SBOWithConstRefSwap) {
     ASSERT_EQ(std::as_const(rhs).data(), &value);
 }
 
-TEST(Any, SBOWithEmptySwap) {
+TEST_F(Any, SBOWithEmptySwap) {
     entt::any lhs{'c'};
     entt::any rhs{};
 
@@ -582,7 +625,7 @@ TEST(Any, SBOWithEmptySwap) {
     ASSERT_EQ(entt::any_cast<char>(lhs), 'c');
 }
 
-TEST(Any, SBOWithVoidSwap) {
+TEST_F(Any, SBOWithVoidSwap) {
     entt::any lhs{'c'};
     entt::any rhs{std::in_place_type<void>};
 
@@ -603,7 +646,7 @@ TEST(Any, SBOWithVoidSwap) {
     ASSERT_EQ(entt::any_cast<char>(lhs), 'c');
 }
 
-TEST(Any, NoSBOWithRefSwap) {
+TEST_F(Any, NoSBOWithRefSwap) {
     int value = 3;
     entt::any lhs{std::ref(value)};
     entt::any rhs{fat{.1, .2, .3, .4}};
@@ -619,7 +662,7 @@ TEST(Any, NoSBOWithRefSwap) {
     ASSERT_EQ(rhs.data(), &value);
 }
 
-TEST(Any, NoSBOWithConstRefSwap) {
+TEST_F(Any, NoSBOWithConstRefSwap) {
     int value = 3;
     entt::any lhs{std::cref(value)};
     entt::any rhs{fat{.1, .2, .3, .4}};
@@ -636,7 +679,7 @@ TEST(Any, NoSBOWithConstRefSwap) {
     ASSERT_EQ(std::as_const(rhs).data(), &value);
 }
 
-TEST(Any, NoSBOWithEmptySwap) {
+TEST_F(Any, NoSBOWithEmptySwap) {
     entt::any lhs{fat{.1, .2, .3, .4}};
     entt::any rhs{};
 
@@ -657,7 +700,7 @@ TEST(Any, NoSBOWithEmptySwap) {
     ASSERT_EQ(entt::any_cast<fat>(lhs), (fat{.1, .2, .3, .4}));
 }
 
-TEST(Any, NoSBOWithVoidSwap) {
+TEST_F(Any, NoSBOWithVoidSwap) {
     entt::any lhs{fat{.1, .2, .3, .4}};
     entt::any rhs{std::in_place_type<void>};
 
@@ -678,7 +721,7 @@ TEST(Any, NoSBOWithVoidSwap) {
     ASSERT_EQ(entt::any_cast<fat>(lhs), (fat{.1, .2, .3, .4}));
 }
 
-TEST(Any, AsRef) {
+TEST_F(Any, AsRef) {
     entt::any any{42};
     auto ref = any.as_ref();
     auto cref = std::as_const(any).as_ref();
@@ -744,7 +787,7 @@ TEST(Any, AsRef) {
     ASSERT_NE(entt::any_cast<int>(&cref), any.data());
 }
 
-TEST(Any, Comparable) {
+TEST_F(Any, Comparable) {
     auto test = [](entt::any any, entt::any other) {
         ASSERT_EQ(any, any);
         ASSERT_NE(other, any);
@@ -764,7 +807,7 @@ TEST(Any, Comparable) {
     test(3, std::cref(value));
 }
 
-TEST(Any, NotComparable) {
+TEST_F(Any, NotComparable) {
     auto test = [](const auto &instance) {
         entt::any any{std::cref(instance)};
 
@@ -782,7 +825,7 @@ TEST(Any, NotComparable) {
     test(std::vector<not_comparable>{});
 }
 
-TEST(Any, CompareVoid) {
+TEST_F(Any, CompareVoid) {
     entt::any any{std::in_place_type<void>};
 
     ASSERT_EQ(any, any);
@@ -797,7 +840,7 @@ TEST(Any, CompareVoid) {
     ASSERT_FALSE(entt::any{} != any);
 }
 
-TEST(Any, AnyCast) {
+TEST_F(Any, AnyCast) {
     entt::any any{42};
     const auto &cany = any;
 
@@ -813,7 +856,7 @@ TEST(Any, AnyCast) {
     ASSERT_DEATH(entt::any_cast<double>(entt::any{42}), "");
 }
 
-TEST(Any, NotCopyableType) {
+TEST_F(Any, NotCopyableType) {
     auto test = [](entt::any any) {
         entt::any copy{any};
 
@@ -830,7 +873,7 @@ TEST(Any, NotCopyableType) {
     test(entt::any{std::in_place_type<not_copyable<4>>});
 }
 
-TEST(Any, Array) {
+TEST_F(Any, Array) {
     entt::any any{std::in_place_type<int[1]>};
     entt::any copy{any};
 
@@ -847,7 +890,7 @@ TEST(Any, Array) {
     ASSERT_EQ(entt::any_cast<const int(&)[1]>(std::as_const(any))[0], 42);
 }
 
-TEST(Any, CopyMoveReference) {
+TEST_F(Any, CopyMoveReference) {
     int value{};
 
     auto test = [&](auto ref) {
@@ -857,7 +900,7 @@ TEST(Any, CopyMoveReference) {
         entt::any move = std::move(any);
         entt::any copy = move;
 
-        ASSERT_FALSE(any);
+        ASSERT_TRUE(any);
         ASSERT_TRUE(move);
         ASSERT_TRUE(copy);
 
@@ -880,7 +923,7 @@ TEST(Any, CopyMoveReference) {
     test(std::cref(value));
 }
 
-TEST(Any, SBOVsZeroedSBOSize) {
+TEST_F(Any, SBOVsZeroedSBOSize) {
     entt::any sbo{42};
     const auto *broken = sbo.data();
     entt::any other = std::move(sbo);
@@ -894,7 +937,7 @@ TEST(Any, SBOVsZeroedSBOSize) {
     ASSERT_EQ(valid, same.data());
 }
 
-TEST(Any, Alignment) {
+TEST_F(Any, Alignment) {
     static constexpr auto alignment = alignof(over_aligned);
 
     auto test = [](auto *target, auto cb) {
@@ -918,7 +961,7 @@ TEST(Any, Alignment) {
     test(sbo, [](auto *pre, auto *post) { ASSERT_NE(pre, post); });
 }
 
-TEST(Any, AggregatesMustWork) {
+TEST_F(Any, AggregatesMustWork) {
     struct aggregate_type { int value; };
     // the goal of this test is to enforce the requirements for aggregate types
     entt::any{std::in_place_type<aggregate_type>, 42}.emplace<aggregate_type>(42);