// https://github.com/kunitoki/LuaBridge3 // Copyright 2021, Stefan Frings // Copyright 2020, Lucio Asnaghi // SPDX-License-Identifier: MIT #include "TestBase.h" #include "TestTypes.h" #include namespace { template std::string toLuaSrcString(const T& value) { return std::to_string(value); } template<> std::string toLuaSrcString(const bool& value) { return value ? "true" : "false"; } template<> std::string toLuaSrcString(const char& value) { return "'" + std::string(&value, 1) + "'"; } template<> std::string toLuaSrcString(const char* const& value) { return "'" + std::string(value) + "'"; } template<> std::string toLuaSrcString(const std::string& value) { return "'" + value + "'"; } template<> std::string toLuaSrcString(const std::string_view& value) { return toLuaSrcString(std::string(value)); } template std::optional optCast(luabridge::LuaRef const& ref) { // NOTE cast to std::optional: https://stackoverflow.com/a/45865802 return ref.unsafe_cast>(); } template void checkEquals(T expected, T actual) { using U = std::decay_t; if constexpr (std::is_same_v) { ASSERT_FLOAT_EQ(expected, actual); } else if constexpr (std::is_same_v || std::is_same_v) { ASSERT_DOUBLE_EQ(expected, actual); } else if constexpr (std::is_same_v) { ASSERT_STREQ(expected, actual); } else { ASSERT_EQ(expected, actual); } } } // namespace template struct OptionalTest : TestBase { }; TYPED_TEST_SUITE_P(OptionalTest); TYPED_TEST_P(OptionalTest, LuaRefPresent) { using Traits = TypeTraits; for (TypeParam const& value : Traits::values()) { std::string const luaSrc = "result = " + toLuaSrcString(value); SCOPED_TRACE(luaSrc); this->runLua(luaSrc); std::optional const actual = optCast(this->result()); ASSERT_TRUE(actual.has_value()); checkEquals(value, actual.value()); } } TYPED_TEST_P(OptionalTest, LuaRefNotPresent) { this->runLua("result = nil"); std::optional const actual = optCast(this->result()); ASSERT_FALSE(actual.has_value()); } TYPED_TEST_P(OptionalTest, LuaRefIsInstancePresent) { using Traits = TypeTraits; for (TypeParam const& value : Traits::values()) { std::string const luaSrc = "result = " + toLuaSrcString(value); SCOPED_TRACE(luaSrc); this->runLua(luaSrc); luabridge::LuaRef const actualRef = this->result(); ASSERT_TRUE(actualRef.isInstance>()); // if isInstance returns true a cast without issues is possible [[maybe_unused]] std::optional const actual = optCast(actualRef); } } TYPED_TEST_P(OptionalTest, LuaRefIsInstancePresentWrongType) { this->runLua("function func() end; result = func"); luabridge::LuaRef const actualRef = this->result(); ASSERT_FALSE(actualRef.isInstance>()); } TYPED_TEST_P(OptionalTest, LuaRefIsInstanceNotPresent) { this->runLua("result = nil"); luabridge::LuaRef const actualRef = this->result(); ASSERT_TRUE(actualRef.isInstance>()); // if isInstance returns true a cast without issues is possible [[maybe_unused]] std::optional const actual = optCast(actualRef); } REGISTER_TYPED_TEST_SUITE_P(OptionalTest, LuaRefPresent, LuaRefNotPresent, LuaRefIsInstancePresent, LuaRefIsInstancePresentWrongType, LuaRefIsInstanceNotPresent); INSTANTIATE_TYPED_TEST_SUITE_P(OptionalTest, OptionalTest, TestTypes); namespace { struct Data { explicit Data(int i) : i(i) {} int i; }; bool operator==(Data const& lhs, Data const& rhs) { return lhs.i == rhs.i; } template bool operator==(std::optional const& lhs, std::optional const& rhs) { if (lhs.has_value() != rhs.has_value()) { return false; } if (lhs.has_value()) { assert(rhs.has_value()); return lhs.value() == rhs.value(); } assert(!lhs.has_value()); assert(!rhs.has_value()); return true; } std::optional processValue(std::optional const& data) { return data; } std::optional processPointer(std::optional const& data) { std::optional result; if (data) { result = **data; } return result; } } // namespace struct OptionalTests : TestBase { }; template void testPassFromLua(OptionalTests const& fixture, std::string const& functionName, std::string const& valueString, std::optional const expected) { fixture.resetResult(); std::string const luaSrc = "result = " + functionName + "(" + valueString + ")"; SCOPED_TRACE(luaSrc); fixture.runLua(luaSrc); std::optional const actual = optCast(fixture.result()); ASSERT_EQ(expected, actual); } TEST_F(OptionalTests, PassFromLua) { luabridge::getGlobalNamespace(L) .beginClass("Data") .addConstructor() .endClass() .addFunction("processValue", &processValue) .addFunction("processPointer", &processPointer); testPassFromLua(*this, "processValue", "Data(-1)", Data(-1)); testPassFromLua(*this, "processValue", "Data(2)", Data(2)); testPassFromLua(*this, "processValue", "nil", std::nullopt); testPassFromLua(*this, "processPointer", "Data(-1)", Data(-1)); testPassFromLua(*this, "processPointer", "Data(2)", Data(2)); testPassFromLua(*this, "processPointer", "nil", std::nullopt); } TEST_F(OptionalTests, PassToFunction) { runLua("function foo (opt) " " result = opt " "end"); auto foo = luabridge::getGlobal(L, "foo"); { resetResult(); std::optional lvalue{ 10 }; foo(lvalue); EXPECT_FALSE(result().isNil()); EXPECT_EQ(lvalue, result>()); resetResult(); const std::optional constLvalue = lvalue; foo(constLvalue); EXPECT_FALSE(result().isNil()); EXPECT_EQ(lvalue, result>()); } { resetResult(); std::optional lvalue; foo(lvalue); EXPECT_TRUE(result().isNil()); EXPECT_FALSE(result>()); resetResult(); const std::optional constLvalue = lvalue; foo(constLvalue); EXPECT_TRUE(result().isNil()); EXPECT_FALSE(result>()); } } TEST_F(OptionalTests, FromCppApi) { struct OptionalClass { OptionalClass() = default; void testOptionalAsArg(std::optional v) { x = v; } std::optional testOptionalAsReturn() { return "abcdef"; } std::optional x; }; luabridge::getGlobalNamespace(L) .beginClass("OptionalClass") .addConstructor() .addFunction("testOptionalAsArg", &OptionalClass::testOptionalAsArg) .addFunction("testOptionalAsReturn", &OptionalClass::testOptionalAsReturn) .endClass(); resetResult(); runLua("result = OptionalClass () result:testOptionalAsArg (1337)"); EXPECT_TRUE(result().isUserdata()); EXPECT_EQ(1337, *result().x); resetResult(); runLua("x = OptionalClass () result = x:testOptionalAsReturn ()"); EXPECT_FALSE(result().isNil()); EXPECT_EQ("abcdef", *result>()); } TEST_F(OptionalTests, MissingOptionalArgument) { luabridge::getGlobalNamespace(L) .addFunction("testOptionalAsArg", [](const std::optional& v) { return v.has_value(); }); resetResult(); runLua("result = testOptionalAsArg()"); EXPECT_TRUE(result().isBool()); EXPECT_FALSE(result()); } #if !LUABRIDGE_HAS_EXCEPTIONS TEST_F(OptionalTests, PushUnregisteredWithNoExceptionsShouldFailButRestoreStack) { class Unregistered {}; const int initialStackSize = lua_gettop(L); lua_pushnumber(L, 1); EXPECT_EQ(1, lua_gettop(L) - initialStackSize); std::optional v = Unregistered{}; auto result = luabridge::Stack::push(L, v); EXPECT_FALSE(result); EXPECT_EQ(1, lua_gettop(L) - initialStackSize); lua_pop(L, 1); EXPECT_EQ(0, lua_gettop(L) - initialStackSize); } #endif