Added LuaBridge support

1 files changed, 304 insertions, 0 deletions

diff --git a/lib/LuaBridge/Tests/Source/LuaRefTests.cpp b/lib/LuaBridge/Tests/Source/LuaRefTests.cpp
new file mode 100644
index 0000000..eaffe0c
--- /dev/null
+++ b/lib/LuaBridge/Tests/Source/LuaRefTests.cpp
@@ -0,0 +1,304 @@
+// https://github.com/vinniefalco/LuaBridge
+//
+// 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, ValueAccess)
+{
+  runLua ("result = true");
+  ASSERT_TRUE (result ().isBool ());
+  ASSERT_TRUE (result <bool> ());
+
+  runLua ("result = 7");
+  ASSERT_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");
+  ASSERT_TRUE (result ().isNumber ());
+  ASSERT_FLOAT_EQ (3.14f, result <float> ());
+  ASSERT_DOUBLE_EQ (3.14, result <double> ());
+
+  runLua ("result = 'D'");
+  ASSERT_TRUE (result ().isString ());
+  ASSERT_EQ ('D', result <char> ());
+  ASSERT_EQ ("D", result <std::string> ());
+  ASSERT_STREQ ("D", result <const char*> ());
+
+  runLua ("result = 'abc'");
+  ASSERT_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");
+  ASSERT_TRUE (result ().isFunction ());
+  auto fnResult = result () (41); // Replaces result variable
+  ASSERT_TRUE (fnResult.isNumber ());
+  ASSERT_EQ (41, fnResult.cast <int> ());
+  ASSERT_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"
+    "}");
+
+  ASSERT_TRUE (result () ["bool"].isBool ());
+  ASSERT_TRUE (result () ["bool"].cast <bool> ());
+
+  ASSERT_TRUE (result () ["int"].isNumber ());
+  ASSERT_EQ (5u, result () ["int"].cast <unsigned char> ());
+  ASSERT_EQ (5, result () ["int"].cast <short> ());
+  ASSERT_EQ (5u, result () ["int"].cast <unsigned short> ());
+  ASSERT_EQ (5, result () ["int"].cast <int> ());
+  ASSERT_EQ (5u, result () ["int"].cast <unsigned int> ());
+  ASSERT_EQ (5, result () ["int"].cast <long> ());
+  ASSERT_EQ (5u, result () ["int"].cast <unsigned long> ());
+  ASSERT_EQ (5, result () ["int"].cast <long long> ());
+  ASSERT_EQ (5u, result () ["int"].cast <unsigned long long> ());
+
+  ASSERT_TRUE (result () ['c'].isNumber ());
+  ASSERT_FLOAT_EQ (3.14f, result () ['c'].cast <float> ());
+  ASSERT_DOUBLE_EQ (3.14, result () ['c'].cast <double> ());
+
+  ASSERT_TRUE (result () [true].isString ());
+  ASSERT_EQ ('D', result () [true].cast <char> ());
+  ASSERT_EQ ("D", result () [true].cast <std::string> ());
+  ASSERT_STREQ ("D", result () [true].cast <const char*> ());
+
+  ASSERT_TRUE (result () [8].isString ());
+  ASSERT_EQ ("abc", result () [8].cast <std::string> ());
+  ASSERT_STREQ ("abc", result () [8].cast <char const*> ());
+
+  ASSERT_TRUE (result () ["fn"].isFunction ());
+  auto fnResult = result () ["fn"] (41); // Replaces result variable
+  ASSERT_TRUE (fnResult.isNumber ());
+  ASSERT_EQ (41, fnResult.cast <int> ());
+  ASSERT_TRUE (result ().isNumber ());
+  ASSERT_EQ (42, result <int> ());
+}
+
+TEST_F (LuaRefTests, DictionaryWrite)
+{
+  runLua ("result = {a = 5}");
+  ASSERT_TRUE (result () ["a"].isNumber ());
+  ASSERT_EQ (5, result () ["a"].cast <int> ());
+
+  result () ["a"] = 7;
+  ASSERT_EQ (7, result () ["a"].cast <int> ());
+
+  runLua ("result = result.a");
+  ASSERT_EQ (7, result <int> ());
+
+  runLua ("result = {a = {b = 1}}");
+  ASSERT_EQ (1, result () ["a"] ["b"].cast <int> ());
+
+  result () ["a"] ["b"] = 2;
+  ASSERT_EQ (2, result () ["a"] ["b"].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 nil (L, luabridge::Nil ());
+  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");
+
+  ASSERT_TRUE (nil == nil);
+
+  ASSERT_TRUE (nil < boolFalse);
+
+  ASSERT_TRUE (boolFalse == boolFalse);
+  ASSERT_TRUE (boolTrue == boolTrue);
+
+  ASSERT_TRUE (boolTrue < minus5);
+
+  ASSERT_TRUE (minus5 == minus5);
+  ASSERT_FALSE (minus5 == numPi);
+  ASSERT_TRUE (minus5 < numPi);
+  ASSERT_TRUE (minus5 <= numPi);
+  ASSERT_FALSE (minus5 > numPi);
+  ASSERT_FALSE (minus5 >= numPi);
+
+  ASSERT_TRUE (numPi < stringA);
+
+  ASSERT_TRUE (stringA == stringA);
+  ASSERT_FALSE (stringA == stringAB);
+  ASSERT_TRUE (stringA < stringAB);
+  ASSERT_TRUE (stringA <= stringAB);
+  ASSERT_FALSE (stringA > stringAB);
+  ASSERT_FALSE (stringA >= stringAB);
+
+  ASSERT_TRUE (stringA < t1);
+
+  ASSERT_TRUE (t1 == t1);
+  ASSERT_FALSE (t1 == t2);
+  ASSERT_TRUE (t1 == t3);
+  ASSERT_FALSE (t1.rawequal (t3));
+  ASSERT_FALSE (t1 == t4);
+  ASSERT_TRUE (t2 == t2);
+  ASSERT_FALSE (t2 == t3);
+  ASSERT_FALSE (t2 == t4);
+  ASSERT_TRUE (t3 == t3);
+  ASSERT_FALSE (t3 == t4);
+
+  ASSERT_FALSE (t1 < t1);
+  ASSERT_TRUE (t1 < t2);
+  ASSERT_FALSE (t1 < t3);
+  ASSERT_FALSE (t2 < t3);
+
+  ASSERT_TRUE (t1 <= t1);
+  ASSERT_TRUE (t1 <= t2);
+  ASSERT_TRUE (t1 <= t3);
+  ASSERT_FALSE (t2 <= t3);
+
+  ASSERT_FALSE (t1 > t1);
+  ASSERT_FALSE (t1 > t2);
+  ASSERT_FALSE (t1 > t3);
+  ASSERT_TRUE (t2 > t3);
+
+  ASSERT_TRUE (t1 >= t1);
+  ASSERT_FALSE (t1 >= t2);
+  ASSERT_TRUE (t1 >= t3);
+  ASSERT_TRUE (t2 >= t3);
+}
+
+TEST_F (LuaRefTests, Assignment)
+{
+  runLua ("value = {a = 5}");
+  auto value = luabridge::getGlobal (L, "value");
+  ASSERT_TRUE (value.isTable ());
+  ASSERT_TRUE (value ["a"].isNumber ());
+  ASSERT_EQ (5, value ["a"].cast <int> ());
+
+  value = value ["a"];
+  ASSERT_TRUE (value.isNumber ());
+  ASSERT_EQ (5, value.cast <int> ());
+
+  value = value;
+  ASSERT_EQ (LUA_TNUMBER, value.type ());
+  ASSERT_TRUE (value.isNumber ());
+  ASSERT_EQ (5, value.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"];
+  ASSERT_TRUE (b1 == b2);
+}
+
+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 ());
+  }
+}