test: meta, minor changes

test/CMakeLists.txt

@@ -178,7 +178,6 @@ SETUP_BASIC_TEST(locator entt/locator/locator.cpp)
 # Test meta
 
 SETUP_BASIC_TEST(meta_any entt/meta/meta_any.cpp)
-SETUP_BASIC_TEST(meta_aob entt/meta/meta_aob.cpp)
 SETUP_BASIC_TEST(meta_base entt/meta/meta_base.cpp)
 SETUP_BASIC_TEST(meta_conv entt/meta/meta_conv.cpp)
 SETUP_BASIC_TEST(meta_ctor entt/meta/meta_ctor.cpp)

test/entt/meta/meta_any.cpp

@@ -40,7 +40,7 @@ struct unmanageable_t {
     unmanageable_t & operator=(unmanageable_t &&) = delete;
 };
 
-struct Meta: ::testing::Test {
+struct MetaAny: ::testing::Test {
     static void SetUpTestCase() {
         entt::meta<double>().conv<int>();
         entt::meta<empty_t>().dtor<&empty_t::destroy>();
@@ -52,7 +52,7 @@ struct Meta: ::testing::Test {
     }
 };
 
-TEST_F(Meta, MetaAnySBO) {
+TEST_F(MetaAny, SBO) {
     entt::meta_any any{'c'};
 
     ASSERT_TRUE(any);
@@ -63,7 +63,7 @@ TEST_F(Meta, MetaAnySBO) {
     ASSERT_NE(entt::meta_any{'h'}, any);
 }
 
-TEST_F(Meta, MetaAnyNoSBO) {
+TEST_F(MetaAny, NoSBO) {
     int value = 42;
     fat_t instance{&value};
     entt::meta_any any{instance};
@@ -76,7 +76,7 @@ TEST_F(Meta, MetaAnyNoSBO) {
     ASSERT_NE(fat_t{}, any);
 }
 
-TEST_F(Meta, MetaAnyEmpty) {
+TEST_F(MetaAny, Empty) {
     entt::meta_any any{};
 
     ASSERT_FALSE(any);
@@ -87,7 +87,7 @@ TEST_F(Meta, MetaAnyEmpty) {
     ASSERT_NE(entt::meta_any{'c'}, any);
 }
 
-TEST_F(Meta, MetaAnySBOInPlaceTypeConstruction) {
+TEST_F(MetaAny, SBOInPlaceTypeConstruction) {
     entt::meta_any any{std::in_place_type<int>, 42};
 
     ASSERT_TRUE(any);
@@ -99,7 +99,7 @@ TEST_F(Meta, MetaAnySBOInPlaceTypeConstruction) {
     ASSERT_NE(entt::meta_any{3}, any);
 }
 
-TEST_F(Meta, MetaAnySBOAsAliasConstruction) {
+TEST_F(MetaAny, SBOAsAliasConstruction) {
     int value = 3;
     int other = 42;
     entt::meta_any any{std::ref(value)};
@@ -114,7 +114,7 @@ TEST_F(Meta, MetaAnySBOAsAliasConstruction) {
     ASSERT_EQ(entt::meta_any{3}, any);
 }
 
-TEST_F(Meta, MetaAnySBOCopyConstruction) {
+TEST_F(MetaAny, SBOCopyConstruction) {
     entt::meta_any any{42};
     entt::meta_any other{any};
 
@@ -126,7 +126,7 @@ TEST_F(Meta, MetaAnySBOCopyConstruction) {
     ASSERT_NE(other, entt::meta_any{0});
 }
 
-TEST_F(Meta, MetaAnySBOCopyAssignment) {
+TEST_F(MetaAny, SBOCopyAssignment) {
     entt::meta_any any{42};
     entt::meta_any other{3};
 
@@ -140,7 +140,7 @@ TEST_F(Meta, MetaAnySBOCopyAssignment) {
     ASSERT_NE(other, entt::meta_any{0});
 }
 
-TEST_F(Meta, MetaAnySBOMoveConstruction) {
+TEST_F(MetaAny, SBOMoveConstruction) {
     entt::meta_any any{42};
     entt::meta_any other{std::move(any)};
 
@@ -152,7 +152,7 @@ TEST_F(Meta, MetaAnySBOMoveConstruction) {
     ASSERT_NE(other, entt::meta_any{0});
 }
 
-TEST_F(Meta, MetaAnySBOMoveAssignment) {
+TEST_F(MetaAny, SBOMoveAssignment) {
     entt::meta_any any{42};
     entt::meta_any other{3};
 
@@ -166,7 +166,7 @@ TEST_F(Meta, MetaAnySBOMoveAssignment) {
     ASSERT_NE(other, entt::meta_any{0});
 }
 
-TEST_F(Meta, MetaAnySBODirectAssignment) {
+TEST_F(MetaAny, SBODirectAssignment) {
     entt::meta_any any{};
     any = 42;
 
@@ -176,7 +176,7 @@ TEST_F(Meta, MetaAnySBODirectAssignment) {
     ASSERT_NE(entt::meta_any{0}, any);
 }
 
-TEST_F(Meta, MetaAnyNoSBOInPlaceTypeConstruction) {
+TEST_F(MetaAny, NoSBOInPlaceTypeConstruction) {
     int value = 42;
     fat_t instance{&value};
     entt::meta_any any{std::in_place_type<fat_t>, instance};
@@ -190,7 +190,7 @@ TEST_F(Meta, MetaAnyNoSBOInPlaceTypeConstruction) {
     ASSERT_NE(entt::meta_any{fat_t{}}, any);
 }
 
-TEST_F(Meta, MetaAnyNoSBOAsAliasConstruction) {
+TEST_F(MetaAny, NoSBOAsAliasConstruction) {
     int value = 3;
     fat_t instance{&value};
     entt::meta_any any{std::ref(instance)};
@@ -204,7 +204,7 @@ TEST_F(Meta, MetaAnyNoSBOAsAliasConstruction) {
     ASSERT_NE(entt::meta_any{fat_t{}}, any);
 }
 
-TEST_F(Meta, MetaAnyNoSBOCopyConstruction) {
+TEST_F(MetaAny, NoSBOCopyConstruction) {
     int value = 42;
     fat_t instance{&value};
     entt::meta_any any{instance};
@@ -218,7 +218,7 @@ TEST_F(Meta, MetaAnyNoSBOCopyConstruction) {
     ASSERT_NE(other, fat_t{});
 }
 
-TEST_F(Meta, MetaAnyNoSBOCopyAssignment) {
+TEST_F(MetaAny, NoSBOCopyAssignment) {
     int value = 42;
     fat_t instance{&value};
     entt::meta_any any{instance};
@@ -234,7 +234,7 @@ TEST_F(Meta, MetaAnyNoSBOCopyAssignment) {
     ASSERT_NE(other, fat_t{});
 }
 
-TEST_F(Meta, MetaAnyNoSBOMoveConstruction) {
+TEST_F(MetaAny, NoSBOMoveConstruction) {
     int value = 42;
     fat_t instance{&value};
     entt::meta_any any{instance};
@@ -248,7 +248,7 @@ TEST_F(Meta, MetaAnyNoSBOMoveConstruction) {
     ASSERT_NE(other, fat_t{});
 }
 
-TEST_F(Meta, MetaAnyNoSBOMoveAssignment) {
+TEST_F(MetaAny, NoSBOMoveAssignment) {
     int value = 42;
     fat_t instance{&value};
     entt::meta_any any{instance};
@@ -264,7 +264,7 @@ TEST_F(Meta, MetaAnyNoSBOMoveAssignment) {
     ASSERT_NE(other, fat_t{});
 }
 
-TEST_F(Meta, MetaAnyNoSBODirectAssignment) {
+TEST_F(MetaAny, NoSBODirectAssignment) {
     int value = 42;
     entt::meta_any any{};
     any = fat_t{&value};
@@ -275,7 +275,7 @@ TEST_F(Meta, MetaAnyNoSBODirectAssignment) {
     ASSERT_NE(fat_t{}, any);
 }
 
-TEST_F(Meta, MetaAnyVoidInPlaceTypeConstruction) {
+TEST_F(MetaAny, VoidInPlaceTypeConstruction) {
     entt::meta_any any{std::in_place_type<void>};
 
     ASSERT_TRUE(any);
@@ -286,7 +286,7 @@ TEST_F(Meta, MetaAnyVoidInPlaceTypeConstruction) {
     ASSERT_NE(entt::meta_any{3}, any);
 }
 
-TEST_F(Meta, MetaAnyVoidCopyConstruction) {
+TEST_F(MetaAny, VoidCopyConstruction) {
     entt::meta_any any{std::in_place_type<void>};
     entt::meta_any other{any};
 
@@ -296,7 +296,7 @@ TEST_F(Meta, MetaAnyVoidCopyConstruction) {
     ASSERT_EQ(other, entt::meta_any{std::in_place_type<void>});
 }
 
-TEST_F(Meta, MetaAnyVoidCopyAssignment) {
+TEST_F(MetaAny, VoidCopyAssignment) {
     entt::meta_any any{std::in_place_type<void>};
     entt::meta_any other{std::in_place_type<void>};
 
@@ -308,7 +308,7 @@ TEST_F(Meta, MetaAnyVoidCopyAssignment) {
     ASSERT_EQ(other, entt::meta_any{std::in_place_type<void>});
 }
 
-TEST_F(Meta, MetaAnyVoidMoveConstruction) {
+TEST_F(MetaAny, VoidMoveConstruction) {
     entt::meta_any any{std::in_place_type<void>};
     entt::meta_any other{std::move(any)};
 
@@ -318,7 +318,7 @@ TEST_F(Meta, MetaAnyVoidMoveConstruction) {
     ASSERT_EQ(other, entt::meta_any{std::in_place_type<void>});
 }
 
-TEST_F(Meta, MetaAnyVoidMoveAssignment) {
+TEST_F(MetaAny, VoidMoveAssignment) {
     entt::meta_any any{std::in_place_type<void>};
     entt::meta_any other{std::in_place_type<void>};
 
@@ -330,7 +330,7 @@ TEST_F(Meta, MetaAnyVoidMoveAssignment) {
     ASSERT_EQ(other, entt::meta_any{std::in_place_type<void>});
 }
 
-TEST_F(Meta, MetaAnySBOMoveInvalidate) {
+TEST_F(MetaAny, SBOMoveInvalidate) {
     entt::meta_any any{42};
     entt::meta_any other{std::move(any)};
     entt::meta_any valid = std::move(other);
@@ -340,7 +340,7 @@ TEST_F(Meta, MetaAnySBOMoveInvalidate) {
     ASSERT_TRUE(valid);
 }
 
-TEST_F(Meta, MetaAnyNoSBOMoveInvalidate) {
+TEST_F(MetaAny, NoSBOMoveInvalidate) {
     int value = 42;
     fat_t instance{&value};
     entt::meta_any any{instance};
@@ -352,7 +352,7 @@ TEST_F(Meta, MetaAnyNoSBOMoveInvalidate) {
     ASSERT_TRUE(valid);
 }
 
-TEST_F(Meta, MetaAnyVoidMoveInvalidate) {
+TEST_F(MetaAny, VoidMoveInvalidate) {
     entt::meta_any any{std::in_place_type<void>};
     entt::meta_any other{std::move(any)};
     entt::meta_any valid = std::move(other);
@@ -362,24 +362,24 @@ TEST_F(Meta, MetaAnyVoidMoveInvalidate) {
     ASSERT_TRUE(valid);
 }
 
-TEST_F(Meta, MetaAnySBODestruction) {
+TEST_F(MetaAny, SBODestruction) {
     ASSERT_EQ(empty_t::counter, 0);
     { entt::meta_any any{empty_t{}}; }
     ASSERT_EQ(empty_t::counter, 1);
 }
 
-TEST_F(Meta, MetaAnyNoSBODestruction) {
+TEST_F(MetaAny, NoSBODestruction) {
     ASSERT_EQ(fat_t::counter, 0);
     { entt::meta_any any{fat_t{}}; }
     ASSERT_EQ(fat_t::counter, 1);
 }
 
-TEST_F(Meta, MetaAnyVoidDestruction) {
+TEST_F(MetaAny, VoidDestruction) {
     // just let asan tell us if everything is ok here
     [[maybe_unused]] entt::meta_any any{std::in_place_type<void>};
 }
 
-TEST_F(Meta, MetaAnyEmplace) {
+TEST_F(MetaAny, Emplace) {
     entt::meta_any any{};
     any.emplace<int>(42);
 
@@ -392,7 +392,7 @@ TEST_F(Meta, MetaAnyEmplace) {
     ASSERT_NE(entt::meta_any{3}, any);
 }
 
-TEST_F(Meta, MetaAnyEmplaceVoid) {
+TEST_F(MetaAny, EmplaceVoid) {
     entt::meta_any any{};
     any.emplace<void>();
 
@@ -402,7 +402,7 @@ TEST_F(Meta, MetaAnyEmplaceVoid) {
     ASSERT_EQ(any, (entt::meta_any{std::in_place_type<void>}));
 }
 
-TEST_F(Meta, MetaAnySBOSwap) {
+TEST_F(MetaAny, SBOSwap) {
     entt::meta_any lhs{'c'};
     entt::meta_any rhs{42};
 
@@ -414,7 +414,7 @@ TEST_F(Meta, MetaAnySBOSwap) {
     ASSERT_EQ(rhs.cast<char>(), 'c');
 }
 
-TEST_F(Meta, MetaAnyNoSBOSwap) {
+TEST_F(MetaAny, NoSBOSwap) {
     int i, j;
     entt::meta_any lhs{fat_t{&i}};
     entt::meta_any rhs{fat_t{&j}};
@@ -425,7 +425,7 @@ TEST_F(Meta, MetaAnyNoSBOSwap) {
     ASSERT_EQ(rhs.cast<fat_t>().bar, &i);
 }
 
-TEST_F(Meta, MetaAnyVoidSwap) {
+TEST_F(MetaAny, VoidSwap) {
     entt::meta_any lhs{std::in_place_type<void>};
     entt::meta_any rhs{std::in_place_type<void>};
     const auto *pre = lhs.data();
@@ -435,7 +435,7 @@ TEST_F(Meta, MetaAnyVoidSwap) {
     ASSERT_EQ(pre, lhs.data());
 }
 
-TEST_F(Meta, MetaAnySBOWithNoSBOSwap) {
+TEST_F(MetaAny, SBOWithNoSBOSwap) {
     int value = 42;
     entt::meta_any lhs{fat_t{&value}};
     entt::meta_any rhs{'c'};
@@ -449,7 +449,7 @@ TEST_F(Meta, MetaAnySBOWithNoSBOSwap) {
     ASSERT_EQ(rhs.cast<fat_t>().bar, &value);
 }
 
-TEST_F(Meta, MetaAnySBOWithEmptySwap) {
+TEST_F(MetaAny, SBOWithEmptySwap) {
     entt::meta_any lhs{'c'};
     entt::meta_any rhs{};
 
@@ -464,7 +464,7 @@ TEST_F(Meta, MetaAnySBOWithEmptySwap) {
     ASSERT_EQ(lhs.cast<char>(), 'c');
 }
 
-TEST_F(Meta, MetaAnySBOWithVoidSwap) {
+TEST_F(MetaAny, SBOWithVoidSwap) {
     entt::meta_any lhs{'c'};
     entt::meta_any rhs{std::in_place_type<void>};
 
@@ -474,7 +474,7 @@ TEST_F(Meta, MetaAnySBOWithVoidSwap) {
     ASSERT_EQ(rhs.cast<char>(), 'c');
 }
 
-TEST_F(Meta, MetaAnyNoSBOWithEmptySwap) {
+TEST_F(MetaAny, NoSBOWithEmptySwap) {
     int i;
     entt::meta_any lhs{fat_t{&i}};
     entt::meta_any rhs{};
@@ -488,7 +488,7 @@ TEST_F(Meta, MetaAnyNoSBOWithEmptySwap) {
     ASSERT_EQ(lhs.cast<fat_t>().bar, &i);
 }
 
-TEST_F(Meta, MetaAnyNoSBOWithVoidSwap) {
+TEST_F(MetaAny, NoSBOWithVoidSwap) {
     int i;
     entt::meta_any lhs{fat_t{&i}};
     entt::meta_any rhs{std::in_place_type<void>};
@@ -502,7 +502,7 @@ TEST_F(Meta, MetaAnyNoSBOWithVoidSwap) {
     ASSERT_EQ(lhs.cast<fat_t>().bar, &i);
 }
 
-TEST_F(Meta, MetaAnyComparable) {
+TEST_F(MetaAny, Comparable) {
     entt::meta_any any{'c'};
 
     ASSERT_EQ(any, any);
@@ -517,7 +517,7 @@ TEST_F(Meta, MetaAnyComparable) {
     ASSERT_TRUE(entt::meta_any{} != any);
 }
 
-TEST_F(Meta, MetaAnyNotComparable) {
+TEST_F(MetaAny, NotComparable) {
     entt::meta_any any{not_comparable_t{}};
 
     ASSERT_EQ(any, any);
@@ -529,7 +529,7 @@ TEST_F(Meta, MetaAnyNotComparable) {
     ASSERT_TRUE(entt::meta_any{} != any);
 }
 
-TEST_F(Meta, MetaAnyCompareVoid) {
+TEST_F(MetaAny, CompareVoid) {
     entt::meta_any any{std::in_place_type<void>};
 
     ASSERT_EQ(any, any);
@@ -544,7 +544,7 @@ TEST_F(Meta, MetaAnyCompareVoid) {
     ASSERT_TRUE(entt::meta_any{} != any);
 }
 
-TEST_F(Meta, MetaAnyTryCast) {
+TEST_F(MetaAny, TryCast) {
     entt::meta_any any{fat_t{}};
 
     ASSERT_TRUE(any);
@@ -556,7 +556,7 @@ TEST_F(Meta, MetaAnyTryCast) {
     ASSERT_EQ(std::as_const(any).try_cast<fat_t>(), any.data());
 }
 
-TEST_F(Meta, MetaAnyCast) {
+TEST_F(MetaAny, Cast) {
     entt::meta_any any{fat_t{}};
 
     ASSERT_TRUE(any);
@@ -568,7 +568,7 @@ TEST_F(Meta, MetaAnyCast) {
     ASSERT_EQ(std::as_const(any).try_cast<fat_t>(), any.data());
 }
 
-TEST_F(Meta, MetaAnyConvert) {
+TEST_F(MetaAny, Convert) {
     entt::meta_any any{42.};
 
     ASSERT_TRUE(any);
@@ -582,7 +582,7 @@ TEST_F(Meta, MetaAnyConvert) {
     ASSERT_EQ(any.cast<int>(), 42);
 }
 
-TEST_F(Meta, MetaAnyConstConvert) {
+TEST_F(MetaAny, ConstConvert) {
     const entt::meta_any any{42.};
 
     ASSERT_TRUE(any);
@@ -600,7 +600,7 @@ TEST_F(Meta, MetaAnyConstConvert) {
     ASSERT_EQ(other.cast<int>(), 42);
 }
 
-TEST_F(Meta, MetaAnyUnmanageableType) {
+TEST_F(MetaAny, UnmanageableType) {
     unmanageable_t instance;
     entt::meta_any any{std::ref(instance)};
     entt::meta_any other = any;

test/entt/meta/meta_aob.cpp

@@ -1,27 +0,0 @@
-#include <gtest/gtest.h>
-#include <entt/core/hashed_string.hpp>
-#include <entt/meta/factory.hpp>
-#include <entt/meta/meta.hpp>
-#include <entt/meta/resolve.hpp>
-
-struct Meta: ::testing::Test {
-    static void SetUpTestCase() {
-        entt::meta<char>().type("char"_hs);
-        entt::meta<double>().type("double"_hs);
-    }
-};
-
-TEST_F(Meta, Resolve) {
-    ASSERT_EQ(entt::resolve<double>(), entt::resolve_id("double"_hs));
-    ASSERT_EQ(entt::resolve<double>(), entt::resolve_type(entt::type_info<double>::id()));
-    // it could be "char"_hs rather than entt::hashed_string::value("char") if it weren't for a bug in VS2017
-    ASSERT_EQ(entt::resolve_if([](auto type) { return type.id() == entt::hashed_string::value("char"); }), entt::resolve<char>());
-
-    bool found = false;
-
-    entt::resolve([&found](auto type) {
-        found = found || type == entt::resolve<double>();
-    });
-
-    ASSERT_TRUE(found);
-}

test/entt/meta/meta_base.cpp

@@ -7,14 +7,14 @@
 struct base_t {};
 struct derived_t: base_t {};
 
-struct Meta: ::testing::Test {
+struct MetaBase: ::testing::Test {
     static void SetUpTestCase() {
         entt::meta<base_t>().type("base"_hs);
         entt::meta<derived_t>().type("derived"_hs).base<base_t>();
     }
 };
 
-TEST_F(Meta, MetaBase) {
+TEST_F(MetaBase, Functionalities) {
     auto base = entt::resolve<derived_t>().base("base"_hs);
     derived_t derived{};
 

test/entt/meta/meta_conv.cpp

@@ -17,14 +17,14 @@ struct clazz_t {
     char c{};
 };
 
-struct Meta: ::testing::Test {
+struct MetaConv: ::testing::Test {
     static void SetUpTestCase() {
         entt::meta<double>().conv<int>();
         entt::meta<clazz_t>().conv<&clazz_t::f>().conv<&clazz_t::g>();
     }
 };
 
-TEST_F(Meta, MetaConv) {
+TEST_F(MetaConv, Functionalities) {
     auto conv = entt::resolve<double>().conv<int>();
     double value = 3.;
 
@@ -39,7 +39,7 @@ TEST_F(Meta, MetaConv) {
     ASSERT_EQ(any.cast<int>(), 3);
 }
 
-TEST_F(Meta, MetaConvAsFreeFunctions) {
+TEST_F(MetaConv, AsFreeFunctions) {
     auto conv = entt::resolve<clazz_t>().conv<int>();
     clazz_t clazz{42, 'c'};
 
@@ -54,7 +54,7 @@ TEST_F(Meta, MetaConvAsFreeFunctions) {
     ASSERT_EQ(any.cast<int>(), 42);
 }
 
-TEST_F(Meta, MetaConvAsMemberFunctions) {
+TEST_F(MetaConv, AsMemberFunctions) {
     auto conv = entt::resolve<clazz_t>().conv<char>();
     clazz_t clazz{42, 'c'};
 

test/entt/meta/meta_ctor.cpp

@@ -29,7 +29,7 @@ struct clazz_t {
     char c{};
 };
 
-struct Meta: ::testing::Test {
+struct MetaCtor: ::testing::Test {
     static void SetUpTestCase() {
         entt::meta<double>().conv<int>();
         entt::meta<derived_t>().base<base_t>();
@@ -42,7 +42,7 @@ struct Meta: ::testing::Test {
     }
 };
 
-TEST_F(Meta, MetaCtor) {
+TEST_F(MetaCtor, Functionalities) {
     auto ctor = entt::resolve<clazz_t>().ctor<const int &, char>();
 
     ASSERT_TRUE(ctor);
@@ -75,7 +75,7 @@ TEST_F(Meta, MetaCtor) {
     ASSERT_FALSE(prop.value().template cast<bool>());
 }
 
-TEST_F(Meta, MetaCtorFunc) {
+TEST_F(MetaCtor, Func) {
     auto ctor = entt::resolve<clazz_t>().ctor<int>();
 
     ASSERT_TRUE(ctor);
@@ -107,7 +107,7 @@ TEST_F(Meta, MetaCtorFunc) {
     ASSERT_EQ(prop.value(), 42);
 }
 
-TEST_F(Meta, MetaCtorMetaAnyArgs) {
+TEST_F(MetaCtor, MetaAnyArgs) {
     auto any = entt::resolve<clazz_t>().ctor<int, char>().invoke(entt::meta_any{42}, entt::meta_any{'c'});
 
     ASSERT_TRUE(any);
@@ -115,12 +115,12 @@ TEST_F(Meta, MetaCtorMetaAnyArgs) {
     ASSERT_EQ(any.cast<clazz_t>().c, 'c');
 }
 
-TEST_F(Meta, MetaCtorInvalidArgs) {
+TEST_F(MetaCtor, InvalidArgs) {
     auto ctor = entt::resolve<clazz_t>().ctor<int, char>();
     ASSERT_FALSE(ctor.invoke('c', 42));
 }
 
-TEST_F(Meta, MetaCtorCastAndConvert) {
+TEST_F(MetaCtor, CastAndConvert) {
     auto any = entt::resolve<clazz_t>().ctor<const base_t &, int>().invoke(derived_t{{'c'}}, 42.);
 
     ASSERT_TRUE(any);
@@ -128,7 +128,7 @@ TEST_F(Meta, MetaCtorCastAndConvert) {
     ASSERT_EQ(any.cast<clazz_t>().c, 'c');
 }
 
-TEST_F(Meta, MetaCtorFuncMetaAnyArgs) {
+TEST_F(MetaCtor, FuncMetaAnyArgs) {
     auto any = entt::resolve<clazz_t>().ctor<base_t, int>().invoke(entt::meta_any{base_t{'c'}}, entt::meta_any{42});
 
     ASSERT_TRUE(any);
@@ -136,12 +136,12 @@ TEST_F(Meta, MetaCtorFuncMetaAnyArgs) {
     ASSERT_EQ(any.cast<clazz_t>().c, 'c');
 }
 
-TEST_F(Meta, MetaCtorFuncInvalidArgs) {
+TEST_F(MetaCtor, FuncInvalidArgs) {
     auto ctor = entt::resolve<clazz_t>().ctor<const base_t &, int>();
     ASSERT_FALSE(ctor.invoke(base_t{}, 'c'));
 }
 
-TEST_F(Meta, MetaCtorFuncCastAndConvert) {
+TEST_F(MetaCtor, FuncCastAndConvert) {
     auto any = entt::resolve<clazz_t>().ctor<base_t, int, int>().invoke(derived_t{{'c'}}, 3., 3);
 
     ASSERT_TRUE(any);

test/entt/meta/meta_data.cpp

@@ -62,7 +62,7 @@ enum class property_t {
     value
 };
 
-struct Meta: ::testing::Test {
+struct MetaData: ::testing::Test {
     static void SetUpTestCase() {
         entt::meta<double>().conv<int>();
         entt::meta<base_t>().dtor<&base_t::destroy>().data<&base_t::value>("value"_hs);
@@ -96,7 +96,7 @@ struct Meta: ::testing::Test {
     }
 };
 
-TEST_F(Meta, MetaData) {
+TEST_F(MetaData, Functionalities) {
     auto data = entt::resolve<clazz_t>().data("i"_hs);
     clazz_t instance{};
 
@@ -125,7 +125,7 @@ TEST_F(Meta, MetaData) {
     ASSERT_EQ(prop.value(), 0);
 }
 
-TEST_F(Meta, MetaDataConst) {
+TEST_F(MetaData, Const) {
     auto data = entt::resolve<clazz_t>().data("j"_hs);
     clazz_t instance{};
 
@@ -154,7 +154,7 @@ TEST_F(Meta, MetaDataConst) {
     ASSERT_EQ(prop.value(), 1);
 }
 
-TEST_F(Meta, MetaDataStatic) {
+TEST_F(MetaData, Static) {
     auto data = entt::resolve<clazz_t>().data("h"_hs);
 
     ASSERT_TRUE(data);
@@ -182,7 +182,7 @@ TEST_F(Meta, MetaDataStatic) {
     ASSERT_EQ(prop.value(), 2);
 }
 
-TEST_F(Meta, MetaDataConstStatic) {
+TEST_F(MetaData, ConstStatic) {
     auto data = entt::resolve<clazz_t>().data("k"_hs);
 
     ASSERT_TRUE(data);
@@ -210,7 +210,7 @@ TEST_F(Meta, MetaDataConstStatic) {
     ASSERT_EQ(prop.value(), 3);
 }
 
-TEST_F(Meta, MetaDataGetMetaAnyArg) {
+TEST_F(MetaData, GetMetaAnyArg) {
     entt::meta_any any{clazz_t{}};
     any.cast<clazz_t>().i = 99;
     const auto value = entt::resolve<clazz_t>().data("i"_hs).get(any);
@@ -220,12 +220,12 @@ TEST_F(Meta, MetaDataGetMetaAnyArg) {
     ASSERT_EQ(value.cast<int>(), 99);
 }
 
-TEST_F(Meta, MetaDataGetInvalidArg) {
+TEST_F(MetaData, GetInvalidArg) {
     auto instance = 0;
     ASSERT_FALSE(entt::resolve<clazz_t>().data("i"_hs).get(instance));
 }
 
-TEST_F(Meta, MetaDataSetMetaAnyArg) {
+TEST_F(MetaData, SetMetaAnyArg) {
     entt::meta_any any{clazz_t{}};
     entt::meta_any value{42};
 
@@ -234,11 +234,11 @@ TEST_F(Meta, MetaDataSetMetaAnyArg) {
     ASSERT_EQ(any.cast<clazz_t>().i, 42);
 }
 
-TEST_F(Meta, MetaDataSetInvalidArg) {
+TEST_F(MetaData, SetInvalidArg) {
     ASSERT_FALSE(entt::resolve<clazz_t>().data("i"_hs).set({}, 'c'));
 }
 
-TEST_F(Meta, MetaDataSetCast) {
+TEST_F(MetaData, SetCast) {
     clazz_t instance{};
 
     ASSERT_EQ(base_t::counter, 0);
@@ -246,7 +246,7 @@ TEST_F(Meta, MetaDataSetCast) {
     ASSERT_EQ(base_t::counter, 1);
 }
 
-TEST_F(Meta, MetaDataSetConvert) {
+TEST_F(MetaData, SetConvert) {
     clazz_t instance{};
 
     ASSERT_EQ(instance.i, 0);
@@ -254,7 +254,7 @@ TEST_F(Meta, MetaDataSetConvert) {
     ASSERT_EQ(instance.i, 3);
 }
 
-TEST_F(Meta, MetaDataSetterGetterAsFreeFunctions) {
+TEST_F(MetaData, SetterGetterAsFreeFunctions) {
     auto data = entt::resolve<setter_getter_t>().data("x"_hs);
     setter_getter_t instance{};
 
@@ -269,7 +269,7 @@ TEST_F(Meta, MetaDataSetterGetterAsFreeFunctions) {
     ASSERT_EQ(data.get(instance).cast<int>(), 42);
 }
 
-TEST_F(Meta, MetaDataSetterGetterAsMemberFunctions) {
+TEST_F(MetaData, SetterGetterAsMemberFunctions) {
     auto data = entt::resolve<setter_getter_t>().data("y"_hs);
     setter_getter_t instance{};
 
@@ -284,7 +284,7 @@ TEST_F(Meta, MetaDataSetterGetterAsMemberFunctions) {
     ASSERT_EQ(data.get(instance).cast<int>(), 42);
 }
 
-TEST_F(Meta, MetaDataSetterGetterWithRefAsMemberFunctions) {
+TEST_F(MetaData, SetterGetterWithRefAsMemberFunctions) {
     auto data = entt::resolve<setter_getter_t>().data("w"_hs);
     setter_getter_t instance{};
 
@@ -299,7 +299,7 @@ TEST_F(Meta, MetaDataSetterGetterWithRefAsMemberFunctions) {
     ASSERT_EQ(data.get(instance).cast<int>(), 42);
 }
 
-TEST_F(Meta, MetaDataSetterGetterMixed) {
+TEST_F(MetaData, SetterGetterMixed) {
     auto data = entt::resolve<setter_getter_t>().data("z"_hs);
     setter_getter_t instance{};
 
@@ -314,7 +314,7 @@ TEST_F(Meta, MetaDataSetterGetterMixed) {
     ASSERT_EQ(data.get(instance).cast<int>(), 42);
 }
 
-TEST_F(Meta, MetaDataSetterGetterReadOnly) {
+TEST_F(MetaData, SetterGetterReadOnly) {
     auto data = entt::resolve<setter_getter_t>().data("z_ro"_hs);
     setter_getter_t instance{};
 
@@ -329,7 +329,7 @@ TEST_F(Meta, MetaDataSetterGetterReadOnly) {
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
 }
 
-TEST_F(Meta, MetaDataSetterGetterReadOnlyDataMember) {
+TEST_F(MetaData, SetterGetterReadOnlyDataMember) {
     auto data = entt::resolve<setter_getter_t>().data("value"_hs);
     setter_getter_t instance{};
 
@@ -344,7 +344,7 @@ TEST_F(Meta, MetaDataSetterGetterReadOnlyDataMember) {
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
 }
 
-TEST_F(Meta, MetaDataArrayStatic) {
+TEST_F(MetaData, ArrayStatic) {
     auto data = entt::resolve<array_t>().data("global"_hs);
 
     array_t::global[0] = 3;
@@ -372,7 +372,7 @@ TEST_F(Meta, MetaDataArrayStatic) {
     ASSERT_EQ(data.get({}, 2).cast<int>(), 9);
 }
 
-TEST_F(Meta, MetaDataArray) {
+TEST_F(MetaData, Array) {
     auto data = entt::resolve<array_t>().data("local"_hs);
     array_t instance;
 
@@ -401,7 +401,7 @@ TEST_F(Meta, MetaDataArray) {
     ASSERT_EQ(data.get(instance, 2).cast<int>(), 9);
 }
 
-TEST_F(Meta, MetaDataAsVoid) {
+TEST_F(MetaData, AsVoid) {
     auto data = entt::resolve<clazz_t>().data("void"_hs);
     clazz_t instance{};
 
@@ -410,7 +410,7 @@ TEST_F(Meta, MetaDataAsVoid) {
     ASSERT_EQ(data.get(instance), entt::meta_any{std::in_place_type<void>});
 }
 
-TEST_F(Meta, MetaDataAsRef) {
+TEST_F(MetaData, AsRef) {
     clazz_t instance{};
 
     auto h_data = entt::resolve<clazz_t>().data("h"_hs);
@@ -426,7 +426,7 @@ TEST_F(Meta, MetaDataAsRef) {
     ASSERT_EQ(instance.i, 3);
 }
 
-TEST_F(Meta, MetaDataFromBase) {
+TEST_F(MetaData, FromBase) {
     auto type = entt::resolve<derived_t>();
     derived_t instance;
 

test/entt/meta/meta_func.cpp

@@ -58,7 +58,7 @@ struct func_t {
     inline static int value = 0;
 };
 
-struct Meta: ::testing::Test {
+struct MetaFunc: ::testing::Test {
     static void SetUpTestCase() {
         entt::meta<double>().conv<int>();
         entt::meta<base_t>().dtor<&base_t::destroy>().func<&base_t::func>("func"_hs);
@@ -80,7 +80,7 @@ struct Meta: ::testing::Test {
     }
 };
 
-TEST_F(Meta, MetaFunc) {
+TEST_F(MetaFunc, Functionalities) {
     auto func = entt::resolve<func_t>().func("f2"_hs);
     func_t instance{};
 
@@ -119,7 +119,7 @@ TEST_F(Meta, MetaFunc) {
     ASSERT_FALSE(prop.value().cast<bool>());
 }
 
-TEST_F(Meta, MetaFuncConst) {
+TEST_F(MetaFunc, Const) {
     auto func = entt::resolve<func_t>().func("f1"_hs);
     func_t instance{};
 
@@ -156,7 +156,7 @@ TEST_F(Meta, MetaFuncConst) {
     ASSERT_FALSE(prop.value().cast<bool>());
 }
 
-TEST_F(Meta, MetaFuncRetVoid) {
+TEST_F(MetaFunc, RetVoid) {
     auto func = entt::resolve<func_t>().func("g"_hs);
     func_t instance{};
 
@@ -191,7 +191,7 @@ TEST_F(Meta, MetaFuncRetVoid) {
     ASSERT_FALSE(prop.value().cast<bool>());
 }
 
-TEST_F(Meta, MetaFuncStatic) {
+TEST_F(MetaFunc, Static) {
     auto func = entt::resolve<func_t>().func("h"_hs);
     func_t::value = 2;
 
@@ -228,7 +228,7 @@ TEST_F(Meta, MetaFuncStatic) {
     ASSERT_FALSE(prop.value().cast<bool>());
 }
 
-TEST_F(Meta, MetaFuncStaticRetVoid) {
+TEST_F(MetaFunc, StaticRetVoid) {
     auto func = entt::resolve<func_t>().func("k"_hs);
 
     ASSERT_TRUE(func);
@@ -263,7 +263,7 @@ TEST_F(Meta, MetaFuncStaticRetVoid) {
     ASSERT_FALSE(prop.value().cast<bool>());
 }
 
-TEST_F(Meta, MetaFuncMetaAnyArgs) {
+TEST_F(MetaFunc, MetaAnyArgs) {
     func_t instance;
     auto any = entt::resolve<func_t>().func("f1"_hs).invoke(instance, 3);
 
@@ -272,12 +272,12 @@ TEST_F(Meta, MetaFuncMetaAnyArgs) {
     ASSERT_EQ(any.cast<int>(), 9);
 }
 
-TEST_F(Meta, MetaFuncInvalidArgs) {
+TEST_F(MetaFunc, InvalidArgs) {
     int value = 3;
     ASSERT_FALSE(entt::resolve<func_t>().func("f1"_hs).invoke(value, 'c'));
 }
 
-TEST_F(Meta, MetaFuncCastAndConvert) {
+TEST_F(MetaFunc, CastAndConvert) {
     func_t instance;
     auto any = entt::resolve<func_t>().func("f3"_hs).invoke(instance, derived_t{}, 0, 3.);
 
@@ -286,7 +286,7 @@ TEST_F(Meta, MetaFuncCastAndConvert) {
     ASSERT_EQ(any.cast<int>(), 9);
 }
 
-TEST_F(Meta, MetaFuncAsVoid) {
+TEST_F(MetaFunc, AsVoid) {
     auto func = entt::resolve<func_t>().func("v"_hs);
     func_t instance{};
 
@@ -295,7 +295,7 @@ TEST_F(Meta, MetaFuncAsVoid) {
     ASSERT_EQ(instance.value, 42);
 }
 
-TEST_F(Meta, MetaFuncAsAlias) {
+TEST_F(MetaFunc, AsAlias) {
     func_t instance{};
     auto func = entt::resolve<func_t>().func("a"_hs);
     func.invoke(instance).cast<int>() = 3;
@@ -304,7 +304,7 @@ TEST_F(Meta, MetaFuncAsAlias) {
     ASSERT_EQ(instance.value, 3);
 }
 
-TEST_F(Meta, MetaFuncByReference) {
+TEST_F(MetaFunc, ByReference) {
     auto func = entt::resolve<func_t>().func("h"_hs);
     func_t::value = 2;
     entt::meta_any any{3};
@@ -316,7 +316,7 @@ TEST_F(Meta, MetaFuncByReference) {
     ASSERT_EQ(value, 8);
 }
 
-TEST_F(Meta, MetaFuncFromBase) {
+TEST_F(MetaFunc, FromBase) {
     auto type = entt::resolve<derived_t>();
     derived_t instance;
 

test/entt/meta/meta_prop.cpp

@@ -8,7 +8,7 @@ struct base_1_t {};
 struct base_2_t {};
 struct derived_t: base_1_t, base_2_t {};
 
-struct Meta: ::testing::Test {
+struct MetaProp: ::testing::Test {
     static void SetUpTestCase() {
         entt::meta<base_1_t>().prop("int"_hs, 42);
         entt::meta<base_2_t>().prop("bool"_hs, false);
@@ -16,7 +16,7 @@ struct Meta: ::testing::Test {
     }
 };
 
-TEST_F(Meta, MetaProp) {
+TEST_F(MetaProp, Functionalities) {
     auto prop = entt::resolve<base_1_t>().prop("int"_hs);
 
     ASSERT_TRUE(prop);
@@ -24,7 +24,7 @@ TEST_F(Meta, MetaProp) {
     ASSERT_EQ(prop.value(), 42);
 }
 
-TEST_F(Meta, MetaPropFromBase) {
+TEST_F(MetaProp, FromBase) {
     auto type = entt::resolve<derived_t>();
     auto prop_bool = type.prop("bool"_hs);
     auto prop_int = type.prop("int"_hs);

test/entt/meta/meta_type.cpp

@@ -55,7 +55,7 @@ union union_t {
     double d;
 };
 
-struct Meta: ::testing::Test {
+struct MetaType: ::testing::Test {
     static void SetUpTestCase() {
         entt::meta<double>().type("double"_hs).conv<int>().data<&set<double>, &get<double>>("var"_hs);
         entt::meta<unsigned int>().data<0u>("min"_hs).data<100u>("max"_hs);
@@ -87,7 +87,22 @@ struct Meta: ::testing::Test {
     }
 };
 
-TEST_F(Meta, MetaType) {
+TEST_F(MetaType, Resolve) {
+    ASSERT_EQ(entt::resolve<double>(), entt::resolve_id("double"_hs));
+    ASSERT_EQ(entt::resolve<double>(), entt::resolve_type(entt::type_info<double>::id()));
+    // it could be "char"_hs rather than entt::hashed_string::value("char") if it weren't for a bug in VS2017
+    ASSERT_EQ(entt::resolve_if([](auto type) { return type.id() == entt::hashed_string::value("clazz"); }), entt::resolve<clazz_t>());
+
+    bool found = false;
+
+    entt::resolve([&found](auto type) {
+        found = found || type == entt::resolve<double>();
+    });
+
+    ASSERT_TRUE(found);
+}
+
+TEST_F(MetaType, Functionalities) {
     auto type = entt::resolve<clazz_t>();
 
     ASSERT_TRUE(type);
@@ -110,7 +125,7 @@ TEST_F(Meta, MetaType) {
     ASSERT_EQ(prop.value(), 42);
 }
 
-TEST_F(Meta, MetaTypeTraits) {
+TEST_F(MetaType, Traits) {
     ASSERT_TRUE(entt::resolve<void>().is_void());
     ASSERT_TRUE(entt::resolve<bool>().is_integral());
     ASSERT_TRUE(entt::resolve<double>().is_floating_point());
@@ -123,19 +138,19 @@ TEST_F(Meta, MetaTypeTraits) {
     ASSERT_TRUE(entt::resolve<decltype(&clazz_t::member)>().is_member_function_pointer());
 }
 
-TEST_F(Meta, MetaTypeRemovePointer) {
+TEST_F(MetaType, RemovePointer) {
     ASSERT_EQ(entt::resolve<void *>().remove_pointer(), entt::resolve<void>());
     ASSERT_EQ(entt::resolve<int(*)(char, double)>().remove_pointer(), entt::resolve<int(char, double)>());
     ASSERT_EQ(entt::resolve<derived_t>().remove_pointer(), entt::resolve<derived_t>());
 }
 
-TEST_F(Meta, MetaTypeRemoveExtent) {
+TEST_F(MetaType, RemoveExtent) {
     ASSERT_EQ(entt::resolve<int[3]>().remove_extent(), entt::resolve<int>());
     ASSERT_EQ(entt::resolve<int[3][3]>().remove_extent(), entt::resolve<int[3]>());
     ASSERT_EQ(entt::resolve<derived_t>().remove_extent(), entt::resolve<derived_t>());
 }
 
-TEST_F(Meta, MetaTypeBase) {
+TEST_F(MetaType, Base) {
     auto type = entt::resolve<derived_t>();
     bool iterate = false;
 
@@ -148,7 +163,7 @@ TEST_F(Meta, MetaTypeBase) {
     ASSERT_EQ(type.base("base"_hs).type(), entt::resolve<base_t>());
 }
 
-TEST_F(Meta, MetaTypeConv) {
+TEST_F(MetaType, Conv) {
     auto type = entt::resolve<double>();
     bool iterate = false;
 
@@ -165,7 +180,7 @@ TEST_F(Meta, MetaTypeConv) {
     ASSERT_FALSE(type.conv<char>());
 }
 
-TEST_F(Meta, MetaTypeCtor) {
+TEST_F(MetaType, Ctor) {
     auto type = entt::resolve<clazz_t>();
     int counter{};
 
@@ -179,7 +194,7 @@ TEST_F(Meta, MetaTypeCtor) {
     ASSERT_TRUE((type.ctor<const derived_t &, double>()));
 }
 
-TEST_F(Meta, MetaTypeData) {
+TEST_F(MetaType, Data) {
     auto type = entt::resolve<clazz_t>();
     int counter{};
 
@@ -191,7 +206,7 @@ TEST_F(Meta, MetaTypeData) {
     ASSERT_TRUE(type.data("value"_hs));
 }
 
-TEST_F(Meta, MetaTypeFunc) {
+TEST_F(MetaType, Func) {
     auto type = entt::resolve<clazz_t>();
     int counter{};
 
@@ -204,43 +219,43 @@ TEST_F(Meta, MetaTypeFunc) {
     ASSERT_TRUE(type.func("func"_hs));
 }
 
-TEST_F(Meta, MetaTypeConstruct) {
+TEST_F(MetaType, Construct) {
     auto any = entt::resolve<clazz_t>().construct(base_t{}, 42);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().value, 42);
 }
 
-TEST_F(Meta, MetaTypeConstructNoArgs) {
+TEST_F(MetaType, ConstructNoArgs) {
     // this should work, no other tests required
     auto any = entt::resolve<clazz_t>().construct();
 
     ASSERT_TRUE(any);
 }
 
-TEST_F(Meta, MetaTypeConstructMetaAnyArgs) {
+TEST_F(MetaType, ConstructMetaAnyArgs) {
     auto any = entt::resolve<clazz_t>().construct(entt::meta_any{base_t{}}, entt::meta_any{42});
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().value, 42);
 }
 
-TEST_F(Meta, MetaTypeConstructInvalidArgs) {
+TEST_F(MetaType, ConstructInvalidArgs) {
     ASSERT_FALSE(entt::resolve<clazz_t>().construct(base_t{}, 'c'));
 }
 
-TEST_F(Meta, MetaTypeLessArgs) {
+TEST_F(MetaType, LessArgs) {
     ASSERT_FALSE(entt::resolve<clazz_t>().construct(base_t{}));
 }
 
-TEST_F(Meta, MetaTypeConstructCastAndConvert) {
+TEST_F(MetaType, ConstructCastAndConvert) {
     auto any = entt::resolve<clazz_t>().construct(derived_t{}, 42.);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<clazz_t>().value, 42);
 }
 
-TEST_F(Meta, MetaTypeDetach) {
+TEST_F(MetaType, Detach) {
     ASSERT_TRUE(entt::resolve_id("clazz"_hs));
 
     entt::resolve([](auto type) {
@@ -259,7 +274,7 @@ TEST_F(Meta, MetaTypeDetach) {
     ASSERT_TRUE(entt::resolve_id("clazz"_hs));
 }
 
-TEST_F(Meta, AbstractClass) {
+TEST_F(MetaType, AbstractClass) {
     auto type = entt::resolve<abstract_t>();
     concrete_t instance;
 
@@ -273,7 +288,7 @@ TEST_F(Meta, AbstractClass) {
     ASSERT_EQ(instance.value, 42);
 }
 
-TEST_F(Meta, EnumAndNamedConstants) {
+TEST_F(MetaType, EnumAndNamedConstants) {
     auto type = entt::resolve<property_t>();
 
     ASSERT_TRUE(type.data("random"_hs));
@@ -289,7 +304,7 @@ TEST_F(Meta, EnumAndNamedConstants) {
     ASSERT_EQ(type.data("value"_hs).get({}).cast<property_t>(), property_t::value);
 }
 
-TEST_F(Meta, ArithmeticTypeAndNamedConstants) {
+TEST_F(MetaType, ArithmeticTypeAndNamedConstants) {
     auto type = entt::resolve<unsigned int>();
 
     ASSERT_TRUE(type.data("min"_hs));
@@ -305,7 +320,7 @@ TEST_F(Meta, ArithmeticTypeAndNamedConstants) {
     ASSERT_EQ(type.data("max"_hs).get({}).cast<unsigned int>(), 100u);
 }
 
-TEST_F(Meta, Variables) {
+TEST_F(MetaType, Variables) {
     auto p_data = entt::resolve<property_t>().data("var"_hs);
     auto d_data = entt::resolve_id("double"_hs).data("var"_hs);
 
@@ -321,7 +336,7 @@ TEST_F(Meta, Variables) {
     ASSERT_EQ(d, 42.);
 }
 
-TEST_F(Meta, PropertiesAndCornerCases) {
+TEST_F(MetaType, PropertiesAndCornerCases) {
     auto type = entt::resolve<property_t>();
 
     ASSERT_EQ(type.data("random"_hs).prop(property_t::random).value().cast<int>(), 0);
@@ -341,7 +356,7 @@ TEST_F(Meta, PropertiesAndCornerCases) {
     ASSERT_FALSE(type.data("list"_hs).prop(property_t::key_only).value());
 }
 
-TEST_F(Meta, ResetAndReRegistrationAfterReset) {
+TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
     ASSERT_NE(*entt::internal::meta_context::global(), nullptr);
 
     entt::meta<double>().reset();