test: added meta_type

test/CMakeLists.txt

@@ -185,6 +185,7 @@ SETUP_BASIC_TEST(meta_ctor entt/meta/meta_ctor.cpp)
 SETUP_BASIC_TEST(meta_data entt/meta/meta_data.cpp)
 SETUP_BASIC_TEST(meta_func entt/meta/meta_func.cpp)
 SETUP_BASIC_TEST(meta_prop entt/meta/meta_prop.cpp)
+SETUP_BASIC_TEST(meta_type entt/meta/meta_type.cpp)
 
 list(APPEND TEST_META_SOURCES entt/meta/meta.cpp entt/meta/fixture.cpp)
 SETUP_BASIC_TEST(meta "${TEST_META_SOURCES}")

test/entt/meta/meta.cpp

@@ -9,178 +9,6 @@
 #include <entt/meta/resolve.hpp>
 #include "fixture.h"
 
-TEST_F(Meta, MetaType) {
-    auto type = entt::resolve<derived_type>();
-
-    ASSERT_TRUE(type);
-    ASSERT_NE(type, entt::meta_type{});
-    ASSERT_EQ(type.id(), "derived"_hs);
-    ASSERT_EQ(type.type_id(), entt::type_info<derived_type>::id());
-
-    type.prop([](auto prop) {
-        ASSERT_EQ(prop.key(), props::prop_int);
-        ASSERT_EQ(prop.value(), 99);
-    });
-
-    ASSERT_FALSE(type.prop(props::prop_bool));
-
-    auto prop = type.prop(props::prop_int);
-
-    ASSERT_TRUE(prop);
-    ASSERT_EQ(prop.key(), props::prop_int);
-    ASSERT_EQ(prop.value(), 99);
-}
-
-TEST_F(Meta, MetaTypeTraits) {
-    ASSERT_TRUE(entt::resolve<void>().is_void());
-    ASSERT_TRUE(entt::resolve<bool>().is_integral());
-    ASSERT_TRUE(entt::resolve<double>().is_floating_point());
-    ASSERT_TRUE(entt::resolve<props>().is_enum());
-    ASSERT_TRUE(entt::resolve<union_type>().is_union());
-    ASSERT_TRUE(entt::resolve<derived_type>().is_class());
-    ASSERT_TRUE(entt::resolve<int *>().is_pointer());
-    ASSERT_TRUE(entt::resolve<decltype(&empty_type::destroy)>().is_function_pointer());
-    ASSERT_TRUE(entt::resolve<decltype(&data_type::i)>().is_member_object_pointer());
-    ASSERT_TRUE(entt::resolve<decltype(&func_type::g)>().is_member_function_pointer());
-}
-
-TEST_F(Meta, MetaTypeRemovePointer) {
-    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_type>().remove_pointer(), entt::resolve<derived_type>());
-}
-
-TEST_F(Meta, MetaTypeRemoveExtent) {
-    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_type>().remove_extent(), entt::resolve<derived_type>());
-}
-
-TEST_F(Meta, MetaTypeBase) {
-    auto type = entt::resolve<derived_type>();
-    bool iterate = false;
-
-    type.base([&iterate](auto base) {
-        ASSERT_EQ(base.type(), entt::resolve<base_type>());
-        iterate = true;
-    });
-
-    ASSERT_TRUE(iterate);
-    ASSERT_EQ(type.base("base"_hs).type(), entt::resolve<base_type>());
-}
-
-TEST_F(Meta, MetaTypeConv) {
-    auto type = entt::resolve<double>();
-    bool iterate = false;
-
-    type.conv([&iterate](auto conv) {
-        ASSERT_EQ(conv.type(), entt::resolve<int>());
-        iterate = true;
-    });
-
-    ASSERT_TRUE(iterate);
-
-    auto conv = type.conv<int>();
-
-    ASSERT_EQ(conv.type(), entt::resolve<int>());
-    ASSERT_FALSE(type.conv<char>());
-}
-
-TEST_F(Meta, MetaTypeCtor) {
-    auto type = entt::resolve<derived_type>();
-    int counter{};
-
-    type.ctor([&counter](auto) {
-        ++counter;
-    });
-
-    ASSERT_EQ(counter, 2);
-    ASSERT_TRUE((type.ctor<const base_type &, int>()));
-    ASSERT_TRUE((type.ctor<const derived_type &, double>()));
-}
-
-TEST_F(Meta, MetaTypeData) {
-    auto type = entt::resolve<data_type>();
-    int counter{};
-
-    type.data([&counter](auto) {
-        ++counter;
-    });
-
-    ASSERT_EQ(counter, 6);
-    ASSERT_TRUE(type.data("i"_hs));
-}
-
-TEST_F(Meta, MetaTypeFunc) {
-    auto type = entt::resolve<func_type>();
-    int counter{};
-
-    type.func([&counter](auto) {
-        ++counter;
-    });
-
-    ASSERT_EQ(counter, 8);
-    ASSERT_TRUE(type.func("f1"_hs));
-}
-
-TEST_F(Meta, MetaTypeConstruct) {
-    auto any = entt::resolve<derived_type>().construct(base_type{}, 42, 'c');
-
-    ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<derived_type>().i, 42);
-    ASSERT_EQ(any.cast<derived_type>().c, 'c');
-}
-
-TEST_F(Meta, MetaTypeConstructNoArgs) {
-    // this should work, no other tests required
-    auto any = entt::resolve<empty_type>().construct();
-
-    ASSERT_TRUE(any);
-}
-
-TEST_F(Meta, MetaTypeConstructMetaAnyArgs) {
-    auto any = entt::resolve<derived_type>().construct(base_type{}, 42, 'c');
-
-    ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<derived_type>().i, 42);
-    ASSERT_EQ(any.cast<derived_type>().c, 'c');
-}
-
-TEST_F(Meta, MetaTypeConstructInvalidArgs) {
-    ASSERT_FALSE(entt::resolve<derived_type>().construct(base_type{}, 'c', 42));
-}
-
-TEST_F(Meta, MetaTypeLessArgs) {
-    ASSERT_FALSE(entt::resolve<derived_type>().construct(base_type{}));
-}
-
-TEST_F(Meta, MetaTypeConstructCastAndConvert) {
-    auto any = entt::resolve<derived_type>().construct(derived_type{}, 42., 'c');
-
-    ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<derived_type>().i, 42);
-    ASSERT_EQ(any.cast<derived_type>().c, 'c');
-}
-
-TEST_F(Meta, MetaTypeDetach) {
-    ASSERT_TRUE(entt::resolve_id("char"_hs));
-
-    entt::resolve([](auto type) {
-        if(type.id() == "char"_hs) {
-            type.detach();
-        }
-    });
-
-    ASSERT_FALSE(entt::resolve_id("char"_hs));
-    ASSERT_EQ(entt::resolve<char>().id(), "char"_hs);
-    ASSERT_EQ(entt::resolve<char>().prop(props::prop_int).value().cast<int>(), 42);
-    ASSERT_TRUE(entt::resolve<char>().data("value"_hs));
-
-    entt::meta<char>().type("char"_hs);
-
-    ASSERT_TRUE(entt::resolve_id("char"_hs));
-}
-
 TEST_F(Meta, MetaDataFromBase) {
     auto type = entt::resolve<concrete_type>();
     concrete_type instance;

test/entt/meta/meta_data.cpp

@@ -56,7 +56,7 @@ struct array_t {
     int local[3];
 };
 
-enum class properties {
+enum class property_t {
     random,
     value
 };
@@ -70,8 +70,8 @@ struct Meta: ::testing::Test {
         entt::meta<clazz_t>().type("clazz"_hs)
                 .data<&clazz_t::i, entt::as_ref_t>("i"_hs).prop(3, 0)
                 .data<&clazz_t::j>("j"_hs).prop(true, 1)
-                .data<&clazz_t::h>("h"_hs).prop(properties::random, 2)
-                .data<&clazz_t::k>("k"_hs).prop(properties::value, 3)
+                .data<&clazz_t::h>("h"_hs).prop(property_t::random, 2)
+                .data<&clazz_t::k>("k"_hs).prop(property_t::value, 3)
                 .data<&clazz_t::base>("base"_hs)
                 .data<&clazz_t::i, entt::as_void_t>("void"_hs);
 
@@ -167,17 +167,17 @@ TEST_F(Meta, MetaDataStatic) {
     ASSERT_EQ(data.get({}).cast<int>(), 42);
 
     data.prop([](auto prop) {
-        ASSERT_EQ(prop.key(), properties::random);
+        ASSERT_EQ(prop.key(), property_t::random);
         ASSERT_EQ(prop.value(), 2);
     });
 
-    ASSERT_FALSE(data.prop(properties::value));
+    ASSERT_FALSE(data.prop(property_t::value));
     ASSERT_FALSE(data.prop('c'));
 
-    auto prop = data.prop(properties::random);
+    auto prop = data.prop(property_t::random);
 
     ASSERT_TRUE(prop);
-    ASSERT_EQ(prop.key(), properties::random);
+    ASSERT_EQ(prop.key(), property_t::random);
     ASSERT_EQ(prop.value(), 2);
 }
 
@@ -195,17 +195,17 @@ TEST_F(Meta, MetaDataConstStatic) {
     ASSERT_EQ(data.get({}).cast<int>(), 3);
 
     data.prop([](auto prop) {
-        ASSERT_EQ(prop.key(), properties::value);
+        ASSERT_EQ(prop.key(), property_t::value);
         ASSERT_EQ(prop.value(), 3);
     });
 
-    ASSERT_FALSE(data.prop(properties::random));
+    ASSERT_FALSE(data.prop(property_t::random));
     ASSERT_FALSE(data.prop('c'));
 
-    auto prop = data.prop(properties::value);
+    auto prop = data.prop(property_t::value);
 
     ASSERT_TRUE(prop);
-    ASSERT_EQ(prop.key(), properties::value);
+    ASSERT_EQ(prop.key(), property_t::value);
     ASSERT_EQ(prop.value(), 3);
 }
 

test/entt/meta/meta_type.cpp

@@ -0,0 +1,244 @@
+#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>
+
+template<typename Type>
+void set(Type &prop, Type value) {
+    prop = value;
+}
+
+template<typename Type>
+Type get(Type &prop) {
+    return prop;
+}
+
+struct base_t {};
+struct derived_t: base_t {};
+
+struct clazz_t {
+    clazz_t() = default;
+
+    clazz_t(const base_t &, int v)
+        : value{v}
+    {}
+
+    void member() {}
+    static void func() {}
+
+    int value;
+};
+
+enum class property_t {
+    random,
+    value,
+    key_only,
+    list
+};
+
+union union_t {
+    int i;
+    double d;
+};
+
+struct Meta: ::testing::Test {
+    static void SetUpTestCase() {
+        entt::meta<double>().conv<int>();
+        entt::meta<base_t>().type("base"_hs);
+        entt::meta<derived_t>().type("derived"_hs).base<base_t>();
+
+        entt::meta<property_t>()
+                .data<property_t::random>("random"_hs)
+                    .prop(property_t::random, 0)
+                    .prop(property_t::value, 3)
+                .data<property_t::value>("value"_hs)
+                    .prop(std::make_tuple(std::make_pair(property_t::random, true), std::make_pair(property_t::value, 0), std::make_pair(property_t::key_only, 3)))
+                    .prop(property_t::list)
+                .data<property_t::key_only>("key_only"_hs)
+                    .prop([]() { return property_t::key_only; })
+                .data<&set<property_t>, &get<property_t>>("wrap"_hs)
+                .data<property_t::list>("list"_hs)
+                   .props(std::make_pair(property_t::random, false), std::make_pair(property_t::value, 0), property_t::key_only);
+
+        entt::meta<clazz_t>()
+                .type("clazz"_hs)
+                    .prop(property_t::value, 42)
+                .ctor().ctor<const base_t &, int>()
+                .data<&clazz_t::value>("value"_hs)
+                .func<&clazz_t::member>("member"_hs)
+                .func<&clazz_t::func>("func"_hs);
+    }
+};
+
+TEST_F(Meta, MetaType) {
+    auto type = entt::resolve<clazz_t>();
+
+    ASSERT_TRUE(type);
+    ASSERT_NE(type, entt::meta_type{});
+    ASSERT_EQ(type.id(), "clazz"_hs);
+    ASSERT_EQ(type.type_id(), entt::type_info<clazz_t>::id());
+
+    type.prop([](auto prop) {
+        ASSERT_EQ(prop.key(), property_t::value);
+        ASSERT_EQ(prop.value(), 42);
+    });
+
+    ASSERT_FALSE(type.prop(property_t::key_only));
+    ASSERT_FALSE(type.prop("property"_hs));
+
+    auto prop = type.prop(property_t::value);
+
+    ASSERT_TRUE(prop);
+    ASSERT_EQ(prop.key(), property_t::value);
+    ASSERT_EQ(prop.value(), 42);
+}
+
+TEST_F(Meta, MetaTypeTraits) {
+    ASSERT_TRUE(entt::resolve<void>().is_void());
+    ASSERT_TRUE(entt::resolve<bool>().is_integral());
+    ASSERT_TRUE(entt::resolve<double>().is_floating_point());
+    ASSERT_TRUE(entt::resolve<property_t>().is_enum());
+    ASSERT_TRUE(entt::resolve<union_t>().is_union());
+    ASSERT_TRUE(entt::resolve<derived_t>().is_class());
+    ASSERT_TRUE(entt::resolve<int *>().is_pointer());
+    ASSERT_TRUE(entt::resolve<decltype(&clazz_t::func)>().is_function_pointer());
+    ASSERT_TRUE(entt::resolve<decltype(&clazz_t::value)>().is_member_object_pointer());
+    ASSERT_TRUE(entt::resolve<decltype(&clazz_t::member)>().is_member_function_pointer());
+}
+
+TEST_F(Meta, MetaTypeRemovePointer) {
+    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) {
+    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) {
+    auto type = entt::resolve<derived_t>();
+    bool iterate = false;
+
+    type.base([&iterate](auto base) {
+        ASSERT_EQ(base.type(), entt::resolve<base_t>());
+        iterate = true;
+    });
+
+    ASSERT_TRUE(iterate);
+    ASSERT_EQ(type.base("base"_hs).type(), entt::resolve<base_t>());
+}
+
+TEST_F(Meta, MetaTypeConv) {
+    auto type = entt::resolve<double>();
+    bool iterate = false;
+
+    type.conv([&iterate](auto conv) {
+        ASSERT_EQ(conv.type(), entt::resolve<int>());
+        iterate = true;
+    });
+
+    ASSERT_TRUE(iterate);
+
+    auto conv = type.conv<int>();
+
+    ASSERT_EQ(conv.type(), entt::resolve<int>());
+    ASSERT_FALSE(type.conv<char>());
+}
+
+TEST_F(Meta, MetaTypeCtor) {
+    auto type = entt::resolve<clazz_t>();
+    int counter{};
+
+    type.ctor([&counter](auto) {
+        ++counter;
+    });
+
+    ASSERT_EQ(counter, 2);
+    ASSERT_TRUE((type.ctor()));
+    ASSERT_TRUE((type.ctor<const base_t &, int>()));
+    ASSERT_TRUE((type.ctor<const derived_t &, double>()));
+}
+
+TEST_F(Meta, MetaTypeData) {
+    auto type = entt::resolve<clazz_t>();
+    int counter{};
+
+    type.data([&counter](auto) {
+        ++counter;
+    });
+
+    ASSERT_EQ(counter, 1);
+    ASSERT_TRUE(type.data("value"_hs));
+}
+
+TEST_F(Meta, MetaTypeFunc) {
+    auto type = entt::resolve<clazz_t>();
+    int counter{};
+
+    type.func([&counter](auto) {
+        ++counter;
+    });
+
+    ASSERT_EQ(counter, 2);
+    ASSERT_TRUE(type.func("member"_hs));
+    ASSERT_TRUE(type.func("func"_hs));
+}
+
+TEST_F(Meta, MetaTypeConstruct) {
+    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) {
+    // this should work, no other tests required
+    auto any = entt::resolve<clazz_t>().construct();
+
+    ASSERT_TRUE(any);
+}
+
+TEST_F(Meta, MetaTypeConstructMetaAnyArgs) {
+    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) {
+    ASSERT_FALSE(entt::resolve<clazz_t>().construct(base_t{}, 'c'));
+}
+
+TEST_F(Meta, MetaTypeLessArgs) {
+    ASSERT_FALSE(entt::resolve<clazz_t>().construct(base_t{}));
+}
+
+TEST_F(Meta, MetaTypeConstructCastAndConvert) {
+    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) {
+    ASSERT_TRUE(entt::resolve_id("clazz"_hs));
+
+    entt::resolve([](auto type) {
+        if(type.id() == "clazz"_hs) {
+            type.detach();
+        }
+    });
+
+    ASSERT_FALSE(entt::resolve_id("clazz"_hs));
+    ASSERT_EQ(entt::resolve<clazz_t>().id(), "clazz"_hs);
+    ASSERT_EQ(entt::resolve<clazz_t>().prop(property_t::value).value().cast<int>(), 42);
+    ASSERT_TRUE(entt::resolve<clazz_t>().data("value"_hs));
+
+    entt::meta<clazz_t>().type("clazz"_hs);
+
+    ASSERT_TRUE(entt::resolve_id("clazz"_hs));
+}