// https://github.com/kunitoki/LuaBridge3 // Copyright 2023, Lucio Asnaghi // Copyright 2020, Dmitry Tarakanov // SPDX-License-Identifier: MIT #include "TestBase.h" #include #include #include #include #include struct ClassTests : TestBase { template T variable(const std::string& name) { runLua("result = " + name); return result(); } }; namespace { struct EmptyBase { }; template struct Class : Base { Class() : data() {} Class(T data) : data(data) {} static Class staticFunction(Class value) { return value; } std::string toString() const { std::ostringstream stream; stream << data; return stream.str(); } bool operator==(const Class& rhs) const { return data == rhs.data; } bool operator<(const Class& rhs) const { return data < rhs.data; } bool operator<=(const Class& rhs) const { return data <= rhs.data; } Class operator+(const Class& rhs) const { return Class(data + rhs.data); } Class operator-(const Class& rhs) const { return Class(data - rhs.data); } Class operator*(const Class& rhs) const { return Class(data * rhs.data); } Class operator/(const Class& rhs) const { return Class(data / rhs.data); } Class operator%(const Class& rhs) const { return Class(data % rhs.data); } Class operator()(T param) { return Class(param); } int len() const { return data; } Class negate() const { return Class(-data); } T method(T value) { return value; } T methodState(T value, lua_State*) { return value; } T constMethod(T value) const { return value; } T getData() const { return data; } T getDataNoexcept() const noexcept { return data; } void setData(T data) { this->data = data; } void setDataNoexcept(T data) noexcept { this->data = data; } T getDataState(lua_State*) const { return data; } T getDataStateNoexcept(lua_State*) const noexcept { return data; } void setDataState(T data, lua_State*) { this->data = data; } void setDataStateNoexcept(T data, lua_State*) noexcept { this->data = data; } static T getStaticData() { return staticData; } static void setStaticData(T data) { staticData = data; } static T getStaticDataNoexcept() noexcept { return staticData; } static void setStaticDataNoexcept(T data) noexcept { staticData = data; } mutable T data; static T staticData; static const T staticConstData; }; template T Class::staticData = {}; template const T Class::staticConstData = {}; template class Foo { public: Foo() = default; Foo(const std::string& name) : name(name) { } const std::string& getName() const { return name; } static Foo& createRef(const std::string& name) { static Foo instance(name); return instance; } static const Foo& createConstRef(const std::string& name) { static Foo instance(name); return instance; } private: std::string name; }; template class Bar { public: Bar() = default; void setFoo(const luabridge::LuaRef& ref) { if (ref.isInstance>()) foo = ref.cast>().value(); else foo = Foo("undefined"); } const std::string& getFooName() const { return foo.getName(); } private: Foo foo; }; } // namespace TEST_F(ClassTests, Assignment) { using BaseClass = Class; auto registeredClass = luabridge::getGlobalNamespace(L) .beginClass("BaseClass"); registeredClass.addConstructor(); registeredClass.endClass(); } TEST_F(ClassTests, IsInstance) { using BaseClass = Class; using OtherClass = Class; using DerivedClass = Class; luabridge::getGlobalNamespace(L) .beginClass("BaseClass") .endClass() .deriveClass("DerivedClass") .endClass() .beginClass("OtherClass") .endClass(); BaseClass base; auto result1 = luabridge::push(L, base); ASSERT_TRUE(result1); DerivedClass derived; auto result2 = luabridge::push(L, derived); ASSERT_TRUE(result2); OtherClass other; auto result3 = luabridge::push(L, other); ASSERT_TRUE(result3); ASSERT_TRUE(luabridge::isInstance(L, -3)); ASSERT_FALSE(luabridge::isInstance(L, -3)); // BaseClass is not DerivedClass ASSERT_FALSE(luabridge::isInstance(L, -3)); ASSERT_TRUE(luabridge::isInstance(L, -2)); ASSERT_TRUE(luabridge::isInstance(L, -2)); // DerivedClass is BaseClass ASSERT_FALSE(luabridge::isInstance(L, -2)); ASSERT_FALSE(luabridge::isInstance(L, -1)); ASSERT_FALSE(luabridge::isInstance(L, -1)); ASSERT_TRUE(luabridge::isInstance(L, -1)); } TEST_F(ClassTests, IsInstanceRef) { struct A {}; using Fool = Foo; using Barn = Bar; luabridge::getGlobalNamespace(L) .beginClass("Foo") .addConstructor() .addStaticFunction("createRef", &Fool::createRef) .addFunction("__tostring", +[](const Fool& self) { return self.getName(); }) .endClass() .beginClass("Bar") .addConstructor() .addFunction("setFoo", &Barn::setFoo) .addFunction("getFooName", &Barn::getFooName) .endClass(); runLua(R"( local fooFirst = Foo('first') local bar = Bar() bar:setFoo(fooFirst) result = bar:getFooName() .. " " .. tostring(fooFirst) )"); EXPECT_EQ("first first", result()); runLua(R"( local fooSecond = Foo.createRef('second') local bar = Bar() bar:setFoo(fooSecond) result = bar:getFooName() .. " " .. tostring(fooSecond) )"); EXPECT_EQ("second second", result()); } TEST_F(ClassTests, IsInstanceConstRef) { struct B {}; using Fool = Foo; using Barn = Bar; luabridge::getGlobalNamespace(L) .beginClass("Foo") .addConstructor() .addStaticFunction("createConstRef", &Fool::createConstRef) .addFunction("__tostring", +[](const Fool& self) { return self.getName(); }) .endClass() .beginClass("Bar") .addConstructor() .addFunction("setFoo", &Barn::setFoo) .addFunction("getFooName", &Barn::getFooName) .endClass(); runLua(R"( local fooFirst = Foo('first') local bar = Bar() bar:setFoo(fooFirst) result = bar:getFooName() .. " " .. tostring(fooFirst) )"); EXPECT_EQ("first first", result()); runLua(R"( local fooSecond = Foo.createConstRef('second') local bar = Bar() bar:setFoo(fooSecond) result = bar:getFooName() .. " " .. tostring(fooSecond) )"); EXPECT_EQ("second second", result()); } TEST_F(ClassTests, RefExtensible) { struct C {}; using Fool = Foo; luabridge::getGlobalNamespace(L) .beginClass("Foo", luabridge::extensibleClass) .addConstructor() .addStaticFunction("createRef", &Fool::createRef) .addProperty("getName", &Fool::getName) .endClass(); runLua(R"( local foo = Foo.createRef('xyz') result = foo.getName )"); EXPECT_EQ("xyz", result()); runLua(R"( local foo = Foo.createRef('xyz') result = foo.nonExistent )"); EXPECT_TRUE(result().isNil()); } TEST_F(ClassTests, ConstRefExtensible) { struct D {}; using Fool = Foo; luabridge::getGlobalNamespace(L) .beginClass("Foo", luabridge::extensibleClass) .addConstructor() .addStaticFunction("createConstRef", &Fool::createConstRef) .addProperty("getName", &Fool::getName) .endClass(); runLua(R"( local foo = Foo.createConstRef('xyz') result = foo.getName )"); EXPECT_EQ("xyz", result()); runLua(R"( local foo = Foo.createConstRef('xyz') result = foo.nonExistent )"); EXPECT_TRUE(result().isNil()); } TEST_F(ClassTests, PassingUnregisteredClassToLuaThrows) { using Unregistered = Class; runLua("function process_fn (value) end"); auto process_fn = luabridge::getGlobal(L, "process_fn"); ASSERT_TRUE(process_fn.isFunction()); Unregistered value(1); const Unregistered constValue(2); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(process_fn(value), std::exception); ASSERT_THROW(process_fn(constValue), std::exception); ASSERT_THROW(process_fn(&value), std::exception); ASSERT_THROW(process_fn(&constValue), std::exception); #else EXPECT_FALSE(process_fn(value)); EXPECT_FALSE(process_fn(constValue)); EXPECT_FALSE(process_fn(&value)); EXPECT_FALSE(process_fn(&constValue)); #endif } TEST_F(ClassTests, PassWrongClassFromLuaThrows) { using Right = Class; using WrongBase = Class; using Wrong = Class; luabridge::getGlobalNamespace(L) .beginClass("Right") .endClass() .beginClass("WrongBase") .endClass() .beginClass("Wrong") .addConstructor() .endClass() .addFunction("processRight", &Right::staticFunction); // bad argument #1 to 'processRight' (Right expected, got Wrong) #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result = processRight (Wrong (5))"), std::exception); #else ASSERT_FALSE(runLua("result = processRight (Wrong (5))")); #endif ASSERT_TRUE(result().isNil()); } TEST_F(ClassTests, PassDerivedClassInsteadOfBase) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .endClass() .deriveClass("Derived") .addConstructor() .endClass() .addFunction("processBase", &Base::staticFunction); runLua("result = processBase (Derived (3.14))"); ASSERT_EQ(0, result().data); } namespace { template T processNonConst(Class* object) { return object->data; } } // namespace TEST_F(ClassTests, PassConstClassInsteadOfNonConstThrows) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .endClass() .deriveClass("Derived") .endClass() .addFunction("processNonConst", &processNonConst); const Derived constObject(1.2f); luabridge::setGlobal(L, &constObject, "constObject"); // bad argument #1 to 'processNonConst' (Derived expected, got const Derived) #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result = processNonConst (constObject)"), std::exception); #else ASSERT_FALSE(runLua("result = processNonConst (constObject)")); #endif ASSERT_TRUE(result().isNil()); } TEST_F(ClassTests, PassOtherTypeInsteadOfNonConstThrows) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() // Show that it doesn't matter .endClass() .addFunction("processNonConst", &processNonConst); // bad argument #1 to 'processNonConst' (Int expected, got number) #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result = processNonConst (1)"), std::exception); #else ASSERT_FALSE(runLua("result = processNonConst (1)")); #endif ASSERT_TRUE(result().isNil()); } TEST_F(ClassTests, PassRegisteredClassInsteadOfUnregisteredThrows) { using Int = Class; using Float = Class; luabridge::getGlobalNamespace(L) .beginClass("Float") .addConstructor() .endClass() .addFunction("processUnregisteredInt", &Int::staticFunction); // bad argument #1 to 'processUnregisteredInt' (unregistered class expected, got Float) #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result = processUnregisteredInt (Float (1.2))"), std::exception); #else ASSERT_FALSE(runLua("result = processUnregisteredInt (Float (1.2))")); #endif ASSERT_TRUE(result().isNil()); } namespace { Class& returnRef() { static Class value(1); return value; } const Class& returnConstRef() { return returnRef(); } Class* returnPtr() { return &returnRef(); } const Class* returnConstPtr() { return &returnConstRef(); } Class returnValue() { return Class(2); } void addHelperFunctions(lua_State* L) { luabridge::getGlobalNamespace(L) .addFunction("returnRef", &returnRef) .addFunction("returnConstRef", &returnConstRef) .addFunction("returnPtr", &returnPtr) .addFunction("returnConstPtr", &returnConstPtr) .addFunction("returnValue", &returnValue); } } // namespace TEST_F(ClassTests, PassingUnregisteredClassFromLuaThrows) { addHelperFunctions(L); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result = returnRef ()"), std::exception); ASSERT_THROW(runLua("result = returnConstRef ()"), std::exception); ASSERT_THROW(runLua("result = returnPtr ()"), std::exception); ASSERT_THROW(runLua("result = returnConstPtr ()"), std::exception); ASSERT_THROW(runLua("result = returnValue ()"), std::exception); #else ASSERT_FALSE(runLua("result = returnRef ()")); ASSERT_FALSE(runLua("result = returnConstRef ()")); ASSERT_FALSE(runLua("result = returnPtr ()")); ASSERT_FALSE(runLua("result = returnConstPtr ()")); ASSERT_FALSE(runLua("result = returnValue ()")); #endif } #if LUABRIDGE_HAS_EXCEPTIONS TEST_F(ClassTests, DeriveFromUnregisteredClassThrows) { using Base = Class; using Derived = Class; EXPECT_EQ(0, lua_gettop(L)); EXPECT_THROW((luabridge::getGlobalNamespace(L).deriveClass("Derived")), std::exception); EXPECT_EQ(0, lua_gettop(L)); } #endif struct ClassFunctions : ClassTests { }; TEST_F(ClassFunctions, MemberFunctions) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("method", &Int::method) .endClass(); addHelperFunctions(L); runLua("result = returnRef ():method (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnPtr ():method (2)"); ASSERT_EQ(2, result()); runLua("result = returnConstPtr ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnValue ():method (3)"); ASSERT_EQ(3, result()); } TEST_F(ClassFunctions, MemberFunctions_PassState) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("method", &Int::methodState) .endClass(); addHelperFunctions(L); runLua("result = returnRef ():method (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnPtr ():method (2)"); ASSERT_EQ(2, result()); runLua("result = returnConstPtr ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnValue ():method (3)"); ASSERT_EQ(3, result()); } TEST_F(ClassFunctions, ConstMemberFunctions) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("constMethod", &Int::constMethod) .endClass(); addHelperFunctions(L); runLua("result = returnRef ():constMethod (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ():constMethod (2)"); ASSERT_EQ(2, result()); runLua("result = returnPtr ():constMethod (3)"); ASSERT_EQ(3, result()); runLua("result = returnConstPtr ():constMethod (4)"); ASSERT_EQ(4, result()); runLua("result = returnValue ():constMethod (5)"); ASSERT_EQ(5, result()); } namespace { struct ClassWithTemplateMembers { template int templateMethod(Args&&...) { return static_cast(sizeof...(Args)); } template int templateMethodNoexcept(Args&&...) noexcept { return static_cast(sizeof...(Args)); } }; template T proxyFunction(Class* object, T value) { object->data = value; return value; } template T proxyFunctionNoexcept(Class* object, T value) noexcept { object->data = value; return value; } template T proxyFunctionState(Class* object, T value, lua_State*) { object->data = value; return value; } template T proxyFunctionStateNoexcept(Class* object, T value, lua_State*) noexcept { object->data = value; return value; } template T proxyConstFunction(const Class* object, T value) { return value; } template T proxyConstFunctionNoexcept(const Class* object, T value) noexcept { return value; } int proxyCFunctionState(lua_State* L) { using Int = Class; auto ref = luabridge::LuaRef::fromStack(L, 1); if (!ref.isUserdata() || !ref.isInstance()) { return 0; } auto arg = luabridge::LuaRef::fromStack(L, 2); if (!arg.isNumber()) { return 0; } [[maybe_unused]] auto result = luabridge::push(L, arg.unsafe_cast() + 1000); return 1; } } // namespace TEST_F(ClassFunctions, ClassWithTemplateMembers) { luabridge::getGlobalNamespace(L) .beginClass("ClassWithTemplateMembers") .addConstructor() .addFunction("method", &ClassWithTemplateMembers::templateMethod) .addFunction("methodNoexcept", &ClassWithTemplateMembers::templateMethodNoexcept) .endClass(); runLua("local a = ClassWithTemplateMembers(); result = a:method()"); ASSERT_EQ(0, result()); runLua("local a = ClassWithTemplateMembers(); result = a:methodNoexcept()"); ASSERT_EQ(0, result()); } TEST_F(ClassFunctions, ProxyFunctions) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("method", &proxyFunction) .addFunction("methodNoexcept", &proxyFunctionNoexcept) .endClass(); addHelperFunctions(L); runLua("result = returnRef ():method (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnPtr ():method (2)"); ASSERT_EQ(2, result()); runLua("result = returnConstPtr ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnValue ():method (3)"); ASSERT_EQ(3, result()); runLua("result = returnRef ():methodNoexcept (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ().methodNoexcept"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnPtr ():methodNoexcept (2)"); ASSERT_EQ(2, result()); runLua("result = returnConstPtr ().methodNoexcept"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnValue ():methodNoexcept (3)"); ASSERT_EQ(3, result()); } TEST_F(ClassFunctions, ProxyFunctions_PassState) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("method", &proxyFunctionState) .addFunction("methodNoexcept", &proxyFunctionStateNoexcept) .endClass(); addHelperFunctions(L); runLua("result = returnRef ():method (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnPtr ():method (2)"); ASSERT_EQ(2, result()); runLua("result = returnConstPtr ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnValue ():method (3)"); ASSERT_EQ(3, result()); runLua("result = returnRef ():methodNoexcept (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ().methodNoexcept"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnPtr ():methodNoexcept (2)"); ASSERT_EQ(2, result()); runLua("result = returnConstPtr ().methodNoexcept"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnValue ():methodNoexcept (3)"); ASSERT_EQ(3, result()); } TEST_F(ClassFunctions, ConstProxyFunctions) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("constMethod", &proxyConstFunction) .addFunction("constMethodNoexcept", &proxyConstFunctionNoexcept) .endClass(); addHelperFunctions(L); runLua("result = returnRef ():constMethod (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ():constMethod (2)"); ASSERT_EQ(2, result()); runLua("result = returnPtr ():constMethod (3)"); ASSERT_EQ(3, result()); runLua("result = returnConstPtr ():constMethod (4)"); ASSERT_EQ(4, result()); runLua("result = returnValue ():constMethod (5)"); ASSERT_EQ(5, result()); runLua("result = returnRef ():constMethodNoexcept (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ():constMethodNoexcept (2)"); ASSERT_EQ(2, result()); runLua("result = returnPtr ():constMethodNoexcept (3)"); ASSERT_EQ(3, result()); runLua("result = returnConstPtr ():constMethodNoexcept (4)"); ASSERT_EQ(4, result()); runLua("result = returnValue ():constMethodNoexcept (5)"); ASSERT_EQ(5, result()); } TEST_F(ClassFunctions, ProxyCFunction) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("method", &proxyCFunctionState) .endClass(); addHelperFunctions(L); runLua("result = returnRef ():method (1000)"); ASSERT_EQ(2000, result()); } TEST_F(ClassFunctions, StdFunctions) { using Int = Class; auto sharedData = std::make_shared(); std::weak_ptr data = sharedData; // Check __gc meta-method std::function function = [sharedData](Int* object, int value) { object->data = value; return value; }; luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("method", std::move(function)) .endClass(); function = nullptr; sharedData.reset(); ASSERT_FALSE(data.expired()); addHelperFunctions(L); runLua("result = returnRef ():method (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnPtr ():method (2)"); ASSERT_EQ(2, result()); runLua("result = returnConstPtr ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnValue ():method (3)"); ASSERT_EQ(3, result()); runLua("result = nil"); closeLuaState(); // Force garbage collection ASSERT_TRUE(data.expired()); } TEST_F(ClassFunctions, StdFunctions_PassState) { using Int = Class; auto sharedData = std::make_shared(); std::weak_ptr data = sharedData; // Check __gc meta-method std::function function = [sharedData](Int* object, int value, lua_State*) { object->data = value; return value; }; luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("method", std::move(function)) .endClass(); function = nullptr; sharedData.reset(); ASSERT_FALSE(data.expired()); addHelperFunctions(L); runLua("result = returnRef ():method (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnPtr ():method (2)"); ASSERT_EQ(2, result()); runLua("result = returnConstPtr ().method"); // Don't call, just get ASSERT_TRUE(result().isNil()); runLua("result = returnValue ():method (3)"); ASSERT_EQ(3, result()); runLua("result = nil"); closeLuaState(); // Force garbage collection ASSERT_TRUE(data.expired()); } TEST_F(ClassFunctions, ConstStdFunctions) { using Int = Class; auto sharedData = std::make_shared(); std::weak_ptr data = sharedData; // Check __gc meta-method std::function function = [sharedData](const Int* object, int value) { object->data = value; return value; }; luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("constMethod", std::move(function)) .endClass(); function = nullptr; sharedData.reset(); ASSERT_FALSE(data.expired()); addHelperFunctions(L); runLua("result = returnRef ():constMethod (1)"); ASSERT_EQ(1, result()); runLua("result = returnConstRef ():constMethod (2)"); ASSERT_EQ(2, result()); runLua("result = returnPtr ():constMethod (3)"); ASSERT_EQ(3, result()); runLua("result = returnConstPtr ():constMethod (4)"); ASSERT_EQ(4, result()); runLua("result = returnValue ():constMethod (5)"); ASSERT_EQ(5, result()); runLua("result = nil"); closeLuaState(); // Force garbage collection ASSERT_TRUE(data.expired()); } struct ClassProperties : ClassTests { }; TEST_F(ClassProperties, FieldPointersNonRegistered) { using Int = Class; using UnregisteredInt = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addProperty("data", [](const Int&) { return UnregisteredInt(1); }) .endClass(); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result = Int().data"), std::exception); #else ASSERT_FALSE(runLua("result = Int().data")); #endif } TEST_F(ClassProperties, FieldPointers) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", &Int::data, true) .endClass(); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); runLua("result.data = 2"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(2, result()["data"].cast()); runLua("result = Int (42).data"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(42, result()); } TEST_F(ClassProperties, FieldPointers_ReadOnly) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", &Int::data, false) .endClass(); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result.data = 2"), std::exception); #else ASSERT_FALSE(runLua("result.data = 2")); #endif runLua("result = Int (42).data"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(42, result()); } TEST_F(ClassProperties, MemberFunctions) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", &Int::getData, &Int::setData) .addProperty("dataNoexcept", &Int::getDataNoexcept, &Int::setDataNoexcept) .addFunction("getDataNoexcept", &Int::getDataNoexcept) .addFunction("setDataNoexcept", &Int::setDataNoexcept) .endClass(); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); ASSERT_TRUE(result()["dataNoexcept"].isNumber()); ASSERT_EQ(501, result()["dataNoexcept"].cast()); runLua("result.data = -2"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(-2, result()["data"].cast()); runLua("result.dataNoexcept = -2"); ASSERT_TRUE(result()["dataNoexcept"].isNumber()); ASSERT_EQ(-2, result()["dataNoexcept"].cast()); } TEST_F(ClassProperties, MemberFunctions_PassState) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", &Int::getDataState, &Int::setDataState) .addProperty("dataNoexcept", &Int::getDataStateNoexcept, &Int::setDataStateNoexcept) .endClass(); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); ASSERT_TRUE(result()["dataNoexcept"].isNumber()); ASSERT_EQ(501, result()["dataNoexcept"].cast()); runLua("result.data = -2"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(-2, result()["data"].cast()); runLua("result.dataNoexcept = -2"); ASSERT_TRUE(result()["dataNoexcept"].isNumber()); ASSERT_EQ(-2, result()["dataNoexcept"].cast()); } TEST_F(ClassProperties, MemberFunctions_ReadOnly) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", &Int::getData) .endClass(); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result.data = -2"), std::exception); #else ASSERT_FALSE(runLua("result.data = -2")); #endif ASSERT_EQ(501, result()["data"].cast()); } TEST_F(ClassProperties, MemberFunctions_Derived) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .addProperty("data", &Base::getData, &Base::setData) .endClass() .deriveClass("Derived") .endClass(); Derived derived(12); derived.Base::data = "abc"; luabridge::setGlobal(L, &derived, "derived"); runLua("result = derived.data"); ASSERT_TRUE(result().isString()); ASSERT_EQ("abc", result()); runLua("derived.data = 5"); // Lua just casts integer to string ASSERT_EQ("5", derived.Base::data); ASSERT_EQ(12, derived.data); runLua("derived.data = '123'"); ASSERT_EQ("123", derived.Base::data); ASSERT_EQ(12, derived.data); } TEST_F(ClassProperties, MemberFunctions_Overridden) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .addProperty("data", &Base::getData, &Base::setData) .endClass() .deriveClass("Derived") .addProperty("data", &Derived::getData, &Derived::setData) .endClass(); Derived derived(50); derived.Base::data = 1.23f; luabridge::setGlobal(L, static_cast(&derived), "base"); luabridge::setGlobal(L, &derived, "derived"); runLua("result = base.data"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(1.23f, result()); runLua("result = derived.data"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(50, result()); runLua("base.data = -3.14"); ASSERT_EQ(-3.14f, derived.Base::data); ASSERT_EQ(50, derived.data); runLua("derived.data = 7"); ASSERT_EQ(-3.14f, derived.Base::data); ASSERT_EQ(7, derived.data); } namespace { template T getData(const Class* object) { return object->data; } template void setData(Class* object, T data) { object->data = data; } template T getDataNoexcept(const Class* object) noexcept { return object->data; } template void setDataNoexcept(Class* object, T data) noexcept { object->data = data; } } // namespace TEST_F(ClassProperties, ProxyFunctions) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", &getData, &setData) .endClass(); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); runLua("result.data = -2"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(-2, result()["data"].cast()); } TEST_F(ClassProperties, ProxyFunctionsNoexcept) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", &getDataNoexcept, &setDataNoexcept) .endClass(); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); runLua("result.data = -2"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(-2, result()["data"].cast()); } TEST_F(ClassProperties, ProxyFunctions_ReadOnly) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", &getData) .endClass(); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result.data = -2"), std::exception); #else ASSERT_FALSE(runLua("result.data = -2")); #endif ASSERT_EQ(501, result()["data"].cast()); } TEST_F(ClassProperties, ProxyFunctions_Derived) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .addProperty("data", &getData, &setData) .endClass() .deriveClass("Derived") .endClass(); Derived derived(12); derived.Base::data = "abc"; luabridge::setGlobal(L, &derived, "derived"); runLua("result = derived.data"); ASSERT_TRUE(result().isString()); ASSERT_EQ("abc", result()); runLua("derived.data = 5"); // Lua just casts integer to string ASSERT_EQ("5", derived.Base::data); ASSERT_EQ(12, derived.data); runLua("derived.data = '123'"); ASSERT_EQ("123", derived.Base::data); ASSERT_EQ(12, derived.data); } TEST_F(ClassProperties, ProxyFunctions_Overridden) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .addProperty("data", &getData, &setData) .endClass() .deriveClass("Derived") .addProperty("data", &getData, &setData) .endClass(); Derived derived(50); derived.Base::data = 1.23f; luabridge::setGlobal(L, static_cast(&derived), "base"); luabridge::setGlobal(L, &derived, "derived"); runLua("result = base.data"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(1.23f, result()); runLua("result = derived.data"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(50, result()); runLua("base.data = -3.14"); ASSERT_EQ(-3.14f, derived.Base::data); ASSERT_EQ(50, derived.data); runLua("derived.data = 7"); ASSERT_EQ(-3.14f, derived.Base::data); ASSERT_EQ(7, derived.data); } namespace { template int getDataC(lua_State* L) { auto objectRef = luabridge::LuaRef::fromStack(L, 1); auto* object = objectRef.unsafe_cast*>(); [[maybe_unused]] auto result = luabridge::Stack::push(L, object->data); return 1; } template int setDataC(lua_State* L) { auto objectRef = luabridge::LuaRef::fromStack(L, 1); auto* object = objectRef.unsafe_cast*>(); auto valueRef = luabridge::LuaRef::fromStack(L, 2); T value = valueRef.unsafe_cast(); object->data = value; return 0; } } // namespace TEST_F(ClassProperties, ProxyCFunctions) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", &getDataC, &setDataC) .endClass(); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); runLua("result.data = -2"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(-2, result()["data"].cast()); } TEST_F(ClassProperties, ProxyCFunctions_ReadOnly) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", &getDataC) .endClass(); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result.data = -2"), std::exception); #else ASSERT_FALSE(runLua("result.data = -2")); #endif ASSERT_EQ(501, result()["data"].cast()); } TEST_F(ClassProperties, ProxyCFunctions_Derived) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .addProperty("data", &getDataC, &setDataC) .endClass() .deriveClass("Derived") .endClass(); Derived derived(12); derived.Base::data = "abc"; luabridge::setGlobal(L, &derived, "derived"); runLua("result = derived.data"); ASSERT_TRUE(result().isString()); ASSERT_EQ("abc", result()); runLua("derived.data = 5"); // Lua just casts integer to string ASSERT_EQ("5", derived.Base::data); ASSERT_EQ(12, derived.data); runLua("derived.data = '123'"); ASSERT_EQ("123", derived.Base::data); ASSERT_EQ(12, derived.data); } TEST_F(ClassProperties, ProxyCFunctions_Overridden) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .addProperty("data", &getDataC, &setDataC) .endClass() .deriveClass("Derived") .addProperty("data", &getData, &setData) .endClass(); Derived derived(50); derived.Base::data = 1.23f; luabridge::setGlobal(L, static_cast(&derived), "base"); luabridge::setGlobal(L, &derived, "derived"); runLua("result = base.data"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(1.23f, result()); runLua("result = derived.data"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(50, result()); runLua("base.data = -3.14"); ASSERT_EQ(-3.14f, derived.Base::data); ASSERT_EQ(50, derived.data); runLua("derived.data = 7"); ASSERT_EQ(-3.14f, derived.Base::data); ASSERT_EQ(7, derived.data); } TEST_F(ClassProperties, StdFunctions) { using Int = Class; auto sharedGetterData = std::make_shared(); std::weak_ptr getterData = sharedGetterData; // Check __gc meta-method auto sharedSetterData = std::make_shared(); std::weak_ptr setterData = sharedGetterData; // Check __gc meta-method std::function getter = [sharedGetterData](const Int* object) { return object->data; }; std::function setter = [sharedSetterData](Int* object, int value) { object->data = value; }; int data2 = 1; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", std::move(getter), std::move(setter)) .addProperty("data2", [&data2](const Int*) { return data2; }, [data2 = std::addressof(data2)](Int*, int v) { *data2 = v; }) .endClass(); getter = nullptr; sharedGetterData.reset(); ASSERT_FALSE(getterData.expired()); setter = nullptr; sharedSetterData.reset(); ASSERT_FALSE(setterData.expired()); runLua("result = Int (501)"); ASSERT_EQ(501, result()["data"].cast()); runLua("result.data = -2"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(-2, result()["data"].cast()); runLua("result.data2 = -2"); ASSERT_TRUE(result()["data2"].isNumber()); ASSERT_EQ(-2, result()["data2"].cast()); runLua("result = nil"); closeLuaState(); // Force garbage collection ASSERT_TRUE(getterData.expired()); ASSERT_TRUE(setterData.expired()); } TEST_F(ClassProperties, StdFunctions_ReadOnly) { using Int = Class; auto sharedGetterData = std::make_shared(); std::weak_ptr getterData = sharedGetterData; // Check __gc meta-method std::function getter = [sharedGetterData](const Int* object) { return object->data; }; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addProperty("data", std::move(getter)) .endClass(); getter = nullptr; sharedGetterData.reset(); ASSERT_FALSE(getterData.expired()); runLua("result = Int (501)"); ASSERT_TRUE(result()["data"].isNumber()); ASSERT_EQ(501, result()["data"].cast()); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result.data = -2"), std::exception); #else ASSERT_FALSE(runLua("result.data = -2")); #endif ASSERT_EQ(501, result()["data"].cast()); runLua("result = nil"); closeLuaState(); // Force garbage collection ASSERT_TRUE(getterData.expired()); } struct ClassStaticFunctions : ClassTests { }; TEST_F(ClassStaticFunctions, Functions) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addStaticFunction("static", &Int::staticFunction) .endClass(); runLua("result = Int.static (Int (35))"); ASSERT_EQ(35, result().data); } TEST_F(ClassStaticFunctions, Functions_Derived) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .addConstructor() .addStaticFunction("static", &Base::staticFunction) .endClass() .deriveClass("Derived") .endClass(); runLua("result = Derived.static (Base ('abc'))"); ASSERT_EQ("abc", result().data); } TEST_F(ClassStaticFunctions, Functions_Overridden) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .addConstructor() .addStaticFunction("staticFunction", &Base::staticFunction) .endClass() .deriveClass("Derived") .addConstructor() .addStaticFunction("staticFunction", &Derived::staticFunction) .endClass(); runLua("result = Base.staticFunction (Base ('abc'))"); ASSERT_EQ("abc", result().data); runLua("result = Derived.staticFunction (Derived (123))"); ASSERT_EQ(123, result().data); } TEST_F(ClassStaticFunctions, StdFunctions) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addStaticFunction("static", std::function(&Int::staticFunction)) .endClass(); runLua("result = Int.static (Int (35))"); ASSERT_EQ(35, result().data); } struct ClassStaticProperties : ClassTests { }; TEST_F(ClassStaticProperties, FieldPointersNonRegistered) { using Int = Class; using UnregisteredInt = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addStaticProperty("staticData", [] { return UnregisteredInt(1); }) .endClass(); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result = Int.staticData"), std::exception); #else ASSERT_FALSE(runLua("result = Int.staticData")); #endif } TEST_F(ClassStaticProperties, FieldPointers) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addStaticProperty("staticData", &Int::staticData, true) .endClass(); Int::staticData = 10; runLua("result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(10, result()); runLua("Int.staticData = 20"); ASSERT_EQ(20, Int::staticData); } TEST_F(ClassStaticProperties, FieldPointers_Const) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addStaticProperty("staticConstData", &Int::staticConstData) .endClass(); runLua("result = Int.staticConstData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(0, result()); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("Int.staticConstData = 20"), std::exception); #else ASSERT_FALSE(runLua("Int.staticConstData = 20")); #endif ASSERT_EQ(0, Int::staticConstData); } TEST_F(ClassStaticProperties, FieldPointers_ReadOnly) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addStaticProperty("staticData", &Int::staticData, false) .endClass(); Int::staticData = 10; runLua("result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(10, result()); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("Int.staticData = 20"), std::exception); #else ASSERT_FALSE(runLua("Int.staticData = 20")); #endif ASSERT_EQ(10, Int::staticData); } TEST_F(ClassStaticProperties, FieldPointers_GetterOnly) { using Int = Class; int value = 10; luabridge::getGlobalNamespace(L) .beginClass("Int") .addStaticProperty("staticData", [&value] { return value; }) .endClass(); runLua("result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(10, result()); ASSERT_EQ(10, value); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("Int.staticData = 20"), std::exception); #else ASSERT_FALSE(runLua("Int.staticData = 20")); #endif runLua("result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(10, result()); ASSERT_EQ(10, value); } TEST_F(ClassStaticProperties, FieldPointers_GetterSetter) { using Int = Class; int value = 10; luabridge::getGlobalNamespace(L) .beginClass("Int") .addStaticProperty("staticData", [&value] { return value; }, [&value](int x) { value = x; }) .endClass(); runLua("result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(10, result()); ASSERT_EQ(10, value); runLua("Int.staticData = 20; result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(20, result()); ASSERT_EQ(20, value); } TEST_F(ClassStaticProperties, FieldPointers_StaticMembers) { using Int = Class; Int::staticData = 10; luabridge::getGlobalNamespace(L) .beginClass("Int") .addStaticProperty("staticData", &Int::getStaticData, &Int::setStaticData) .endClass(); runLua("result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(10, result()); runLua("Int.staticData = 20; result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(20, result()); } TEST_F(ClassStaticProperties, FieldPointers_StaticMembersReadOnly) { using Int = Class; Int::staticData = 10; luabridge::getGlobalNamespace(L) .beginClass("Int") .addStaticProperty("staticData", &Int::getStaticData) .endClass(); runLua("result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(10, result()); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("Int.staticData = 20"), std::exception); #else ASSERT_FALSE(runLua("Int.staticData = 20")); #endif } TEST_F(ClassStaticProperties, FieldPointers_StaticMembersNoexcept) { using Int = Class; Int::staticData = 10; luabridge::getGlobalNamespace(L) .beginClass("Int") .addStaticProperty("staticData", &Int::getStaticDataNoexcept, &Int::setStaticDataNoexcept) .endClass(); runLua("result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(10, result()); runLua("Int.staticData = 20; result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(20, result()); } TEST_F(ClassStaticProperties, FieldPointers_StaticMembersReadonlyNoexcept) { using Int = Class; Int::staticData = 10; luabridge::getGlobalNamespace(L) .beginClass("Int") .addStaticProperty("staticData", &Int::getStaticDataNoexcept) .endClass(); runLua("result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(10, result()); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("Int.staticData = 20"), std::exception); #else ASSERT_FALSE(runLua("Int.staticData = 20")); #endif } TEST_F(ClassStaticProperties, FieldPointers_Derived) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .addStaticProperty("staticData", &Base::staticData, true) .endClass() .deriveClass("Derived") .endClass(); Base::staticData = 1.23f; Derived::staticData = 50; runLua("result = Derived.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(1.23f, result()); runLua("Derived.staticData = -3.14"); ASSERT_EQ(-3.14f, Base::staticData); ASSERT_EQ(50, Derived::staticData); } TEST_F(ClassStaticProperties, FieldPointers_Overridden) { using Base = Class; using Derived = Class; luabridge::getGlobalNamespace(L) .beginClass("Base") .addStaticProperty("staticData", &Base::staticData, true) .endClass() .deriveClass("Derived") .addStaticProperty("staticData", &Derived::staticData, true) .endClass(); Base::staticData = 1.23f; Derived::staticData = 50; runLua("result = Base.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(1.23f, result()); runLua("result = Derived.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(50, result()); runLua("Base.staticData = -3.14"); ASSERT_EQ(-3.14f, Base::staticData); ASSERT_EQ(50, Derived::staticData); runLua("Derived.staticData = 7"); ASSERT_EQ(-3.14f, Base::staticData); ASSERT_EQ(7, Derived::staticData); } TEST_F(ClassStaticProperties, SubsequentRegistration) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .endClass() .beginClass("Int") .addStaticProperty("staticData", &Int::staticData, true) .endClass(); Int::staticData = 10; runLua("result = Int.staticData"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(10, result()); runLua("Int.staticData = 20"); ASSERT_EQ(20, Int::staticData); } struct ClassMetaMethods : ClassTests { }; TEST_F(ClassMetaMethods, __call) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__call", &Int::operator()) .endClass(); runLua("result = Int (1) (-1)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(-1, result().data); runLua("result = Int (2) (5)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(5, result().data); } TEST_F(ClassMetaMethods, __tostring) { typedef Class Int; typedef Class StringClass; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__tostring", &Int::toString) .endClass() .beginClass("String") .addConstructor() .addFunction("__tostring", &StringClass::toString) .endClass(); runLua("result = tostring (Int (-123))"); ASSERT_EQ("-123", result()); #if LUA_VERSION_NUM >= 502 // Lua 5.1 string.format doesn't use __tostring runLua("result = string.format ('%s%s', String ('abc'), Int (-123))"); ASSERT_EQ("abc-123", result()); #endif } TEST_F(ClassMetaMethods, __eq) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__eq", &Int::operator==) .endClass(); runLua("result = Int (1) == Int (1)"); ASSERT_EQ(true, result()); runLua("result = Int (1) ~= Int (1)"); ASSERT_EQ(false, result()); runLua("result = Int (1) == Int (2)"); ASSERT_EQ(false, result()); runLua("result = Int (1) ~= Int (2)"); ASSERT_EQ(true, result()); } TEST_F(ClassMetaMethods, __lt) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__lt", &Int::operator<) .endClass(); runLua("result = Int (1) < Int (1)"); ASSERT_EQ(false, result()); runLua("result = Int (1) < Int (2)"); ASSERT_EQ(true, result()); runLua("result = Int (2) < Int (1)"); ASSERT_EQ(false, result()); } TEST_F(ClassMetaMethods, __le) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__le", &Int::operator<=) .endClass(); runLua("result = Int (1) <= Int (1)"); ASSERT_EQ(true, result()); runLua("result = Int (1) <= Int (2)"); ASSERT_EQ(true, result()); runLua("result = Int (2) <= Int (1)"); ASSERT_EQ(false, result()); } TEST_F(ClassMetaMethods, __add) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__add", &Int::operator+) .endClass(); runLua("result = Int (1) + Int (2)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(3, result().data); } TEST_F(ClassMetaMethods, __sub) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__sub", &Int::operator-) .endClass(); runLua("result = Int (1) - Int (2)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(-1, result().data); } TEST_F(ClassMetaMethods, __mul) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__mul", &Int::operator*) .endClass(); runLua("result = Int (-2) * Int (-5)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(10, result().data); } TEST_F(ClassMetaMethods, __div) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__div", &Int::operator/) .endClass(); runLua("result = Int (10) / Int (2)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(5, result().data); } TEST_F(ClassMetaMethods, __mod) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__mod", &Int::operator%) .endClass(); runLua("result = Int (7) % Int (2)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(1, result().data); } TEST_F(ClassMetaMethods, __pow) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__pow", &Int::operator-) .endClass(); runLua("result = Int (5) ^ Int (2)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(3, result().data); } TEST_F(ClassMetaMethods, __unm) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__unm", &Int::negate) .endClass(); runLua("result = -Int (-3)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(3, result().data); } TEST_F(ClassMetaMethods, __concat) { typedef Class String; luabridge::getGlobalNamespace(L) .beginClass("String") .addConstructor() .addFunction("__concat", &String::operator+) .endClass(); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result = String ('a') + String ('b')"), std::exception); #else ASSERT_FALSE(runLua("result = String ('a') + String ('b')")); #endif runLua("result = String ('ab') .. String ('cd')"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ("abcd", result().data); } TEST_F(ClassMetaMethods, __len) { typedef Class Int; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__len", &Int::len) .endClass(); runLua("result = #Int (1)"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(1, result()); runLua("result = #Int (5)"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(5, result()); } namespace { struct Table { int index(const std::string& key) { #if LUABRIDGE_HAS_EXCEPTIONS return map.at(key); #else auto it = map.find(key); return it != map.end() ? it->second : -1; #endif } void newIndex(const std::string& key, int value) { map.emplace(key, value); } std::map map; }; } // namespace TEST_F(ClassMetaMethods, __index) { luabridge::getGlobalNamespace(L) .beginClass("Table") .addFunction("__index", &Table::index) .endClass(); Table t{{{"a", 1}, {"b", 2}}}; luabridge::setGlobal(L, &t, "t"); runLua("result = t.a"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(1, result()); runLua("result = t.b"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(2, result()); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("result = t.c"), std::exception); // at ("c") throws #else ASSERT_TRUE(runLua("result = t.c")); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(-1, result()); #endif } TEST_F(ClassMetaMethods, __newindex) { luabridge::getGlobalNamespace(L) .beginClass
("Table") .addFunction("__newindex", &Table::newIndex) .endClass(); Table t; luabridge::setGlobal(L, &t, "t"); runLua("t.a = 1; t['b'] = 2"); ASSERT_EQ((std::map{{"a", 1}, {"b", 2}}), t.map); } TEST_F(ClassTests, __tostring) { luabridge::getGlobalNamespace(L) .beginClass
("Table") .endClass(); Table t; luabridge::setGlobal(L, &t, "t"); runLua("result = tostring(t)"); ASSERT_EQ(0, result().find("Table")); } TEST_F(ClassTests, __tostringOverride) { luabridge::getGlobalNamespace(L) .beginClass
("Table") .addFunction("__tostring", [] (const Table* t) { return "StrangeTable"; }) .endClass(); Table t; luabridge::setGlobal(L, &t, "t"); runLua("result = tostring(t)"); ASSERT_EQ(0, result().find("StrangeTable")); } #if LUABRIDGE_HAS_EXCEPTIONS TEST_F(ClassMetaMethods, __gcForbidden) { using Int = Class; ASSERT_THROW(luabridge::getGlobalNamespace(L) .beginClass("Int") .addFunction("__gc", &Int::method) .endClass(), std::exception); } #endif TEST_F(ClassMetaMethods, MetamethodsShouldNotBePartOfClassInstances) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .addFunction("__xyz", [](const Int*) {}) .endClass(); #if LUABRIDGE_HAS_EXCEPTIONS EXPECT_ANY_THROW(runLua("local x = Int(1); x.__gc()")); EXPECT_ANY_THROW(runLua("local x = Int(1); x:__gc()")); EXPECT_ANY_THROW(runLua("local x = Int(1); x.__index()")); EXPECT_ANY_THROW(runLua("local x = Int(1); x:__index()")); EXPECT_ANY_THROW(runLua("local x = Int(1); x.__newindex()")); EXPECT_ANY_THROW(runLua("local x = Int(1); x:__newindex()")); EXPECT_TRUE(runLua("local x = Int(1); result = x.__gc")); EXPECT_TRUE(result().isNil()); EXPECT_TRUE(runLua("local x = Int(1); result = x.__index")); EXPECT_TRUE(result().isNil()); EXPECT_TRUE(runLua("local x = Int(1); result = x.__newindex")); EXPECT_TRUE(result().isNil()); #else EXPECT_FALSE(runLua("local x = Int(1); x.__gc()")); EXPECT_FALSE(runLua("local x = Int(1); x:__gc()")); EXPECT_FALSE(runLua("local x = Int(1); x.__index()")); EXPECT_FALSE(runLua("local x = Int(1); x:__index()")); EXPECT_FALSE(runLua("local x = Int(1); x.__newindex()")); EXPECT_FALSE(runLua("local x = Int(1); x:__newindex()")); EXPECT_TRUE(runLua("local x = Int(1); result = x.__gc")); EXPECT_TRUE(result().isNil()); EXPECT_TRUE(runLua("local x = Int(1); result = x.__index")); EXPECT_TRUE(result().isNil()); EXPECT_TRUE(runLua("local x = Int(1); result = x.__newindex")); EXPECT_TRUE(result().isNil()); #endif EXPECT_TRUE(runLua("local x = Int(1); x:__xyz()")); EXPECT_TRUE(runLua("local x = Int(1); result = x.__xyz")); EXPECT_TRUE(result().isFunction()); } TEST_F(ClassMetaMethods, MetamethodsShouldNotBeWritable) { using Int = Class; luabridge::getGlobalNamespace(L) .beginClass("Int") .addConstructor() .endClass(); #if LUABRIDGE_HAS_EXCEPTIONS EXPECT_ANY_THROW(runLua("local x = Int(1); x.__gc = function() end")); EXPECT_ANY_THROW(runLua("local x = Int(1); x.__index = function() end")); EXPECT_ANY_THROW(runLua("local x = Int(1); x.__newindex = function() end")); #else EXPECT_FALSE(runLua("local x = Int(1); x.__gc = function() end")); EXPECT_FALSE(runLua("local x = Int(1); x.__index = function() end")); EXPECT_FALSE(runLua("local x = Int(1); x.__newindex = function() end")); #endif } namespace { struct StringGetter { std::string str; const char* getString() const { return str.c_str(); } void setString(const char* val) { str = val; } }; } // namespace TEST_F(ClassMetaMethods, ErrorLineWithProperties) { luabridge::getGlobalNamespace(L) .beginClass("StringGetter") .addConstructor() .addFunction("setString", &StringGetter::setString) .addProperty("str", &StringGetter::getString, &StringGetter::setString) .endClass(); #if LUABRIDGE_HAS_EXCEPTIONS try { runLua(R"( local myStringGetter = StringGetter() myStringGetter.str = 12 )"); EXPECT_TRUE(false); } catch (const std::exception& ex) { EXPECT_EQ(0, std::string_view(ex.what()).find("[string \"...\"]:3")); // This is not comparing with std::string_view::npos because we have debug.traceback in the error handler EXPECT_NE(18, std::string_view(ex.what()).find("[string \"...\"]:3: ", 18)); } try { runLua(R"( local myStringGetter = StringGetter() myStringGetter:setString(12) )"); EXPECT_TRUE(false); } catch (const std::exception& ex) { EXPECT_EQ(0, std::string_view(ex.what()).find("[string \"...\"]:3: ")); // This is not comparing with std::string_view::npos because we have debug.traceback in the error handler EXPECT_NE(18, std::string_view(ex.what()).find("[string \"...\"]:3: ", 18)); } #endif { auto [result, errorString] = runLuaCaptureError(R"( local myStringGetter = StringGetter() myStringGetter.str = 12 )"); EXPECT_EQ(0, std::string_view(errorString).find("[string \"...\"]:3: ")); EXPECT_EQ(std::string_view::npos, std::string_view(errorString).find("[string \"...\"]:3: ", 18)); } { auto [result, errorString] = runLuaCaptureError(R"( local myStringGetter = StringGetter() myStringGetter:setString(12) )"); EXPECT_EQ(0, std::string_view(errorString).find("[string \"...\"]:3: ")); EXPECT_EQ(std::string_view::npos, std::string_view(errorString).find("[string \"...\"]:3: ", 18)); } } TEST_F(ClassMetaMethods, SimulateArray) { using ContainerType = std::vector; ContainerType data(1); data[0] = "abcdefg"; luabridge::getGlobalNamespace(L) .beginTable("xyz") .addFunction("a", +[] { return "abcdefg"; }) .addMetaFunction("__index", [&data](luabridge::LuaRef, int index, lua_State* L) { if (index < 0 || index >= static_cast(data.size())) luaL_error(L, "Invalid index access in table %d", index); return data[index]; }) .addMetaFunction("__newindex", [&data](luabridge::LuaRef, int index, luabridge::LuaRef ref, lua_State* L) { if (index < 0) luaL_error(L, "Invalid index access in table %d", index); if (! ref.isString()) luaL_error(L, "Invalid value provided to set table at index %d", index); if (index >= static_cast(data.size())) data.resize(index + 1); data[index] = ref.unsafe_cast(); }) .endTable(); runLua("xyz[0] = '123'; result = xyz[0]"); ASSERT_EQ("123", result()); } TEST_F(ClassTests, EnclosedClassProperties) { typedef Class Inner; typedef Class Outer; luabridge::getGlobalNamespace(L) .beginClass("Inner") .addProperty("data", &Inner::data) .endClass() .beginClass("Outer") .addProperty("data", &Outer::data) .endClass(); Outer outer(Inner(0)); luabridge::setGlobal(L, &outer, "outer"); outer.data.data = 1; runLua("outer.data.data = 10"); ASSERT_EQ(10, outer.data.data); runLua("result = outer.data.data"); ASSERT_EQ(10, result()); } namespace { struct InnerClass { ~InnerClass() { ++destructorCallCount; } static unsigned destructorCallCount; }; unsigned InnerClass::destructorCallCount; struct OuterClass { OuterClass() { #if LUABRIDGE_HAS_EXCEPTIONS throw std::runtime_error("Exception"); #endif } ~OuterClass() { ++destructorCallCount; } static unsigned destructorCallCount; InnerClass inner; }; unsigned OuterClass::destructorCallCount; } // namespace TEST_F(ClassTests, ConstructorWithReferences) { struct InnerClass { InnerClass() = default; }; struct OuterClass { OuterClass(const InnerClass& x) : y(x) {} private: [[maybe_unused]] InnerClass y; }; luabridge::getGlobalNamespace(L) .beginClass("InnerClass") .addConstructor() .endClass() .beginClass("OuterClass") .addConstructor() .endClass(); runLua("x = InnerClass () result = OuterClass (x)"); } TEST_F(ClassTests, DestructorIsNotCalledIfConstructorThrows) { #if LUABRIDGE_HAS_EXCEPTIONS luabridge::getGlobalNamespace(L) .beginClass("OuterClass") .addConstructor() .endClass(); InnerClass::destructorCallCount = 0; OuterClass::destructorCallCount = 0; ASSERT_THROW(runLua("result = OuterClass ()"), std::exception); ASSERT_EQ(1, InnerClass::destructorCallCount); closeLuaState(); // Force garbage collection ASSERT_EQ(1, InnerClass::destructorCallCount); ASSERT_EQ(0, OuterClass::destructorCallCount); #endif } TEST_F(ClassTests, DestructorIsCalledOnce) { luabridge::getGlobalNamespace(L) .beginClass("InnerClass") .addConstructor() .endClass(); InnerClass::destructorCallCount = 0; runLua("result = InnerClass ()"); closeLuaState(); // Force garbage collection ASSERT_EQ(1, InnerClass::destructorCallCount); } TEST_F(ClassTests, ConstructorTakesMoreThanEightArgs) { struct WideClass { WideClass(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10) { a1_ = a1; a2_ = a2; a3_ = a3; a4_ = a4; a5_ = a5; a6_ = a6; a7_ = a7; a8_ = a8; a9_ = a9; a10_ = a10; } int a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_; }; luabridge::getGlobalNamespace(L) .beginClass("WideClass") .addConstructor() .endClass(); runLua("result = WideClass (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(1, result().a1_); ASSERT_EQ(2, result().a2_); ASSERT_EQ(3, result().a3_); ASSERT_EQ(4, result().a4_); ASSERT_EQ(5, result().a5_); ASSERT_EQ(6, result().a6_); ASSERT_EQ(7, result().a7_); ASSERT_EQ(8, result().a8_); ASSERT_EQ(9, result().a9_); ASSERT_EQ(10, result().a10_); } TEST_F(ClassTests, MethodTakesMoreThanEightArgs) { struct WideClass { WideClass() = default; void testLotsOfArgs(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10) { a1_ = a1; a2_ = a2; a3_ = a3; a4_ = a4; a5_ = a5; a6_ = a6; a7_ = a7; a8_ = a8; a9_ = a9; a10_ = a10; } int a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_; }; luabridge::getGlobalNamespace(L) .beginClass("WideClass") .addConstructor() .addFunction("testLotsOfArgs", &WideClass::testLotsOfArgs) .endClass(); runLua("result = WideClass () result:testLotsOfArgs (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(1, result().a1_); ASSERT_EQ(2, result().a2_); ASSERT_EQ(3, result().a3_); ASSERT_EQ(4, result().a4_); ASSERT_EQ(5, result().a5_); ASSERT_EQ(6, result().a6_); ASSERT_EQ(7, result().a7_); ASSERT_EQ(8, result().a8_); ASSERT_EQ(9, result().a9_); ASSERT_EQ(10, result().a10_); } TEST_F(ClassTests, ConstructorFactory) { struct FactoryConstructibleClass { FactoryConstructibleClass() = default; FactoryConstructibleClass(int x) : x_(x) {} int x_ = 33; }; { luabridge::getGlobalNamespace(L) .beginClass("FactoryConstructibleClass") .addConstructor([](void* ptr) { return new(ptr) FactoryConstructibleClass(); }) .addProperty("x", &FactoryConstructibleClass::x_) .endClass(); runLua("obj = FactoryConstructibleClass (); result = obj.x"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(33, result()); } { luabridge::getGlobalNamespace(L) .beginClass("FactoryConstructibleClass2") .addConstructor([](void* ptr, int x) { return new(ptr) FactoryConstructibleClass(x); }) .addProperty("x", &FactoryConstructibleClass::x_) .endClass(); runLua("obj = FactoryConstructibleClass2 (42); result = obj.x"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(42, result()); } { luabridge::getGlobalNamespace(L) .beginClass("FactoryConstructibleClass3") .addConstructor([](void* ptr, lua_State* L) { return new(ptr) FactoryConstructibleClass(static_cast(luaL_checkinteger(L, 2))); }) .addProperty("x", &FactoryConstructibleClass::x_) .endClass(); runLua("obj = FactoryConstructibleClass3 (42); result = obj.x"); ASSERT_TRUE(result().isNumber()); ASSERT_EQ(42, result()); } } namespace { class BaseExampleClass { public: BaseExampleClass() = default; virtual ~BaseExampleClass() = default; virtual void virtualFunction(int arg) = 0; virtual int virtualCFunction(lua_State*) = 0; virtual void virtualFunctionConst(int arg) const = 0; virtual int virtualCFunctionConst(lua_State*) const = 0; void baseFunction(int arg) { baseFunction_ = arg; } int baseCFunction(lua_State*) { return baseCFunction_ = 1; } void baseFunctionConst(int arg) const { baseFunctionConst_ = arg; } int baseCFunctionConst(lua_State*) const { return baseCFunctionConst_ = 1; } int virtualFunction_ = 0; int virtualCFunction_ = 0; mutable int virtualFunctionConst_ = 0; mutable int virtualCFunctionConst_ = 0; int baseFunction_ = 0; int baseCFunction_ = 0; mutable int baseFunctionConst_ = 0; mutable int baseCFunctionConst_ = 0; }; class DerivedExampleClass : public BaseExampleClass { public: DerivedExampleClass() = default; void virtualFunction(int arg) override { virtualFunction_ = arg; } int virtualCFunction(lua_State*) override { return virtualCFunction_ = 1; } void virtualFunctionConst(int arg) const override { virtualFunctionConst_ = arg; } int virtualCFunctionConst(lua_State*) const override { return virtualCFunctionConst_ = 1; } }; } // namespace TEST_F(ClassTests, NonVirtualMethodInBaseClassCannotBeExposed) { luabridge::getGlobalNamespace(L) .beginClass("DerivedExampleClass") .addConstructor() .addFunction("baseFunction", &BaseExampleClass::baseFunction) .addFunction("baseCFunction", &BaseExampleClass::baseCFunction) .addFunction("baseFunctionConst", &BaseExampleClass::baseFunctionConst) .addFunction("baseCFunctionConst", &BaseExampleClass::baseCFunctionConst) .addFunction("virtualFunction", &DerivedExampleClass::virtualFunction) .addFunction("virtualCFunction", &DerivedExampleClass::virtualCFunction) .addFunction("virtualFunctionConst", &DerivedExampleClass::virtualFunctionConst) .addFunction("virtualCFunctionConst", &DerivedExampleClass::virtualCFunctionConst) .endClass(); runLua(R"( result = DerivedExampleClass () result:baseFunction(1) result:baseCFunction() result:baseFunctionConst(1) result:baseCFunctionConst() result:virtualFunction(1) result:virtualCFunction() result:virtualFunctionConst(1) result:virtualCFunctionConst() )"); ASSERT_TRUE(result().isUserdata()); ASSERT_EQ(1, result().baseFunction_); ASSERT_EQ(1, result().baseCFunction_); ASSERT_EQ(1, result().baseFunctionConst_); ASSERT_EQ(1, result().baseCFunctionConst_); ASSERT_EQ(1, result().virtualFunction_); ASSERT_EQ(1, result().virtualCFunction_); ASSERT_EQ(1, result().virtualFunctionConst_); ASSERT_EQ(1, result().virtualCFunctionConst_); } TEST_F(ClassTests, NilCanBeConvertedToNullptrButNotToReference) { struct X {}; bool result = false, resultConst = false, called = false; luabridge::getGlobalNamespace(L) .addFunction("TakeNullptr", [&result](X* iAmNullptr) { result = (iAmNullptr == nullptr); }) .addFunction("TakeConstNullptr", [&resultConst](const X* iAmNullptr) { resultConst = (iAmNullptr == nullptr); }) .addFunction("TakeReference", [&called](const X& iAmNullptr) { called = true; }) .beginClass("X") .endClass(); runLua("TakeNullptr(nil)"); EXPECT_TRUE(result); runLua("TakeConstNullptr(nil)"); EXPECT_TRUE(resultConst); #if LUABRIDGE_HAS_EXCEPTIONS EXPECT_THROW(runLua("TakeReference(nil)"), std::exception); #else EXPECT_FALSE(runLua("TakeReference(nil)")); #endif EXPECT_FALSE(called); } namespace { template struct alignas(Alignment) Vec { public: Vec(double InA, double InB, double InC, double InD) { X = InA; Y = InB; Z = InC; W = InD; } public: double X; double Y; double Z; double W; bool isAligned() const { return luabridge::is_aligned(reinterpret_cast(this)); } }; } // namespace TEST_F(ClassTests, OveralignedClasses) { luabridge::getGlobalNamespace(L) .beginClass>("Vec8") .addConstructor() .addFunction("checkIsAligned", &Vec<8>::isAligned) .endClass() .beginClass>("Vec16") .addConstructor() .addFunction("checkIsAligned", &Vec<16>::isAligned) .endClass() .beginClass>("Vec32") .addConstructor() .addFunction("checkIsAligned", &Vec<32>::isAligned) .endClass(); runLua("result = Vec8(3.0, 2.0, 1.0, 0.5):checkIsAligned()"); EXPECT_TRUE(result()); runLua("result = Vec16(3.0, 2.0, 1.0, 0.5):checkIsAligned()"); EXPECT_TRUE(result()); runLua("result = Vec32(3.0, 2.0, 1.0, 0.5):checkIsAligned()"); EXPECT_TRUE(result()); } namespace { struct XYZ { int x = 0; }; struct ABC { float y = 0.0f; }; } // namespace TEST_F(ClassTests, WrongThrowBadArgObjectDescription) { luabridge::getGlobalNamespace(L) .beginClass("XYZ") .endClass() .beginClass("ABC") .addConstructor() .endClass() .addFunction("textXYZ", [](int, float, const XYZ&) {}) .addFunction("textSingleXYZ", [](const XYZ&) {}); #if LUABRIDGE_HAS_EXCEPTIONS #if 0 // These seems to fail coverage collection of .gcda try { runLua("textSingleXYZ()"); EXPECT_TRUE(false); } catch (const std::exception& ex) { EXPECT_NE(std::string::npos, std::string(ex.what()).find("got no value")); } try { runLua("textXYZ(1, 1.0)"); EXPECT_TRUE(false); } catch (const std::exception& ex) { EXPECT_NE(std::string::npos, std::string(ex.what()).find("got no value")); } try { runLua("textXYZ(1, 1.0, 1)"); EXPECT_TRUE(false); } catch (const std::exception& ex) { EXPECT_NE(std::string::npos, std::string(ex.what()).find("got number")); } try { runLua("textXYZ(1, 1.0, '1')"); EXPECT_TRUE(false); } catch (const std::exception& ex) { EXPECT_NE(std::string::npos, std::string(ex.what()).find("got string")); } try { runLua("textXYZ(1, 1.0, ABC())"); EXPECT_TRUE(false); } catch (const std::exception& ex) { EXPECT_NE(std::string::npos, std::string(ex.what()).find("got ABC")); } #endif #else { auto [result, errorMessage] = runLuaCaptureError("textSingleXYZ()"); ASSERT_FALSE(result); EXPECT_NE(std::string::npos, errorMessage.find("got no value")); } { auto [result, errorMessage] = runLuaCaptureError("textXYZ(1, 1.0)"); ASSERT_FALSE(result); EXPECT_NE(std::string::npos, errorMessage.find("got no value")); } { auto [result, errorMessage] = runLuaCaptureError("textXYZ(1, 1.0, 1)"); ASSERT_FALSE(result); EXPECT_NE(std::string::npos, errorMessage.find("got number")); } { auto [result, errorMessage] = runLuaCaptureError("textXYZ(1, 1.0, '1')"); ASSERT_FALSE(result); EXPECT_NE(std::string::npos, errorMessage.find("got string")); } { auto [result, errorMessage] = runLuaCaptureError("textXYZ(1, 1.0, ABC())"); ASSERT_FALSE(result); EXPECT_NE(std::string::npos, errorMessage.find("got ABC")); } #endif } namespace { struct Node { int data = 0; Node* next = nullptr; Node* prev = nullptr; explicit Node(int value) : data(value) { } int val() const { return data; } Node* next_node() const { return next; } }; class DoublyLinkedList { public: DoublyLinkedList(int numToAdd = 0) { for (int value = 1; value <= numToAdd; value++) addBack(value); } ~DoublyLinkedList() { while (head) removeBack(); } void addBack(int value) { Node* newNode = new Node(value); if (tail == nullptr) { head = newNode; tail = newNode; } else { newNode->prev = tail; tail->next = newNode; tail = newNode; } } void removeBack() { if (tail == nullptr) return; Node* temp = tail; tail = tail->prev; if (tail != nullptr) tail->next = nullptr; else head = nullptr; delete temp; } Node* first() const { return head; } private: Node* head = nullptr; Node* tail = nullptr; }; class foo { public: foo(int size = 5000) : list(size) {} Node* first() const { return list.first(); } Node* next(Node* curr) const { return curr->next_node(); } private: DoublyLinkedList list; }; class bar { public: bar(foo* f) : foo_(f) {} Node* first() const { return foo_->first(); } Node* next(Node* curr) const { return foo_->next(curr); } private: foo* foo_; }; } // namespace TEST_F(ClassTests, BugWithPlacementConstructor) { luabridge::getGlobalNamespace(L) .beginNamespace("foobar") .beginClass("Node") .addFunction("val", &Node::val) .endClass() .beginClass("foo") .addConstructor([](void* p, int size) { return new(p) foo(size); }) .addFunction("first", &foo::first) .addFunction("next", &foo::next) .endClass() .beginClass("bar") .addConstructor() .addFunction("first", &bar::first) .addFunction("next", &bar::next) .endClass() .endNamespace(); runLua(R"( local foo = foobar.foo(5000) local bar = foobar.bar(foo) local next = bar:first() while next do next = bar:next(next) end )"); SUCCEED(); } TEST_F(ClassTests, BugWithFactoryConstructor) { luabridge::getGlobalNamespace(L) .beginNamespace("foobar") .beginClass("Node") .addFunction("val", &Node::val) .endClass() .beginClass("foo") .addFactory( +[]() -> foo* { return new foo(5000); }, +[](foo* x) { delete x; }) .addFunction("first", &foo::first) .addFunction("next", &foo::next) .endClass() .beginClass("bar") .addConstructor() .addFunction("first", &bar::first) .addFunction("next", &bar::next) .endClass() .endNamespace(); runLua(R"( local foo = foobar.foo() local bar = foobar.bar(foo) local next = bar:first() while next do next = bar:next(next) end )"); SUCCEED(); }