Files
dl_old/third/LuaBridge3/Tests/Source/IssueTests.cpp
T
2024-12-25 20:57:42 +08:00

269 lines
5.9 KiB
C++

// https://github.com/kunitoki/LuaBridge3
// Copyright 2019, Dmitry Tarakanov
// SPDX-License-Identifier: MIT
#include "TestBase.h"
struct IssueTests : TestBase
{
};
namespace {
struct AbstractClass
{
virtual int sum(int a, int b) = 0;
};
struct ConcreteClass : AbstractClass
{
int sum(int a, int b) override { return a + b; }
static AbstractClass& get()
{
static ConcreteClass instance;
return instance;
}
};
} // namespace
TEST_F(IssueTests, Issue87)
{
luabridge::getGlobalNamespace(L)
.beginClass<AbstractClass>("Class")
.addFunction("sum", &AbstractClass::sum)
.endClass()
.addFunction("getAbstractClass", &ConcreteClass::get);
runLua("result = getAbstractClass ():sum (1, 2)");
ASSERT_TRUE(result().isNumber());
ASSERT_EQ(3, result<int>());
}
TEST_F(IssueTests, Issue121)
{
runLua(R"(
first = {
second = {
actual = "data"
}
}
)");
auto first = luabridge::getGlobal(L, "first");
ASSERT_TRUE(first.isTable());
ASSERT_EQ(0, first.length());
ASSERT_TRUE(first["second"].isTable());
ASSERT_EQ(0, first["second"].length());
}
namespace {
void pushArgs(lua_State*)
{
}
template<class Arg, class... Args>
void pushArgs(lua_State* L, Arg arg, Args... args)
{
[[maybe_unused]] auto result = luabridge::Stack<Arg>::push(L, arg);
pushArgs(L, args...);
}
template<class... Args>
std::vector<luabridge::LuaRef> callFunction(const luabridge::LuaRef& function, Args... args)
{
assert(function.isFunction());
lua_State* L = function.state();
int originalTop = lua_gettop(L);
function.push(L);
pushArgs(L, args...);
luabridge::pcall(L, sizeof...(args), LUA_MULTRET);
std::vector<luabridge::LuaRef> results;
int top = lua_gettop(L);
results.reserve(top - originalTop);
for (int i = originalTop + 1; i <= top; ++i)
{
results.push_back(luabridge::LuaRef::fromStack(L, i));
}
return results;
}
} // namespace
TEST_F(IssueTests, Issue160)
{
runLua("function isConnected (arg1, arg2) "
" return 1, 'srvname', 'ip:10.0.0.1', arg1, arg2 "
"end");
luabridge::LuaRef f_isConnected = luabridge::getGlobal(L, "isConnected");
auto v = callFunction(f_isConnected, 2, "abc");
ASSERT_EQ(5u, v.size());
ASSERT_EQ(1, v[0].unsafe_cast<int>());
ASSERT_EQ("srvname", v[1].unsafe_cast<std::string>());
ASSERT_EQ("ip:10.0.0.1", v[2].unsafe_cast<std::string>());
ASSERT_EQ(2, v[3].unsafe_cast<int>());
ASSERT_EQ("abc", v[4].unsafe_cast<std::string>());
}
namespace {
struct Vector
{
float getX() const { return x; }
float x = 0;
};
struct WideVector : Vector
{
WideVector(float, float, float, float w) { x = w; }
};
} // namespace
TEST_F(IssueTests, Issue178)
{
luabridge::getGlobalNamespace(L)
.beginClass<WideVector>("WideVector")
.addConstructor<void (*)(float, float, float, float)>()
.addProperty("x", &Vector::x, true)
.endClass();
runLua("result = WideVector (0, 1, 2, 3).x");
ASSERT_TRUE(result().isNumber());
ASSERT_EQ(3.f, result<float>());
}
namespace {
enum class MyEnum
{
VALUE0,
VALUE1,
};
template <class T>
struct EnumWrapper
{
static auto push(lua_State* L, T value) -> std::enable_if_t<std::is_enum_v<T>, luabridge::Result>
{
lua_pushnumber(L, static_cast<std::size_t>(value));
return {};
}
static auto get(lua_State* L, int index) -> std::enable_if_t<std::is_enum_v<T>, luabridge::TypeResult<T>>
{
return static_cast<T>(lua_tointeger(L, index));
}
};
} // namespace
namespace luabridge {
template<>
struct Stack<MyEnum> : EnumWrapper<MyEnum>
{
};
} // namespace luabridge
TEST_F(IssueTests, Issue127)
{
runLua("result = 1");
ASSERT_EQ(MyEnum::VALUE1, result<MyEnum>());
}
TEST_F(IssueTests, Issue8)
{
runLua(R"(function HelloWorld(args) return args end)");
luabridge::LuaRef func = luabridge::getGlobal(L, "HelloWorld");
{
auto result = func("helloworld");
ASSERT_EQ(1, result.size());
ASSERT_STREQ("helloworld", result[0].unsafe_cast<const char*>());
}
{
const char* str = "helloworld";
auto result = func(str);
ASSERT_EQ(1, result.size());
ASSERT_STREQ("helloworld", result[0].unsafe_cast<const char*>());
}
{
std::string str = "helloworld";
auto result = func(std::move(str));
ASSERT_EQ(1, result.size());
ASSERT_STREQ("helloworld", result[0].unsafe_cast<const char*>());
}
}
namespace {
struct SomeClass
{
luabridge::LuaRef override_;
SomeClass(lua_State* L)
: override_(luabridge::main_thread(L))
{
}
void SomeMember()
{
if (override_.isFunction())
override_();
}
};
} // namespace
TEST_F(IssueTests, IssueMainThread)
{
luabridge::getGlobalNamespace(L)
.beginClass<SomeClass>("SomeClass")
.addConstructor<void (*)(lua_State*)>()
.addFunction("SomeMember", &SomeClass::SomeMember)
.addProperty("SomeMemberOverride", &SomeClass::override_)
.endClass();
const char* source = R"(
function test()
c:SomeMember()
c.SomeMemberOverride = MyHandler
c:SomeMember()
--This is pretty cool too!
c:SomeMemberOverride()
--Revert to C++ version
c.SomeMemberOverride = nil
c:SomeMember()
return
end
function MyHandler()
print 'SomeMember Overidden by Lua'
end
)";
const char* threadSource = "c = SomeClass()";
lua_State* thread = lua_newthread(L);
if (!runLua(threadSource, thread))
{
EXPECT_TRUE(false);
return;
}
lua_pop(L, 1);
lua_gc(L, LUA_GCCOLLECT, 0);
if (!runLua(source, L))
{
EXPECT_TRUE(false);
return;
}
luabridge::LuaRef test = luabridge::getGlobal(L, "test");
test();
}