711 lines
20 KiB
C++
Vendored
711 lines
20 KiB
C++
Vendored
// https://github.com/kunitoki/LuaBridge3
|
|
// Copyright 2020, Lucio Asnaghi
|
|
// Copyright 2019, Dmitry Tarakanov
|
|
// Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
|
|
// Copyright 2007, Nathan Reed
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
#include "TestBase.h"
|
|
|
|
#include <sstream>
|
|
|
|
struct LuaRefTests : TestBase
|
|
{
|
|
};
|
|
|
|
TEST_F(LuaRefTests, TypeCheck)
|
|
{
|
|
{
|
|
luabridge::LuaRef none(L);
|
|
EXPECT_FALSE(none.isValid());
|
|
EXPECT_TRUE(none.isNil());
|
|
std::stringstream ss;
|
|
none.print(ss);
|
|
EXPECT_EQ("nil", ss.str());
|
|
EXPECT_NE(0u, none.hash());
|
|
}
|
|
|
|
{
|
|
runLua("result = nil");
|
|
EXPECT_EQ(LUA_TNIL, result().type());
|
|
EXPECT_TRUE(result().isValid());
|
|
EXPECT_TRUE(result().isNil());
|
|
std::stringstream ss;
|
|
result().print(ss);
|
|
EXPECT_EQ("nil", ss.str());
|
|
EXPECT_NE(0u, result().hash());
|
|
}
|
|
|
|
{
|
|
runLua("result = true");
|
|
EXPECT_EQ(LUA_TBOOLEAN, result().type());
|
|
EXPECT_TRUE(result().isValid());
|
|
EXPECT_TRUE(result().isBool());
|
|
std::stringstream ss;
|
|
result().print(ss);
|
|
EXPECT_EQ("true", ss.str());
|
|
EXPECT_NE(0u, result().hash());
|
|
}
|
|
|
|
{
|
|
runLua("result = 11");
|
|
EXPECT_EQ(LUA_TNUMBER, result().type());
|
|
EXPECT_TRUE(result().isValid());
|
|
EXPECT_TRUE(result().isNumber());
|
|
std::stringstream ss;
|
|
result().print(ss);
|
|
EXPECT_EQ("11", ss.str());
|
|
EXPECT_NE(0u, result().hash());
|
|
}
|
|
|
|
{
|
|
runLua("result = 3.1");
|
|
EXPECT_EQ(LUA_TNUMBER, result().type());
|
|
EXPECT_TRUE(result().isValid());
|
|
EXPECT_TRUE(result().isNumber());
|
|
std::stringstream ss;
|
|
result().print(ss);
|
|
EXPECT_EQ("3.1", ss.str());
|
|
EXPECT_NE(0u, result().hash());
|
|
}
|
|
|
|
{
|
|
runLua("result = 'abcd'");
|
|
EXPECT_EQ(LUA_TSTRING, result().type());
|
|
EXPECT_TRUE(result().isValid());
|
|
EXPECT_TRUE(result().isString());
|
|
std::stringstream ss;
|
|
result().print(ss);
|
|
EXPECT_EQ("\"abcd\"", ss.str());
|
|
EXPECT_NE(0u, result().hash());
|
|
}
|
|
|
|
{
|
|
runLua("result = {}");
|
|
EXPECT_EQ(LUA_TTABLE, result().type());
|
|
EXPECT_TRUE(result().isValid());
|
|
EXPECT_TRUE(result().isTable());
|
|
std::stringstream ss;
|
|
result().print(ss);
|
|
EXPECT_NE(std::string::npos, ss.str().find("table:"));
|
|
EXPECT_NE(0u, result().hash());
|
|
}
|
|
|
|
{
|
|
runLua("result = function () end");
|
|
EXPECT_EQ(LUA_TFUNCTION, result().type());
|
|
EXPECT_TRUE(result().isValid());
|
|
EXPECT_TRUE(result().isFunction());
|
|
EXPECT_TRUE(result().isCallable());
|
|
std::stringstream ss;
|
|
result().print(ss);
|
|
EXPECT_NE(std::string::npos, ss.str().find("function:"));
|
|
EXPECT_NE(0u, result().hash());
|
|
}
|
|
|
|
{
|
|
void* x = nullptr;
|
|
lua_pushlightuserdata(L, x);
|
|
auto result = luabridge::LuaRef::fromStack(L);
|
|
EXPECT_EQ(LUA_TLIGHTUSERDATA, result.type());
|
|
EXPECT_TRUE(result.isValid());
|
|
EXPECT_TRUE(result.isLightUserdata());
|
|
std::stringstream ss;
|
|
result.print(ss);
|
|
EXPECT_NE(std::string::npos, ss.str().find("userdata:"));
|
|
EXPECT_NE(0u, result.hash());
|
|
lua_pop(L, 1);
|
|
}
|
|
|
|
{
|
|
lua_newuserdata(L, 100);
|
|
auto result = luabridge::LuaRef::fromStack(L);
|
|
EXPECT_EQ(LUA_TUSERDATA, result.type());
|
|
EXPECT_TRUE(result.isValid());
|
|
EXPECT_TRUE(result.isUserdata());
|
|
std::stringstream ss;
|
|
result.print(ss);
|
|
EXPECT_NE(std::string::npos, ss.str().find("userdata:"));
|
|
EXPECT_NE(0u, result.hash());
|
|
}
|
|
|
|
{
|
|
auto threadL = lua_newthread(L);
|
|
lua_pushthread(threadL);
|
|
auto result = luabridge::LuaRef::fromStack(L);
|
|
EXPECT_EQ(LUA_TTHREAD, result.type());
|
|
EXPECT_TRUE(result.isValid());
|
|
EXPECT_TRUE(result.isThread());
|
|
std::stringstream ss;
|
|
result.print(ss);
|
|
EXPECT_NE(std::string::npos, ss.str().find("thread:"));
|
|
EXPECT_NE(0u, result.hash());
|
|
}
|
|
}
|
|
|
|
TEST_F(LuaRefTests, ValueAccess)
|
|
{
|
|
runLua("result = true");
|
|
EXPECT_TRUE(result().isBool());
|
|
ASSERT_TRUE(result<bool>());
|
|
|
|
runLua("result = 7");
|
|
EXPECT_TRUE(result().isNumber());
|
|
ASSERT_EQ(7u, result<unsigned char>());
|
|
ASSERT_EQ(7, result<short>());
|
|
ASSERT_EQ(7u, result<unsigned short>());
|
|
ASSERT_EQ(7, result<int>());
|
|
ASSERT_EQ(7u, result<unsigned int>());
|
|
ASSERT_EQ(7, result<long>());
|
|
ASSERT_EQ(7u, result<unsigned long>());
|
|
ASSERT_EQ(7, result<long long>());
|
|
ASSERT_EQ(7u, result<unsigned long long>());
|
|
|
|
runLua("result = 3.14");
|
|
EXPECT_TRUE(result().isNumber());
|
|
ASSERT_FLOAT_EQ(3.14f, result<float>());
|
|
ASSERT_DOUBLE_EQ(3.14, result<double>());
|
|
|
|
runLua("result = 'D'");
|
|
EXPECT_TRUE(result().isString());
|
|
ASSERT_EQ("D", result());
|
|
ASSERT_EQ('D', result<char>());
|
|
ASSERT_EQ("D", result<std::string>());
|
|
ASSERT_STREQ("D", result<const char*>());
|
|
|
|
runLua("result = 'abc'");
|
|
EXPECT_TRUE(result().isString());
|
|
ASSERT_EQ("abc", result<std::string>());
|
|
ASSERT_STREQ("abc", result<char const*>());
|
|
|
|
runLua("result = function (i) "
|
|
" result = i + 1 "
|
|
" return i "
|
|
"end");
|
|
EXPECT_TRUE(result().isFunction());
|
|
auto fnResult = result()(41); // Replaces result variable
|
|
EXPECT_TRUE(fnResult);
|
|
EXPECT_TRUE(fnResult.size());
|
|
EXPECT_TRUE(fnResult[0].isNumber());
|
|
ASSERT_EQ(41, fnResult[0].unsafe_cast<int>());
|
|
ASSERT_EQ(41, *fnResult[0].cast<int>());
|
|
ASSERT_EQ(41, luabridge::unsafe_cast<int>(fnResult[0]));
|
|
ASSERT_EQ(41, *luabridge::cast<int>(fnResult[0]));
|
|
EXPECT_TRUE(result().isNumber());
|
|
ASSERT_EQ(42, result<int>());
|
|
}
|
|
|
|
TEST_F(LuaRefTests, DictionaryRead)
|
|
{
|
|
runLua("result = {"
|
|
" bool = true,"
|
|
" int = 5,"
|
|
" c = 3.14,"
|
|
" [true] = 'D',"
|
|
" [8] = 'abc',"
|
|
" fn = function (i) "
|
|
" result = i + 1 "
|
|
" return i "
|
|
" end"
|
|
"}");
|
|
|
|
EXPECT_TRUE(result()["bool"].isBool());
|
|
EXPECT_TRUE(result()["bool"].cast<bool>());
|
|
|
|
EXPECT_TRUE(result()["int"].isNumber());
|
|
ASSERT_EQ(5u, result()["int"].unsafe_cast<unsigned char>());
|
|
ASSERT_EQ(5, result()["int"].unsafe_cast<short>());
|
|
ASSERT_EQ(5u, result()["int"].unsafe_cast<unsigned short>());
|
|
ASSERT_EQ(5, result()["int"].unsafe_cast<int>());
|
|
ASSERT_EQ(5u, result()["int"].unsafe_cast<unsigned int>());
|
|
ASSERT_EQ(5, result()["int"].unsafe_cast<long>());
|
|
ASSERT_EQ(5u, result()["int"].unsafe_cast<unsigned long>());
|
|
ASSERT_EQ(5, result()["int"].unsafe_cast<long long>());
|
|
ASSERT_EQ(5u, result()["int"].unsafe_cast<unsigned long long>());
|
|
|
|
EXPECT_TRUE(result()['c'].isNumber());
|
|
ASSERT_FLOAT_EQ(3.14f, result()['c'].unsafe_cast<float>());
|
|
ASSERT_DOUBLE_EQ(3.14, result()['c'].unsafe_cast<double>());
|
|
|
|
EXPECT_TRUE(result()[true].isString());
|
|
ASSERT_EQ('D', result()[true].unsafe_cast<char>());
|
|
ASSERT_EQ("D", result()[true].unsafe_cast<std::string>());
|
|
ASSERT_STREQ("D", result()[true].unsafe_cast<const char*>());
|
|
|
|
EXPECT_TRUE(result()[8].isString());
|
|
ASSERT_EQ("abc", result()[8].unsafe_cast<std::string>());
|
|
ASSERT_STREQ("abc", result()[8].unsafe_cast<char const*>());
|
|
|
|
EXPECT_TRUE(result()["fn"].isFunction());
|
|
auto fnResult = result()["fn"](41); // Replaces result variable
|
|
EXPECT_TRUE(fnResult);
|
|
EXPECT_TRUE(fnResult.size());
|
|
EXPECT_TRUE(fnResult[0].isNumber());
|
|
ASSERT_EQ(41, fnResult[0].unsafe_cast<int>());
|
|
EXPECT_TRUE(result().isNumber());
|
|
ASSERT_EQ(42, result<int>());
|
|
}
|
|
|
|
TEST_F(LuaRefTests, DictionaryWrite)
|
|
{
|
|
runLua("result = {a = 5}");
|
|
EXPECT_TRUE(result()["a"].isNumber());
|
|
ASSERT_EQ(5, result()["a"].unsafe_cast<int>());
|
|
|
|
result()["a"] = 7;
|
|
ASSERT_EQ(7, result()["a"].unsafe_cast<int>());
|
|
|
|
runLua("result = result.a");
|
|
ASSERT_EQ(7, result<int>());
|
|
|
|
runLua("result = {a = {b = 1}}");
|
|
ASSERT_EQ(1, result()["a"]["b"].unsafe_cast<int>());
|
|
|
|
result()["a"]["b"] = 2;
|
|
ASSERT_EQ(2, result()["a"]["b"].unsafe_cast<int>());
|
|
}
|
|
|
|
struct Class
|
|
{
|
|
};
|
|
|
|
TEST_F(LuaRefTests, Comparison)
|
|
{
|
|
runLua("function foo () end "
|
|
"local m = {} "
|
|
"m.__eq = function (l, r) return l.a == r.a end "
|
|
"m.__lt = function (l, r) return l.a < r.a end "
|
|
"m.__le = function (l, r) return l.a <= r.a end "
|
|
"t1 = {a = 1} setmetatable (t1, m) "
|
|
"t2 = {a = 2} setmetatable (t2, m) "
|
|
"t3 = {a = 1} setmetatable (t3, m) "
|
|
"t4 = {a = 2} ");
|
|
|
|
luabridge::getGlobalNamespace(L).beginClass<Class>("Class").endClass();
|
|
|
|
luabridge::LuaRef invalid(L);
|
|
luabridge::LuaRef nil(L, luabridge::LuaNil());
|
|
luabridge::LuaRef boolFalse(L, false);
|
|
luabridge::LuaRef boolTrue(L, true);
|
|
luabridge::LuaRef minus5(L, -5);
|
|
luabridge::LuaRef numPi(L, 3.14);
|
|
luabridge::LuaRef stringA(L, 'a');
|
|
luabridge::LuaRef stringAB(L, "ab");
|
|
luabridge::LuaRef t1 = luabridge::getGlobal(L, "t1");
|
|
luabridge::LuaRef t2 = luabridge::getGlobal(L, "t2");
|
|
luabridge::LuaRef t3 = luabridge::getGlobal(L, "t3");
|
|
luabridge::LuaRef t4 = luabridge::getGlobal(L, "t4");
|
|
|
|
EXPECT_FALSE(invalid.isValid());
|
|
EXPECT_TRUE(nil.isValid());
|
|
|
|
EXPECT_TRUE(nil == invalid);
|
|
EXPECT_TRUE(invalid == nil);
|
|
|
|
EXPECT_TRUE(nil == nil);
|
|
|
|
EXPECT_TRUE(nil < boolFalse);
|
|
|
|
EXPECT_TRUE(boolFalse == boolFalse);
|
|
EXPECT_TRUE(boolTrue == boolTrue);
|
|
|
|
EXPECT_TRUE(boolTrue < minus5);
|
|
|
|
EXPECT_TRUE(minus5 == minus5);
|
|
EXPECT_FALSE(minus5 == numPi);
|
|
EXPECT_TRUE(minus5 < numPi);
|
|
EXPECT_TRUE(minus5 <= numPi);
|
|
EXPECT_FALSE(minus5 > numPi);
|
|
EXPECT_FALSE(minus5 >= numPi);
|
|
|
|
EXPECT_TRUE(numPi < stringA);
|
|
|
|
EXPECT_TRUE(stringA == stringA);
|
|
EXPECT_FALSE(stringA == stringAB);
|
|
EXPECT_TRUE(stringA < stringAB);
|
|
EXPECT_TRUE(stringA <= stringAB);
|
|
EXPECT_FALSE(stringA > stringAB);
|
|
EXPECT_FALSE(stringA >= stringAB);
|
|
|
|
EXPECT_TRUE(stringA < t1);
|
|
|
|
EXPECT_TRUE(t1 == t1);
|
|
EXPECT_FALSE(t1 == t2);
|
|
EXPECT_TRUE(t1 == t3);
|
|
EXPECT_FALSE(t1.rawequal(t3));
|
|
EXPECT_FALSE(t1 == t4);
|
|
EXPECT_TRUE(t2 == t2);
|
|
EXPECT_FALSE(t2 == t3);
|
|
|
|
#if LUABRIDGEDEMO_LUA_VERSION >= 503 && !LUABRIDGE_ON_LUAU && !LUABRIDGE_ON_LUAJIT
|
|
// This has changed in lua 5.3 and is quite a behaviour change
|
|
EXPECT_TRUE(t2 == t4);
|
|
#else
|
|
EXPECT_FALSE(t2 == t4);
|
|
#endif
|
|
|
|
EXPECT_TRUE(t3 == t3);
|
|
EXPECT_FALSE(t3 == t4);
|
|
|
|
EXPECT_FALSE(t1 < t1);
|
|
EXPECT_TRUE(t1 < t2);
|
|
EXPECT_FALSE(t1 < t3);
|
|
EXPECT_FALSE(t2 < t3);
|
|
|
|
EXPECT_TRUE(t1 <= t1);
|
|
EXPECT_TRUE(t1 <= t2);
|
|
EXPECT_TRUE(t1 <= t3);
|
|
EXPECT_FALSE(t2 <= t3);
|
|
|
|
EXPECT_FALSE(t1 > t1);
|
|
EXPECT_FALSE(t1 > t2);
|
|
EXPECT_FALSE(t1 > t3);
|
|
EXPECT_TRUE(t2 > t3);
|
|
|
|
EXPECT_TRUE(t1 >= t1);
|
|
EXPECT_FALSE(t1 >= t2);
|
|
EXPECT_TRUE(t1 >= t3);
|
|
EXPECT_TRUE(t2 >= t3);
|
|
}
|
|
|
|
TEST_F(LuaRefTests, ComparisonNumbers)
|
|
{
|
|
runLua("result = 7");
|
|
EXPECT_TRUE(result().isNumber());
|
|
|
|
EXPECT_EQ(7, result());
|
|
EXPECT_EQ(result(), 7);
|
|
EXPECT_NE(8, result());
|
|
EXPECT_NE(result(), 8);
|
|
|
|
EXPECT_GT(8, result());
|
|
EXPECT_LT(result(), 8);
|
|
|
|
EXPECT_GE(8, result());
|
|
EXPECT_GE(7, result());
|
|
EXPECT_LE(result(), 8);
|
|
EXPECT_LE(result(), 7);
|
|
}
|
|
|
|
TEST_F(LuaRefTests, ComparisonLuaRef)
|
|
{
|
|
runLua("result = 7");
|
|
auto seven = result();
|
|
|
|
runLua("result = 8");
|
|
auto eight = result();
|
|
|
|
EXPECT_EQ(seven, seven);
|
|
EXPECT_NE(seven, eight);
|
|
EXPECT_NE(eight, seven);
|
|
|
|
EXPECT_GT(eight, seven);
|
|
EXPECT_LT(seven, eight);
|
|
|
|
EXPECT_GE(eight, seven);
|
|
EXPECT_LE(seven, eight);
|
|
}
|
|
|
|
TEST_F(LuaRefTests, ComparisonLuaRefInvalidTypes)
|
|
{
|
|
runLua("result = 7");
|
|
auto seven = result();
|
|
|
|
runLua("result = '8'");
|
|
auto eight = result();
|
|
|
|
EXPECT_NE(seven, eight);
|
|
EXPECT_NE(eight, seven);
|
|
|
|
EXPECT_GT(eight, seven);
|
|
EXPECT_LT(seven, eight);
|
|
|
|
EXPECT_GE(eight, seven);
|
|
EXPECT_LE(seven, eight);
|
|
}
|
|
|
|
TEST_F(LuaRefTests, Assignment)
|
|
{
|
|
runLua("value = {a = 5}");
|
|
auto value = luabridge::getGlobal(L, "value");
|
|
EXPECT_TRUE(value.isTable());
|
|
EXPECT_TRUE(value["a"].isNumber());
|
|
ASSERT_EQ(5, value["a"].unsafe_cast<int>());
|
|
|
|
value = value["a"];
|
|
EXPECT_TRUE(value.isNumber());
|
|
ASSERT_EQ(5, value.unsafe_cast<int>());
|
|
|
|
#if __clang__
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wself-assign-overloaded"
|
|
#endif
|
|
|
|
value = value;
|
|
|
|
#if __clang__
|
|
#pragma clang diagnostic pop
|
|
#endif
|
|
|
|
ASSERT_EQ(LUA_TNUMBER, value.type());
|
|
EXPECT_TRUE(value.isNumber());
|
|
ASSERT_EQ(5, value.unsafe_cast<int>());
|
|
|
|
runLua("t = {a = {b = 5}}");
|
|
auto table = luabridge::getGlobal(L, "t");
|
|
luabridge::LuaRef entry = table["a"];
|
|
luabridge::LuaRef b1 = entry["b"];
|
|
luabridge::LuaRef b2 = table["a"]["b"];
|
|
EXPECT_TRUE(b1 == b2);
|
|
|
|
runLua("c1 = 1");
|
|
auto c1 = luabridge::getGlobal(L, "c1");
|
|
ASSERT_EQ(1, c1.unsafe_cast<int>());
|
|
c1 = 11;
|
|
ASSERT_EQ(11, c1.unsafe_cast<int>());
|
|
}
|
|
|
|
TEST_F(LuaRefTests, MoveConstructAndAssign)
|
|
{
|
|
runLua("value = {a = 5}");
|
|
auto value = luabridge::getGlobal(L, "value");
|
|
EXPECT_TRUE(value.isTable());
|
|
EXPECT_TRUE(value["a"].isNumber());
|
|
EXPECT_TRUE(value.rawget("a").isNumber());
|
|
ASSERT_EQ(5, value["a"].unsafe_cast<int>());
|
|
|
|
luabridge::LuaRef moveConstructed = std::move(value);
|
|
EXPECT_TRUE(moveConstructed.isTable());
|
|
EXPECT_TRUE(moveConstructed["a"].isNumber());
|
|
ASSERT_EQ(5, moveConstructed["a"].unsafe_cast<int>());
|
|
EXPECT_FALSE(value.isValid());
|
|
|
|
luabridge::LuaRef moveAssigned(L);
|
|
moveAssigned = std::move(moveConstructed);
|
|
EXPECT_TRUE(moveAssigned.isTable());
|
|
EXPECT_TRUE(moveAssigned["a"].isNumber());
|
|
ASSERT_EQ(5, moveAssigned["a"].unsafe_cast<int>());
|
|
EXPECT_FALSE(moveConstructed.isValid());
|
|
}
|
|
|
|
TEST_F(LuaRefTests, Callable)
|
|
{
|
|
runLua("function f () end");
|
|
auto f = luabridge::getGlobal(L, "f");
|
|
EXPECT_TRUE(f.isCallable());
|
|
|
|
runLua("x = 1");
|
|
auto x = luabridge::getGlobal(L, "x");
|
|
EXPECT_FALSE(x.isCallable());
|
|
|
|
runLua("meta1 = { __call = function(self) return 5 end }");
|
|
auto meta1 = luabridge::getGlobal(L, "meta1");
|
|
EXPECT_FALSE(meta1.isCallable());
|
|
|
|
runLua("meta2 = { __call = function(self) self.i = self.i + 100 end }; obj = { i = 100 }; setmetatable(obj, meta2)");
|
|
auto obj = luabridge::getGlobal(L, "obj");
|
|
EXPECT_TRUE(obj.isCallable());
|
|
EXPECT_EQ(100, obj["i"].unsafe_cast<int>());
|
|
obj();
|
|
EXPECT_EQ(200, obj["i"].unsafe_cast<int>());
|
|
}
|
|
|
|
TEST_F(LuaRefTests, Pop)
|
|
{
|
|
lua_pushstring(L, "hello");
|
|
luabridge::LuaRef ref1 = luabridge::LuaRef::fromStack(L);
|
|
|
|
lua_pushstring(L, "world!");
|
|
luabridge::LuaRef ref2 = luabridge::LuaRef::fromStack(L);
|
|
|
|
ref1.push();
|
|
ref2.pop();
|
|
|
|
EXPECT_EQ(ref1.unsafe_cast<std::string>(), ref2.unsafe_cast<std::string>());
|
|
EXPECT_EQ("hello", ref1.tostring());
|
|
EXPECT_EQ("hello", ref2.tostring());
|
|
}
|
|
|
|
TEST_F(LuaRefTests, IsInstance)
|
|
{
|
|
struct Base {};
|
|
struct Derived : Base {};
|
|
struct Other {};
|
|
struct Unknown : Base {};
|
|
|
|
luabridge::getGlobalNamespace(L)
|
|
.beginClass<Base>("Base")
|
|
.addConstructor<void (*)()>()
|
|
.endClass()
|
|
.deriveClass<Derived, Base>("Derived")
|
|
.addConstructor<void (*)()>()
|
|
.endClass()
|
|
.beginClass<Other>("Other")
|
|
.addConstructor<void (*)()>()
|
|
.endClass();
|
|
|
|
runLua("result = Base ()");
|
|
EXPECT_TRUE(result().isInstance<Base>());
|
|
EXPECT_FALSE(result().isInstance<Derived>());
|
|
EXPECT_FALSE(result().isInstance<Other>());
|
|
EXPECT_FALSE(result().isInstance<Unknown>());
|
|
EXPECT_TRUE(result().isUserdata());
|
|
EXPECT_FALSE(result().isNil());
|
|
EXPECT_EQ("Base", result().getClassName().value_or(""));
|
|
|
|
runLua("result = Derived ()");
|
|
EXPECT_TRUE(result().isInstance<Base>());
|
|
EXPECT_TRUE(result().isInstance<Derived>());
|
|
EXPECT_FALSE(result().isInstance<Other>());
|
|
EXPECT_FALSE(result().isInstance<Unknown>());
|
|
EXPECT_TRUE(result().isUserdata());
|
|
EXPECT_FALSE(result().isNil());
|
|
EXPECT_EQ("Derived", result().getClassName().value_or(""));
|
|
|
|
runLua("result = Other ()");
|
|
EXPECT_FALSE(result().isInstance<Base>());
|
|
EXPECT_FALSE(result().isInstance<Derived>());
|
|
EXPECT_TRUE(result().isInstance<Other>());
|
|
EXPECT_FALSE(result().isInstance<Unknown>());
|
|
EXPECT_TRUE(result().isUserdata());
|
|
EXPECT_FALSE(result().isNil());
|
|
EXPECT_EQ("Other", result().getClassName().value_or(""));
|
|
|
|
lua_newuserdata(L, sizeof(Unknown));
|
|
EXPECT_TRUE(lua_isuserdata(L, -1));
|
|
luaL_newmetatable(L, "Unknown");
|
|
EXPECT_TRUE(lua_istable(L, -1));
|
|
lua_setmetatable(L, -2);
|
|
EXPECT_TRUE(lua_isuserdata(L, -1));
|
|
lua_setglobal(L, "unkown");
|
|
runLua("result = unknown");
|
|
EXPECT_FALSE(result().isInstance<Base>());
|
|
EXPECT_FALSE(result().isInstance<Derived>());
|
|
EXPECT_FALSE(result().isInstance<Other>());
|
|
EXPECT_FALSE(result().isInstance<Unknown>());
|
|
//EXPECT_TRUE(result().isUserdata()); // TODO
|
|
EXPECT_FALSE(result().isTable());
|
|
//EXPECT_FALSE(result().isNil()); // TODO
|
|
EXPECT_FALSE(result().getClassName());
|
|
|
|
runLua("result = {}");
|
|
EXPECT_FALSE(result().isInstance<Base>());
|
|
EXPECT_FALSE(result().isInstance<Derived>());
|
|
EXPECT_FALSE(result().isInstance<Other>());
|
|
EXPECT_FALSE(result().isInstance<Unknown>());
|
|
EXPECT_FALSE(result().isUserdata());
|
|
EXPECT_TRUE(result().isTable());
|
|
EXPECT_FALSE(result().isNil());
|
|
EXPECT_FALSE(result().getClassName());
|
|
|
|
runLua("result = 3.14");
|
|
EXPECT_FALSE(result().isInstance<Base>());
|
|
EXPECT_FALSE(result().isInstance<Derived>());
|
|
EXPECT_FALSE(result().isInstance<Other>());
|
|
EXPECT_FALSE(result().isInstance<Unknown>());
|
|
EXPECT_FALSE(result().isUserdata());
|
|
EXPECT_TRUE(result().isNumber());
|
|
EXPECT_FALSE(result().isNil());
|
|
EXPECT_FALSE(result().getClassName());
|
|
}
|
|
|
|
TEST_F(LuaRefTests, Print)
|
|
{
|
|
{
|
|
runLua("result = true");
|
|
std::ostringstream stream;
|
|
stream << result();
|
|
ASSERT_EQ("true", stream.str());
|
|
}
|
|
{
|
|
runLua("result = false");
|
|
std::ostringstream stream;
|
|
stream << result();
|
|
ASSERT_EQ("false", stream.str());
|
|
}
|
|
{
|
|
runLua("result = 5");
|
|
std::ostringstream stream;
|
|
stream << result();
|
|
ASSERT_EQ("5", stream.str());
|
|
}
|
|
{
|
|
runLua("result = 'abc'");
|
|
std::ostringstream stream;
|
|
stream << result();
|
|
ASSERT_EQ("\"abc\"", stream.str());
|
|
}
|
|
|
|
runLua("result = {"
|
|
" true_ = true,"
|
|
" false_ = false,"
|
|
" five = 5,"
|
|
" abc = 'abc'"
|
|
"}");
|
|
{
|
|
std::ostringstream stream;
|
|
stream << result()["true_"];
|
|
ASSERT_EQ("true", stream.str());
|
|
}
|
|
{
|
|
std::ostringstream stream;
|
|
stream << result()["false_"];
|
|
ASSERT_EQ("false", stream.str());
|
|
}
|
|
{
|
|
std::ostringstream stream;
|
|
stream << result()["five"];
|
|
ASSERT_EQ("5", stream.str());
|
|
}
|
|
{
|
|
std::ostringstream stream;
|
|
stream << result()["abc"];
|
|
ASSERT_EQ("\"abc\"", stream.str());
|
|
}
|
|
}
|
|
|
|
TEST_F(LuaRefTests, RegisterLambdaInTable)
|
|
{
|
|
luabridge::getGlobalNamespace(L)
|
|
.beginNamespace("Entities")
|
|
.addFunction("GetLocalHero", [&]() {
|
|
auto table = luabridge::newTable(L);
|
|
table.push(L);
|
|
|
|
luabridge::getNamespaceFromStack(L)
|
|
.addProperty("index", [] { return 150; })
|
|
.addFunction("Health", [&] { return 500; });
|
|
|
|
table.pop();
|
|
return table;
|
|
})
|
|
.endNamespace();
|
|
|
|
runLua("result = Entities.GetLocalHero().Health()");
|
|
ASSERT_EQ(500, result<int>());
|
|
}
|
|
|
|
TEST_F(LuaRefTests, HookTesting)
|
|
{
|
|
std::map<std::string, luabridge::LuaRef> hooklist;
|
|
|
|
auto hook = [&](const std::string& name, luabridge::LuaRef cb) {
|
|
hooklist.emplace(name, std::move(cb));
|
|
};
|
|
|
|
luabridge::getGlobalNamespace(L)
|
|
.addFunction("Hook", hook);
|
|
|
|
runLua(R"(
|
|
function hook1(type, packet)
|
|
print("lol")
|
|
end
|
|
|
|
Hook("hook1", hook1)
|
|
)");
|
|
|
|
for (auto& func : hooklist) {
|
|
func.second(0, "x");
|
|
}
|
|
}
|