// https://github.com/kunitoki/LuaBridge3 // Copyright 2022, kunitoki // Copyright 2022, Stefan Frings // SPDX-License-Identifier: MIT #include "TestBase.h" namespace { class TestClass { public: explicit inline TestClass(int i) : m_i(i) {} inline int get() const { return m_i; } private: int m_i; }; int testFunctionObject(TestClass object) { return object.get(); } int testFunctionObjectConst(const TestClass object) { return object.get(); } int testFunctionRef(TestClass& object) { return object.get(); } int testFunctionRefConst(const TestClass& object) { return object.get(); } } // namespace struct UserDataTest : TestBase { void SetUp() override { TestBase::SetUp(); luabridge::getGlobalNamespace(L) .beginClass("TestClass") .addConstructor() .endClass() .addFunction("testFunctionObject", testFunctionObject) .addFunction("testFunctionObjectConst", testFunctionObjectConst) .addFunction("testFunctionRef", testFunctionRef) .addFunction("testFunctionRefConst", testFunctionRefConst); } }; TEST_F(UserDataTest, Object) { runLua("object = TestClass(123); result = testFunctionObject(object)"); ASSERT_EQ(result(), 123); } TEST_F(UserDataTest, ObjectConst) { runLua("object = TestClass(123); result = testFunctionObjectConst(object)"); ASSERT_EQ(result(), 123); } TEST_F(UserDataTest, Ref) { runLua("object = TestClass(123); result = testFunctionRef(object)"); ASSERT_EQ(result(), 123); } TEST_F(UserDataTest, RefConst) { runLua("object = TestClass(123); result = testFunctionRefConst(object)"); ASSERT_EQ(result(), 123); } TEST_F(UserDataTest, FailNumberObject) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("testFunctionObject(132)"), std::runtime_error); #else EXPECT_FALSE(runLua("testFunctionObject(132)")); #endif } TEST_F(UserDataTest, FailNumberObjectConst) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("testFunctionObjectConst(132)"), std::runtime_error); #else EXPECT_FALSE(runLua("testFunctionObjectConst(132)")); #endif } TEST_F(UserDataTest, FailNumberRef) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("testFunctionRef(132)"), std::runtime_error); #else EXPECT_FALSE(runLua("testFunctionRef(132)")); #endif } TEST_F(UserDataTest, FailNumberRefConst) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("testFunctionRefConst(132)"), std::runtime_error); #else EXPECT_FALSE(runLua("testFunctionRefConst(132)")); #endif } TEST_F(UserDataTest, FailNilObject) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("testFunctionObject(nil)"), std::runtime_error); #else EXPECT_FALSE(runLua("testFunctionObject(nil)")); #endif } TEST_F(UserDataTest, FailNilObjectConst) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("testFunctionObjectConst(nil)"), std::runtime_error); #else EXPECT_FALSE(runLua("testFunctionObjectConst(nil)")); #endif } TEST_F(UserDataTest, FailNilRef) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("testFunctionRef(nil)"), std::runtime_error); #else EXPECT_FALSE(runLua("testFunctionRef(nil)")); #endif } TEST_F(UserDataTest, FailNilRefConst) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("testFunctionRefConst(nil)"), std::runtime_error); #else EXPECT_FALSE(runLua("testFunctionRefConst(nil)")); #endif } //================================================================================================= // New Test Suite for TypeResult and getNilBadArgError Error Handling //================================================================================================= namespace { class ClassWithProperties { public: ClassWithProperties() : m_value(42), m_readOnly(100) {} int getValue() const { return m_value; } void setValue(int v) { m_value = v; } int getReadOnly() const { return m_readOnly; } int callSomething(int x) { return x * 2; } const int& getValueRef() const { return m_value; } private: int m_value; const int m_readOnly; }; } // namespace struct TypeResultErrorHandlingTest : TestBase { void SetUp() override { TestBase::SetUp(); luabridge::getGlobalNamespace(L) .beginClass("ClassWithProperties") .addConstructor() .addProperty("value", &ClassWithProperties::getValue, &ClassWithProperties::setValue) .addFunction("callSomething", &ClassWithProperties::callSomething) .endClass() .addFunction("getPropertyRef", [](const ClassWithProperties& obj) { return obj.getValue(); }); } }; // Test 1: Verify error message when nil is passed to reference parameters TEST_F(TypeResultErrorHandlingTest, NilToReferenceParameterError) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("getPropertyRef(nil)"), std::runtime_error); #else auto [result, errorMsg] = runLuaCaptureError("getPropertyRef(nil)"); ASSERT_FALSE(result); // Should mention "no value" in error message EXPECT_TRUE(errorMsg.find("no value") != std::string::npos || errorMsg.find("ClassWithProperties") != std::string::npos); #endif } // Test 2: Verify property getter error message with nil TEST_F(TypeResultErrorHandlingTest, PropertyGetterWithNil) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("obj = nil; v = obj.value"), std::runtime_error); #else auto [result, errorMsg] = runLuaCaptureError("obj = nil; v = obj.value"); ASSERT_FALSE(result); #endif } // Test 3: Verify property setter error message with nil TEST_F(TypeResultErrorHandlingTest, PropertySetterWithNil) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("obj = nil; obj.value = 123"), std::runtime_error); #else auto [result, errorMsg] = runLuaCaptureError("obj = nil; obj.value = 123"); ASSERT_FALSE(result); #endif } // Test 4: Verify member function error with nil TEST_F(TypeResultErrorHandlingTest, MemberFunctionWithNil) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("obj = nil; result = obj:callSomething(5)"), std::runtime_error); #else auto [result, errorMsg] = runLuaCaptureError("obj = nil; result = obj:callSomething(5)"); ASSERT_FALSE(result); #endif } // Test 5: Verify correct behavior with valid object TEST_F(TypeResultErrorHandlingTest, ValidObjectPropertyAccess) { runLua("obj = ClassWithProperties(); result = obj.value"); ASSERT_EQ(result(), 42); } // Test 6: Verify correct behavior with property setter TEST_F(TypeResultErrorHandlingTest, ValidObjectPropertySetter) { runLua("obj = ClassWithProperties(); obj.value = 99; result = obj.value"); ASSERT_EQ(result(), 99); } // Test 7: Verify correct behavior with member function TEST_F(TypeResultErrorHandlingTest, ValidObjectMemberFunction) { runLua("obj = ClassWithProperties(); result = obj:callSomething(21)"); ASSERT_EQ(result(), 42); } // Test 8: Wrong type passed to member function TEST_F(TypeResultErrorHandlingTest, WrongTypeToMemberFunction) { #if LUABRIDGE_HAS_EXCEPTIONS runLua("obj = ClassWithProperties()"); // Setup valid object ASSERT_THROW(runLua("result = obj:callSomething('string')"), std::runtime_error); #else runLua("obj = ClassWithProperties()"); auto [result, errorMsg] = runLuaCaptureError("result = obj:callSomething('string')"); ASSERT_FALSE(result); #endif } // Test 9: Test error message quality for unregistered class TEST_F(TypeResultErrorHandlingTest, UnregisteredClassError) { #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("local ud = debug.setlocal(1, nil, nil); " "getPropertyRef(ud)"), std::runtime_error); #else // This is harder to test without manually constructing an unregistered userdata #endif } // Test 10: Nil handling consistency across different property access patterns TEST_F(TypeResultErrorHandlingTest, PropertyAccessConsistency) { runLua("obj = ClassWithProperties(); " "v1 = obj.value; " "result = (v1 == 42)"); ASSERT_EQ(result(), true); } // Test 11: Multiple operations in sequence to verify stack management TEST_F(TypeResultErrorHandlingTest, SequentialPropertyAccess) { runLua("obj = ClassWithProperties(); " "v1 = obj.value; " "obj.value = 50; " "v2 = obj.value; " "result = v2"); ASSERT_EQ(result(), 50); } // Test 12: Verify error when passing wrong object type to function expecting specific class TEST_F(TypeResultErrorHandlingTest, WrongClassTypeError) { runLua("obj = ClassWithProperties()"); #if LUABRIDGE_HAS_EXCEPTIONS ASSERT_THROW(runLua("otherObj = TestClass(10)"), std::runtime_error); #else // This test mainly checks that registering TestClass succeeds EXPECT_TRUE(true); #endif }