test: added meta_ctor

test/CMakeLists.txt

@@ -181,6 +181,7 @@ SETUP_BASIC_TEST(meta_any entt/meta/meta_any.cpp)
 SETUP_BASIC_TEST(meta_base entt/meta/meta_base.cpp)
 SETUP_BASIC_TEST(meta_basic entt/meta/meta_basic.cpp)
 SETUP_BASIC_TEST(meta_conv entt/meta/meta_conv.cpp)
+SETUP_BASIC_TEST(meta_ctor entt/meta/meta_ctor.cpp)
 SETUP_BASIC_TEST(meta_prop entt/meta/meta_prop.cpp)
 
 list(APPEND TEST_META_SOURCES entt/meta/meta.cpp entt/meta/fixture.cpp)

test/entt/meta/meta.cpp

@@ -9,113 +9,6 @@
 #include <entt/meta/resolve.hpp>
 #include "fixture.h"
 
-TEST_F(Meta, MetaCtor) {
-    auto ctor = entt::resolve<derived_type>().ctor<const base_type &, int, char>();
-
-    ASSERT_TRUE(ctor);
-    ASSERT_EQ(ctor.parent(), entt::resolve_id("derived"_hs));
-    ASSERT_EQ(ctor.size(), 3u);
-    ASSERT_EQ(ctor.arg(0u), entt::resolve<base_type>());
-    ASSERT_EQ(ctor.arg(1u), entt::resolve<int>());
-    ASSERT_EQ(ctor.arg(2u), entt::resolve<char>());
-    ASSERT_FALSE(ctor.arg(3u));
-
-    auto any = ctor.invoke(base_type{}, 42, 'c');
-    auto empty = ctor.invoke();
-
-    ASSERT_FALSE(empty);
-    ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<derived_type>().i, 42);
-    ASSERT_EQ(any.cast<derived_type>().c, 'c');
-
-    ctor.prop([](auto prop) {
-        ASSERT_EQ(prop.key(), props::prop_bool);
-        ASSERT_FALSE(prop.value().template cast<bool>());
-    });
-
-    ASSERT_FALSE(ctor.prop(props::prop_int));
-
-    auto prop = ctor.prop(props::prop_bool);
-
-    ASSERT_TRUE(prop);
-    ASSERT_EQ(prop.key(), props::prop_bool);
-    ASSERT_FALSE(prop.value().template cast<bool>());
-}
-
-TEST_F(Meta, MetaCtorFunc) {
-    auto ctor = entt::resolve<derived_type>().ctor<const base_type &, int>();
-
-    ASSERT_TRUE(ctor);
-    ASSERT_EQ(ctor.parent(), entt::resolve_id("derived"_hs));
-    ASSERT_EQ(ctor.size(), 2u);
-    ASSERT_EQ(ctor.arg(0u), entt::resolve<base_type>());
-    ASSERT_EQ(ctor.arg(1u), entt::resolve<int>());
-    ASSERT_FALSE(ctor.arg(2u));
-
-    auto any = ctor.invoke(derived_type{}, 42);
-    auto empty = ctor.invoke(3, 'c');
-
-    ASSERT_FALSE(empty);
-    ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<derived_type>().i, 42);
-    ASSERT_EQ(any.cast<derived_type>().c, 'c');
-
-    ctor.prop([](auto prop) {
-        ASSERT_EQ(prop.key(), props::prop_int);
-        ASSERT_EQ(prop.value(), 42);
-    });
-
-    ASSERT_FALSE(ctor.prop(props::prop_bool));
-
-    auto prop = ctor.prop(props::prop_int);
-
-    ASSERT_TRUE(prop);
-    ASSERT_EQ(prop.key(), props::prop_int);
-    ASSERT_EQ(prop.value(), 42);
-}
-
-TEST_F(Meta, MetaCtorMetaAnyArgs) {
-    auto any = entt::resolve<derived_type>().ctor<const base_type &, int, char>().invoke(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, MetaCtorInvalidArgs) {
-    auto ctor = entt::resolve<derived_type>().ctor<const base_type &, int, char>();
-    ASSERT_FALSE(ctor.invoke(base_type{}, 'c', 42));
-}
-
-TEST_F(Meta, MetaCtorCastAndConvert) {
-    auto any = entt::resolve<derived_type>().ctor<const base_type &, int, char>().invoke(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, MetaCtorFuncMetaAnyArgs) {
-    auto any = entt::resolve<derived_type>().ctor<const base_type &, int>().invoke(base_type{}, 42);
-
-    ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<derived_type>().i, 42);
-    ASSERT_EQ(any.cast<derived_type>().c, 'c');
-}
-
-TEST_F(Meta, MetaCtorFuncInvalidArgs) {
-    auto ctor = entt::resolve<derived_type>().ctor<const base_type &, int>();
-    ASSERT_FALSE(ctor.invoke(base_type{}, 'c'));
-}
-
-TEST_F(Meta, MetaCtorFuncCastAndConvert) {
-    auto any = entt::resolve<derived_type>().ctor<const base_type &, int>().invoke(derived_type{}, 42.);
-
-    ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<derived_type>().i, 42);
-    ASSERT_EQ(any.cast<derived_type>().c, 'c');
-}
-
 TEST_F(Meta, MetaData) {
     auto data = entt::resolve<data_type>().data("i"_hs);
     data_type instance{};

test/entt/meta/meta_ctor.cpp

@@ -0,0 +1,149 @@
+#include <gtest/gtest.h>
+#include <entt/core/hashed_string.hpp>
+#include <entt/core/utility.hpp>
+#include <entt/meta/factory.hpp>
+#include <entt/meta/meta.hpp>
+#include <entt/meta/resolve.hpp>
+
+struct base_t { char value{}; };
+struct derived_t: base_t {};
+
+struct clazz_t {
+    clazz_t(const base_t &other, int iv)
+        : clazz_t{iv, other.value}
+    {}
+
+    clazz_t(const int &iv, char cv)
+        : i{iv}, c{cv}
+    {}
+
+    static clazz_t factory(int value) {
+        return {value, 'c'};
+    }
+
+    static clazz_t factory(base_t other, int value, int mul) {
+        return {value * mul, other.value};
+    }
+
+    int i{};
+    char c{};
+};
+
+struct Meta: ::testing::Test {
+    static void SetUpTestCase() {
+        entt::meta<double>().conv<int>();
+        entt::meta<derived_t>().base<base_t>();
+        entt::meta<clazz_t>().type("clazz"_hs)
+                .ctor<const base_t &, int>()
+                .ctor<const int &, char>().prop(3, false)
+                .ctor<entt::overload<clazz_t(int)>(&clazz_t::factory)>().prop('c', 42)
+                .ctor<entt::overload<clazz_t(base_t, int, int)>(&clazz_t::factory)>();
+    }
+};
+
+TEST_F(Meta, MetaCtor) {
+    auto ctor = entt::resolve<clazz_t>().ctor<const int &, char>();
+
+    ASSERT_TRUE(ctor);
+    ASSERT_EQ(ctor.parent(), entt::resolve_id("clazz"_hs));
+    ASSERT_EQ(ctor.size(), 2u);
+    ASSERT_EQ(ctor.arg(0u), entt::resolve<int>());
+    ASSERT_EQ(ctor.arg(1u), entt::resolve<char>());
+    ASSERT_FALSE(ctor.arg(2u));
+
+    auto any = ctor.invoke(42, 'c');
+    auto empty = ctor.invoke();
+
+    ASSERT_FALSE(empty);
+    ASSERT_TRUE(any);
+    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+
+    ctor.prop([](auto prop) {
+        ASSERT_EQ(prop.key(), 3);
+        ASSERT_FALSE(prop.value().template cast<bool>());
+    });
+
+    ASSERT_FALSE(ctor.prop(2));
+    ASSERT_FALSE(ctor.prop('c'));
+
+    auto prop = ctor.prop(3);
+
+    ASSERT_TRUE(prop);
+    ASSERT_EQ(prop.key(), 3);
+    ASSERT_FALSE(prop.value().template cast<bool>());
+}
+
+TEST_F(Meta, MetaCtorFunc) {
+    auto ctor = entt::resolve<clazz_t>().ctor<int>();
+
+    ASSERT_TRUE(ctor);
+    ASSERT_EQ(ctor.parent(), entt::resolve_id("clazz"_hs));
+    ASSERT_EQ(ctor.size(), 1u);
+    ASSERT_EQ(ctor.arg(0u), entt::resolve<int>());
+    ASSERT_FALSE(ctor.arg(1u));
+
+    auto any = ctor.invoke(42);
+    auto empty = ctor.invoke(3, 'c');
+
+    ASSERT_FALSE(empty);
+    ASSERT_TRUE(any);
+    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+
+    ctor.prop([](auto prop) {
+        ASSERT_EQ(prop.key(), 'c');
+        ASSERT_EQ(prop.value(), 42);
+    });
+
+    ASSERT_FALSE(ctor.prop('d'));
+    ASSERT_FALSE(ctor.prop(3));
+
+    auto prop = ctor.prop('c');
+
+    ASSERT_TRUE(prop);
+    ASSERT_EQ(prop.key(), 'c');
+    ASSERT_EQ(prop.value(), 42);
+}
+
+TEST_F(Meta, MetaCtorMetaAnyArgs) {
+    auto any = entt::resolve<clazz_t>().ctor<int, char>().invoke(entt::meta_any{42}, entt::meta_any{'c'});
+
+    ASSERT_TRUE(any);
+    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+}
+
+TEST_F(Meta, MetaCtorInvalidArgs) {
+    auto ctor = entt::resolve<clazz_t>().ctor<int, char>();
+    ASSERT_FALSE(ctor.invoke('c', 42));
+}
+
+TEST_F(Meta, MetaCtorCastAndConvert) {
+    auto any = entt::resolve<clazz_t>().ctor<const base_t &, int>().invoke(derived_t{{'c'}}, 42.);
+
+    ASSERT_TRUE(any);
+    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+}
+
+TEST_F(Meta, MetaCtorFuncMetaAnyArgs) {
+    auto any = entt::resolve<clazz_t>().ctor<base_t, int>().invoke(entt::meta_any{base_t{'c'}}, entt::meta_any{42});
+
+    ASSERT_TRUE(any);
+    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+}
+
+TEST_F(Meta, MetaCtorFuncInvalidArgs) {
+    auto ctor = entt::resolve<clazz_t>().ctor<const base_t &, int>();
+    ASSERT_FALSE(ctor.invoke(base_t{}, 'c'));
+}
+
+TEST_F(Meta, MetaCtorFuncCastAndConvert) {
+    auto any = entt::resolve<clazz_t>().ctor<base_t, int, int>().invoke(derived_t{{'c'}}, 3., 3);
+
+    ASSERT_TRUE(any);
+    ASSERT_EQ(any.cast<clazz_t>().i, 9);
+    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+}