Added LuaBridge support

1 files changed, 262 insertions, 0 deletions

diff --git a/lib/LuaBridge/Tests/Source/Tests.cpp b/lib/LuaBridge/Tests/Source/Tests.cpp
new file mode 100644
index 0000000..c8c9fc5
--- /dev/null
+++ b/lib/LuaBridge/Tests/Source/Tests.cpp
@@ -0,0 +1,262 @@
+// 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
+
+// A set of tests of different types' communication with Lua
+
+#include "TestBase.h"
+
+#include <gtest/gtest.h>
+
+#include <cstring>
+#include <iostream>
+#include <memory>
+#include <string>
+
+void printValue (lua_State* L, int index)
+{
+  int type = lua_type (L, index);
+  switch (type)
+  {
+    case LUA_TBOOLEAN:
+      std::cerr << std::boolalpha << (lua_toboolean (L, index) != 0);
+      break;
+    case LUA_TSTRING:
+      std::cerr << lua_tostring (L, index);
+      break;
+    case LUA_TNUMBER:
+      std::cerr << lua_tonumber (L, index);
+      break;
+    case LUA_TTABLE:
+    case LUA_TTHREAD:
+    case LUA_TFUNCTION:
+      std::cerr << lua_topointer (L, index);
+      break;
+  }
+  std::cerr << ": " << lua_typename (L, type) << " (" << type << ")" << std::endl;
+}
+
+struct LuaBridgeTest : TestBase
+{
+};
+
+template <class T>
+T identityCFunction(T value)
+{
+  return value;
+}
+
+TEST_F (LuaBridgeTest, CFunction)
+{
+  luabridge::getGlobalNamespace(L)
+    .addFunction ("boolFn", &identityCFunction <bool>)
+    .addFunction ("ucharFn", &identityCFunction <unsigned char>)
+    .addFunction ("shortFn", &identityCFunction <short>)
+    .addFunction ("ushortFn", &identityCFunction <unsigned short>)
+    .addFunction ("intFn", &identityCFunction <int>)
+    .addFunction ("uintFn", &identityCFunction <unsigned int>)
+    .addFunction ("longFn", &identityCFunction <long>)
+    .addFunction ("ulongFn", &identityCFunction <unsigned long>)
+    .addFunction ("longlongFn", &identityCFunction <long long>)
+    .addFunction ("ulonglongFn", &identityCFunction <unsigned long long>)
+    .addFunction ("floatFn", &identityCFunction <float>)
+    .addFunction ("doubleFn", &identityCFunction <double>)
+    .addFunction ("charFn", &identityCFunction <char>)
+    .addFunction ("cstringFn", &identityCFunction <const char*>)
+    .addFunction ("stringFn", &identityCFunction <std::string>)
+  ;
+
+  {
+    runLua ("result = ucharFn (255)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_EQ (255u, result <unsigned char> ());
+  }
+
+  {
+    runLua ("result = boolFn (false)");
+    ASSERT_EQ (true, result ().isBool ());
+    ASSERT_EQ (false, result <bool> ());
+  }
+  {
+    runLua ("result = boolFn (true)");
+    ASSERT_EQ (true, result ().isBool ());
+    ASSERT_EQ (true, result <bool> ());
+  }
+
+  {
+    runLua ("result = shortFn (-32768)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_EQ (-32768, result <int> ());
+  }
+
+  {
+    runLua ("result = ushortFn (32767)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_EQ (32767u, result <unsigned int> ());
+  }
+  {
+    runLua ("result = intFn (-500)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_EQ (-500, result <int> ());
+  }
+
+  {
+    runLua ("result = uintFn (42)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_EQ (42u, result <unsigned int> ());
+  }
+
+  {
+    runLua ("result = longFn (-8000)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_EQ (-8000, result <long> ());
+  }
+
+  {
+    runLua ("result = ulongFn (9000)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_EQ (9000u, result <unsigned long> ());
+  }
+
+  {
+    runLua ("result = longlongFn (-8000)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_EQ (-8000, result <long long> ());
+  }
+
+  {
+    runLua ("result = ulonglongFn (9000)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_EQ (9000u, result <unsigned long long> ());
+  }
+
+  {
+    runLua ("result = floatFn (3.14)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_FLOAT_EQ (3.14f, result <float> ());
+  }
+
+  {
+    runLua ("result = doubleFn (-12.3)");
+    ASSERT_EQ (true, result ().isNumber ());
+    ASSERT_DOUBLE_EQ (-12.3, result <double> ());
+  }
+
+  {
+    runLua ("result = charFn ('a')");
+    ASSERT_EQ (true, result ().isString ());
+    ASSERT_EQ ('a', result <char> ());
+  }
+
+  {
+    runLua ("result = cstringFn ('abc')");
+    ASSERT_EQ (true, result ().isString ());
+    ASSERT_STREQ ("abc", result <const char*> ());
+  }
+
+  {
+    runLua ("result = stringFn ('lua')");
+    ASSERT_EQ (true, result ().isString ());
+    ASSERT_EQ ("lua", result <std::string> ());
+  }
+}
+
+template <class T>
+struct TestClass
+{
+  TestClass (T data)
+    : data (data)
+    , constData (data)
+  {
+  }
+
+  T getValue () { return data; }
+  T* getPtr () { return &data; }
+  T const* getConstPtr () { return &data; }
+  T& getRef () { return data; }
+  T const& getConstRef () { return data; }
+  T getValueConst () const { return data; }
+  T* getPtrConst () const { return &data; }
+  T const* getConstPtrConst () const { return &data; }
+  T& getRefConst () const { return data; }
+  T const& getConstRefConst () const { return data; }
+
+  mutable T data;
+  mutable T constData;
+};
+
+TEST_F (LuaBridgeTest, ClassFunction)
+{
+  typedef TestClass <int> Inner;
+  typedef TestClass <Inner> Outer;
+
+  luabridge::getGlobalNamespace (L)
+    .beginClass <Inner> ("Inner")
+    .addConstructor <void (*) (int)> ()
+    .addData ("data", &Inner::data)
+    .endClass ()
+    .beginClass <Outer> ("Outer")
+    .addConstructor <void (*) (Inner)> ()
+    .addFunction ("getValue", &Outer::getValue)
+    .addFunction ("getPtr", &Outer::getPtr)
+    .addFunction ("getConstPtr", &Outer::getConstPtr)
+    .addFunction ("getRef", &Outer::getRef)
+    .addFunction ("getConstRef", &Outer::getConstRef)
+    .addFunction ("getValueConst", &Outer::getValueConst)
+    .addFunction ("getPtrConst", &Outer::getPtrConst)
+    .addFunction ("getConstPtrConst", &Outer::getConstPtrConst)
+    .addFunction ("getRefConst", &Outer::getRefConst)
+    .addFunction ("getConstRefConst", &Outer::getConstRefConst)
+    .endClass ()
+    ;
+
+  Outer outer (Inner (0));
+  luabridge::setGlobal (L, &outer, "outer");
+
+  outer.data.data = 0;
+  runLua ("outer:getValue ().data = 1");
+  ASSERT_EQ (0, outer.data.data);
+
+  outer.data.data = 1;
+  runLua ("outer:getPtr ().data = 10");
+  ASSERT_EQ (10, outer.data.data);
+
+  outer.data.data = 2;
+  ASSERT_THROW (
+    runLua ("outer:getConstPtr ().data = 20"),
+    std::runtime_error);
+
+  outer.data.data = 3;
+  runLua ("outer:getRef().data = 30");
+  ASSERT_EQ (30, outer.data.data);
+
+  outer.data.data = 4;
+  ASSERT_THROW (
+    runLua ("outer:getConstPtr ().data = 40"),
+    std::runtime_error);
+
+  outer.data.data = 5;
+  runLua ("outer:getValueConst ().data = 50");
+  ASSERT_EQ (5, outer.data.data);
+
+  outer.data.data = 6;
+  runLua ("outer:getPtrConst ().data = 60");
+  ASSERT_EQ (60, outer.data.data);
+
+  outer.data.data = 7;
+  ASSERT_THROW (
+    runLua ("outer:getConstPtr ().data = 70"),
+    std::runtime_error);
+
+  outer.data.data = 8;
+  runLua ("outer:getRef().data = 80");
+  ASSERT_EQ (80, outer.data.data);
+
+  outer.data.data = 9;
+  ASSERT_THROW (
+    runLua ("outer:getConstPtr ().data = 90"),
+    std::runtime_error);
+}