Unverified Commit 1cc74393 authored by Vinicius Jarina's avatar Vinicius Jarina Committed by GitHub
Browse files

* Giant cleanup/reshuffle of all files. (#265)

* * Giant cleanup/reshuffle of all files.

* * Update upstream `KeraLua` to `0.1.14`

* Fixed .NET Core build.

* Add runsettings file

* * Fixed nuspec `dependencies` node

* Ignore _ in branch names for package names.

* * Fixed nuspec.
parent 3f254585
-- fibonacci function with cache
-- very inefficient fibonacci function
function fib(n)
N=N+1
if n<2 then
return n
else
return fib(n-1)+fib(n-2)
end
end
-- a general-purpose value cache
function cache(f)
local c={}
return function (x)
local y=c[x]
if not y then
y=f(x)
c[x]=y
end
return y
end
end
-- run and time it
function test(s,f)
N=0
local c=os.clock()
local v=f(n)
local t=os.clock()-c
print(s,n,v,t,N)
return v
end
n= 24 -- for other values, do lua fib.lua XX
n=tonumber(n)
print("","n","value","time","evals")
v = test("plain",fib)
assert (v == 46368)
fib=cache(fib)
v = test("cached",fib)
assert (v == 46368)
-- example of for with generator functions
local fibs = {
1,
1,
2,
3,
5,
8,
13,
21,
34,
55,
89,
144,
233,
377,
610,
987,
}
function generatefib (n)
return coroutine.wrap(function ()
local a,b = 1, 1
while a <= n do
coroutine.yield(a)
a, b = b, a+b
end
end)
end
local j = 1
for i in generatefib(1000) do
print(i.." ".. fibs [j])
assert (i == fibs [j])
j = j + 1
end
-- life.lua
-- original by Dave Bollinger <DBollinger@compuserve.com> posted to lua-l
-- modified to use ANSI terminal escape sequences
-- modified to use for instead of while
local write=print
ALIVE="" DEAD=""
ALIVE="O" DEAD="-"
function delay() -- NOTE: SYSTEM-DEPENDENT, adjust as necessary
for i=1,10000 do end
-- local i=os.clock()+1 while(os.clock()<i) do end
end
function ARRAY2D(w,h)
local t = {w=w,h=h}
for y=1,h do
t[y] = {}
for x=1,w do
t[y][x]=0
end
end
return t
end
_CELLS = {}
-- give birth to a "shape" within the cell array
function _CELLS:spawn(shape,left,top)
for y=0,shape.h-1 do
for x=0,shape.w-1 do
self[top+y][left+x] = shape[y*shape.w+x+1]
end
end
end
-- run the CA and produce the next generation
function _CELLS:evolve(next)
local ym1,y,yp1,yi=self.h-1,self.h,1,self.h
while yi > 0 do
local xm1,x,xp1,xi=self.w-1,self.w,1,self.w
while xi > 0 do
local sum = self[ym1][xm1] + self[ym1][x] + self[ym1][xp1] +
self[y][xm1] + self[y][xp1] +
self[yp1][xm1] + self[yp1][x] + self[yp1][xp1]
next[y][x] = ((sum==2) and self[y][x]) or ((sum==3) and 1) or 0
xm1,x,xp1,xi = x,xp1,xp1+1,xi-1
end
ym1,y,yp1,yi = y,yp1,yp1+1,yi-1
end
end
-- output the array to screen
function _CELLS:draw()
local out="" -- accumulate to reduce flicker
for y=1,self.h do
for x=1,self.w do
out=out..(((self[y][x]>0) and ALIVE) or DEAD)
end
out=out.."\n"
end
write(out)
end
-- constructor
function CELLS(w,h)
local c = ARRAY2D(w,h)
c.spawn = _CELLS.spawn
c.evolve = _CELLS.evolve
c.draw = _CELLS.draw
return c
end
--
-- shapes suitable for use with spawn() above
--
HEART = { 1,0,1,1,0,1,1,1,1; w=3,h=3 }
GLIDER = { 0,0,1,1,0,1,0,1,1; w=3,h=3 }
EXPLODE = { 0,1,0,1,1,1,1,0,1,0,1,0; w=3,h=4 }
FISH = { 0,1,1,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,1,0; w=5,h=4 }
BUTTERFLY = { 1,0,0,0,1,0,1,1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,0,0,1; w=5,h=5 }
-- the main routine
function LIFE(w,h)
-- create two arrays
local thisgen = CELLS(w,h)
local nextgen = CELLS(w,h)
-- create some life
-- about 1000 generations of fun, then a glider steady-state
thisgen:spawn(GLIDER,5,4)
thisgen:spawn(EXPLODE,25,10)
thisgen:spawn(FISH,4,12)
-- run until break
local gen=1
write("\027[2J") -- ANSI clear screen
while 1 do
thisgen:evolve(nextgen)
thisgen,nextgen = nextgen,thisgen
write("\027[H") -- ANSI home cursor
thisgen:draw()
write("Life - generation ".." "..gen.." ".."\n")
gen=gen+1
if gen>2000 then break end
--delay() -- no delay
end
end
LIFE(40,20)
-- an implementation of printf
function sprintf(...)
return string.format(...)
end
function printf (...)
print(sprintf(...))
end
x = sprintf("Hello %s from %s on %s", "there", "Lua Tests", "XYZ")
assert (x == "Hello there from Lua Tests on XYZ")
print(x)
-- the sieve of of Eratosthenes programmed with coroutines
-- typical usage: lua -e N=1000 sieve.lua | column
local siev = {
2,
3,
5,
7,
11,
13,
17,
19,
23,
29,
31,
37,
41,
43,
47,
53,
59,
61,
67,
71,
73,
79,
83,
89,
97,
101,
103,
107,
109,
113,
127,
131,
137,
139,
149,
151,
157,
163,
167,
173,
179,
181,
191,
193,
197,
199,
211,
223,
227,
229,
233,
239,
241,
251,
257,
263,
269,
271,
277,
281,
283,
293,
307,
311,
313,
317,
331,
337,
347,
349,
353,
359,
367,
373,
379,
383,
389,
397,
401,
409,
419,
421,
431,
433,
439,
443,
449,
457,
461,
463,
467,
479,
487,
491,
499,
503,
509,
521,
523,
541,
547,
557,
563,
569,
571,
577,
587,
593,
599,
601,
607,
613,
617,
619,
631,
641,
643,
647,
653,
659,
661,
673,
677,
683,
691,
701,
709,
719,
727,
733,
739,
743,
751,
757,
761,
769,
773,
787,
797,
809,
811,
821,
823,
827,
829,
839,
853,
857,
859,
863,
877,
881,
883,
887,
907,
911,
919,
929,
937,
941,
947,
953,
967,
971,
977,
983,
991,
997,
}
-- generate all the numbers from 2 to n
function gen (n)
return coroutine.wrap(function ()
for i=2,n do coroutine.yield(i) end
end)
end
-- filter the numbers generated by `g', removing multiples of `p'
function filter (p, g)
return coroutine.wrap(function ()
while 1 do
local n = g()
if n == nil then return end
if math.fmod(n, p) ~= 0 then coroutine.yield(n) end
end
end)
end
N=1000 -- from command line
x = gen(N) -- generate primes up to N
local j = 1
while 1 do
local n = x() -- pick a number until done
if n == nil then break end
print(n) -- must be a prime number
assert (n == siev [j])
x = filter(n, x) -- now remove its multiples
j = j + 1
end
-- two implementations of a sort function
-- this is an example only. Lua has now a built-in function "sort"
quicksort_x = {"Apr","Aug","Dec","Feb","Jan","Jul","Jun","Mar","May","Nov","Oct","Sep"}
reverse_x = {"Sep","Oct","Nov","May","Mar","Jun","Jul","Jan","Feb","Dec","Aug","Apr"}
-- extracted from Programming Pearls, page 110
function qsort(x,l,u,f)
if l<u then
local m=math.random(u-(l-1))+l-1 -- choose a random pivot in range l..u
x[l],x[m]=x[m],x[l] -- swap pivot to first position
local t=x[l] -- pivot value
m=l
local i=l+1
while i<=u do
-- invariant: x[l+1..m] < t <= x[m+1..i-1]
if f(x[i],t) then
m=m+1
x[m],x[i]=x[i],x[m] -- swap x[i] and x[m]
end
i=i+1
end
x[l],x[m]=x[m],x[l] -- swap pivot to a valid place
-- x[l+1..m-1] < x[m] <= x[m+1..u]
qsort(x,l,m-1,f)
qsort(x,m+1,u,f)
end
end
function selectionsort(x,n,f)
local i=1
while i<=n do
local m,j=i,i+1
while j<=n do
if f(x[j],x[m]) then m=j end
j=j+1
end
x[i],x[m]=x[m],x[i] -- swap x[i] and x[m]
i=i+1
end
end
function show(m,x, t)
print(m.." ".."\n\t")
local i=1
while x[i] do
assert (x[i] == t[i])
print(x[i])
i=i+1
if x[i] then print(",") end
end
print("\n")
end
function testsorts(x)
local n=1
while x[n] do n=n+1 end; n=n-1 -- count elements
show("original",x , x)
qsort(x,1,n,function (x,y) return x<y end)
show("after quicksort",x, quicksort_x)
selectionsort(x,n,function (x,y) return x>y end)
show("after reverse selection sort",x, reverse_x)
qsort(x,1,n,function (x,y) return x<y end)
show("after quicksort again",x, quicksort_x)
end
-- array to be sorted
x={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"}
testsorts(x)
using System;
using System.Text;
using System.Collections.Generic;
using NUnit.Framework;
using NLuaTest.Mock;
using System.Reflection;
using System.Threading;
using NLua;
using NLua.Exceptions;
namespace NLuaTest
{
[TestFixture]
public class AAACodeGenTests
{
/*
* Tests passing a Lua function to a delegate
* with value-type arguments
*/
[Test]
public void LuaDelegateValueTypes()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x,y) return x+y; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callDelegate1(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with value-type arguments and out params
*/
[Test]
public void LuaDelegateValueTypesOutParam()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x) return x,x*2; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callDelegate2(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(6, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with value-type arguments and ref params
*/
[Test]
public void LuaDelegateValueTypesByRefParam()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x,y) return x+y; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callDelegate3(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with value-type arguments that returns a reference type
*/
[Test]
public void LuaDelegateValueTypesReturnReferenceType()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x,y) return TestClass(x+y); end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callDelegate4(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with reference type arguments
*/
[Test]
public void LuaDelegateReferenceTypes()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x,y) return x.testval+y.testval; end");
lua.DoString("a=test:callDelegate5(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with reference type arguments and an out param
*/
[Test]
public void LuaDelegateReferenceTypesOutParam()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x) return x,TestClass(x*2); end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callDelegate6(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(6, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with reference type arguments and a ref param
*/
[Test]
public void LuaDelegateReferenceTypesByRefParam()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x,y) return TestClass(x+y.testval); end");
lua.DoString("a=test:callDelegate7(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua table as an interface and
* calling one of its methods with value-type params
*/
[Test]
public void NLuaAAValueTypes()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("itest={}");
lua.DoString("function itest:test1(x,y) return x+y; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callInterface1(itest)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("interface returned: "+a);
}
}
/*
* Tests making an object from a Lua table and calling the base
* class version of one of the methods the table overrides.
*/
[Test]
public void LuaTableBaseMethod()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test={}");
lua.DoString("function test:overridableMethod(x,y) print(self[base]); return 6 end");
lua.DoString("luanet.make_object(test,'NLuaTest.Mock.TestClass')");
lua.DoString("a=TestClass.callOverridable(test,2,3)");
int a = (int)lua.GetNumber("a");
lua.DoString("luanet.free_object(test)");
Assert.AreEqual(6, a);
}
}
}
}
using System;
using NLua;
using System.IO;
using LoadFileTests;
using NUnit.Framework;
#if __IOS__ || __TVOS__ || __WATCHOS__
using Foundation;
#endif
namespace NLuaTest
{
[TestFixture]
#if __IOS__ || __TVOS__ || __WATCHOS__
[Preserve (AllMembers = true)]
#endif
public class Core
{
Lua lua = null;
string GetTestPath(string name)
{
string core = LoadLuaFile.GetScriptsPath("core");
return Path.Combine(core, name + ".lua");
}
void AssertFile(string path)
{
lua.DoFile(path);
}
void TestLuaFile(string name)
{
string path = GetTestPath(name);
AssertFile(path);
}
[SetUp]
public void Setup()
{
lua = new Lua();
lua.RegisterFunction("WriteLineString", typeof(Console).GetMethod("WriteLine", new Type[] { typeof(String) }));
lua.DoString(@"
function print (param)
WriteLineString (tostring(param))
end
");
}
[TearDown]
public void TearDown()
{
lua.Dispose();
lua = null;
}
[Test]
public void Bisect()
{
TestLuaFile("bisect");
}
[Test]
public void CF()
{
TestLuaFile("cf");
}
[Test]
public void Factorial()
{
TestLuaFile("factorial");
}
[Test]
public void FibFor()
{
TestLuaFile("fibfor");
}
[Test]
public void Life()
{
TestLuaFile("life");
}
[Test]
public void Printf()
{
TestLuaFile("printf");
}
[Test]
public void Sieve()
{
TestLuaFile("sieve");
}
[Test]
public void Sort()
{
TestLuaFile("sort");
}
}
}
using System;
namespace NLuaTest.Mock
{
public class Entity
{
public event EventHandler<EventArgs> Clicked;
protected virtual void OnEntityClicked(EventArgs e)
{
EventHandler<EventArgs> handler = Clicked;
if (handler != null)
{
handler(this, e);
}
}
public string Property
{
get;
set;
}
// default ctor
public Entity()
{
Property = "Default";
}
// string ctor
public Entity(string param)
{
Property = "String";
}
public Entity(int param)
{
Property = "Int";
}
public void Click()
{
OnEntityClicked(new EventArgs());
}
}
}
using System;
using System.IO;
using NLua;
using NLuaTest.Mock;
using NUnit.Framework;
#if __IOS__ || __TVOS__ || __WATCHOS__
using Foundation;
#endif
namespace LoadFileTests
{
[TestFixture]
#if __IOS__ || __TVOS__ || __WATCHOS__
[Preserve (AllMembers = true)]
#endif
public class LoadLuaFile
{
public static string GetScriptsPath(string name)
{
string path = new Uri(typeof(LoadLuaFile).Assembly.CodeBase).AbsolutePath;
path = Path.GetDirectoryName(path);
path = Path.Combine(path, "scripts");
path = Path.Combine (path, name);
return path;
}
/*
* Tests capturing an exception
*/
[Test]
public void TestLoadFile()
{
using (Lua lua = new Lua())
{
lua.LoadCLRPackage();
string file = GetScriptsPath("test.lua");
lua.DoFile(file);
int width = (int)(double)lua["width"];
int height = (int)(double)lua["height"];
string message = (string)lua["message"];
int color_g = (int)(double)lua["color.g"];
LuaFunction func = (LuaFunction)lua["func"];
object[] res = func.Call(12, 34);
int x = (int)(double)res[0];
int y = (int)(double)res[1];
//function func(x,y)
// return x,x+y
//end
Assert.AreEqual(100, width);
Assert.AreEqual(200, height);
Assert.AreEqual("Hello World!", message);
Assert.AreEqual(20, color_g);
Assert.AreEqual(12, x);
Assert.AreEqual(46, y);
}
}
[Test]
public void TestBinaryLoadFile()
{
using (Lua lua = new Lua())
{
string file;
lua.LoadCLRPackage();
if (IntPtr.Size == 4)
file = GetScriptsPath("test_32.luac");
else
file = GetScriptsPath("test_64.luac");
lua.DoFile(file);
int width = (int)(double)lua["width"];
int height = (int)(double)lua["height"];
string message = (string)lua["message"];
int color_g = (int)(double)lua["color.g"];
LuaFunction func = (LuaFunction)lua["func"];
object[] res = func.Call(12, 34);
int x = (int)(double)res[0];
int y = (int)(double)res[1];
Assert.AreEqual(100, width);
Assert.AreEqual(200, height);
Assert.AreEqual("Hello World!", message);
Assert.AreEqual(20, color_g);
Assert.AreEqual(12, x);
Assert.AreEqual(46, y);
}
}
}
}
using System;
using System.IO;
using System.Text;
using NLuaTest.Mock;
using System.Reflection;
using System.Threading;
using LoadFileTests;
using NLua;
using NLua.Exceptions;
#if __IOS__ || __TVOS__ || __WATCHOS__
using Foundation;
#endif
using NUnit.Framework;
namespace NLuaTest
{
public class parameter
{
public string field1 = "parameter-field1";
}
#if __IOS__ || __TVOS__ || __WATCHOS__
[Preserve (AllMembers = true)]
#endif
public class master
{
public static string read()
{
return "test-master";
}
public static string read(parameter test)
{
return test.field1;
}
}
#if __IOS__ || __TVOS__ || __WATCHOS__
[Preserve (AllMembers = true)]
#endif
public class testClass : master
{
public String strData;
public int intData;
public static string read2()
{
return "test";
}
public static string read(int test)
{
return "int-test";
}
}
#if __IOS__ || __TVOS__ || __WATCHOS__
[Preserve (AllMembers = true)]
#endif
public class DefaultElementModel
{
public Action<double> DrawMe { get; set; }
}
#if __IOS__ || __TVOS__ || __WATCHOS__
[Preserve (AllMembers = true)]
#endif
public class TestCaseName
{
public string name = "name";
public string Name => "**" + name + "**";
}
#if __IOS__ || __TVOS__ || __WATCHOS__
[Preserve (AllMembers = true)]
#endif
public class Vector
{
public double x;
public double y;
public static Vector operator *(float k, Vector v)
{
var r = new Vector();
r.x = v.x * k;
r.y = v.y * k;
return r;
}
public static Vector operator *(Vector v, float k)
{
var r = new Vector();
r.x = v.x * k;
r.y = v.y * k;
return r;
}
public void Func()
{
Console.WriteLine("Func");
}
}
public static class VectorExtension
{
public static double Length(this Vector v)
{
return v.x * v.x + v.y * v.y;
}
}
#if __IOS__ || __TVOS__ || __WATCHOS__
[Preserve (AllMembers = true)]
#endif
public class Person
{
public string firstName;
}
#if __IOS__ || __TVOS__ || __WATCHOS__
[Preserve (AllMembers = true)]
#endif
public class Employee : Person
{
public string occupation;
}
public static class PersonExentsions
{
public static string GetFirstName(this Person argPerson)
{
return argPerson.firstName;
}
}
[TestFixture]
#if __IOS__ || __TVOS__ || __WATCHOS__
[Preserve (AllMembers = true)]
#endif
public class LuaTests
{
public static readonly char UnicodeChar = '\uE007';
public static string UnicodeString
{
get
{
return Convert.ToString(UnicodeChar);
}
}
public static string UnicodeStringRussian
{
get
{
return "Файл";
}
}
/*
* Tests capturing an exception
*/
[Test]
public void ThrowException()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("err,errMsg=pcall(test.exceptionMethod,test)");
bool err = (bool)lua["err"];
Exception errMsg = (Exception)lua["errMsg"];
Assert.AreEqual(false, err);
Assert.AreNotEqual(null, errMsg.InnerException);
Assert.AreEqual("exception test", errMsg.InnerException.Message);
}
}
/*
* Tests passing a LuaFunction
*/
[Test]
public void CallLuaFunction()
{
using (Lua lua = new Lua())
{
lua.DoString("function someFunc(v1,v2) return v1 + v2 end");
lua["funcObject"] = lua.GetFunction("someFunc");
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("b = TestClass():TestLuaFunction(funcObject)[0]");
Assert.AreEqual(3, lua["b"]);
lua.DoString("a = TestClass():TestLuaFunction(nil)");
Assert.AreEqual(null, lua["a"]);
}
}
/*
* Tests capturing an exception
*/
[Test]
public void ThrowUncaughtException()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
try
{
lua.DoString("test:exceptionMethod()");
//failed
Assert.AreEqual(false, true);
}
catch (Exception)
{
//passed
Assert.AreEqual(true, true);
}
}
}
/*
* Tests nullable fields
*/
[Test]
public void TestNullable()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("val=test.NullableBool");
Assert.AreEqual(null, (object)lua["val"]);
lua.DoString("test.NullableBool = true");
lua.DoString("val=test.NullableBool");
Assert.AreEqual(true, (bool)lua["val"]);
}
}
/*
* Tests structure assignment
*/
[Test]
public void TestStructs()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("TestStruct=luanet.import_type('NLuaTest.Mock.TestStruct')");
lua.DoString("struct=TestStruct(2)");
lua.DoString("test.Struct = struct");
lua.DoString("val=test.Struct.val");
Assert.AreEqual(2.0d, (double)lua["val"]);
}
}
/*
* Tests structure creation via the default constructor
*/
[Test]
public void TestStructDefaultConstructor()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestStruct=luanet.import_type('NLuaTest.Mock.TestStruct')");
lua.DoString("struct=TestStruct()");
Assert.AreEqual(new TestStruct(), (TestStruct)lua["struct"]);
}
}
[Test]
public void TestStructHashesEqual()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestStruct=luanet.import_type('NLuaTest.Mock.TestStruct')");
lua.DoString("struct1=TestStruct(0)");
lua.DoString("struct2=TestStruct(0)");
lua.DoString("struct2.val=1");
Assert.AreEqual(0, (double)lua["struct1.val"]);
}
}
[Test]
public void TestEnumEqual()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestEnum=luanet.import_type('NLuaTest.Mock.TestEnum')");
lua.DoString("enum1=TestEnum.ValueA");
lua.DoString("enum2=TestEnum.ValueB");
Assert.AreEqual(true, (bool)lua.DoString("return enum1 ~= enum2")[0]);
Assert.AreEqual(false, (bool)lua.DoString("return enum1 == enum2")[0]);
}
}
[Test]
public void TestMethodOverloads()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("test:MethodOverload()");
lua.DoString("test:MethodOverload(test)");
lua.DoString("test:MethodOverload(1,1,1)");
lua.DoString("test:MethodOverload(2,2,i)\r\nprint(i)");
}
}
[Test]
public void TestDispose()
{
GC.Collect();
long startingMem = System.Diagnostics.Process.GetCurrentProcess().WorkingSet64;
for (int i = 0; i < 300; i++)
{
using (Lua lua = new Lua())
{
_Calc(lua, i);
}
}
long endMem = System.Diagnostics.Process.GetCurrentProcess().WorkingSet64;
Console.WriteLine("Was using " + startingMem / 1024 / 1024 + "MB, now using: " + endMem / 1024 / 1024 + "MB");
}
private void _Calc(Lua lua, int i)
{
lua.DoString(
"sqrt = math.sqrt;" +
"sqr = function(x) return math.pow(x,2); end;" +
"log = math.log;" +
"log10 = math.log10;" +
"exp = math.exp;" +
"sin = math.sin;" +
"cos = math.cos;" +
"tan = math.tan;" +
"abs = math.abs;"
);
lua.DoString("function calcVP(a,b) return a+b end");
//LuaFunction lf = lua.GetFunction("calcVP");
//lf.Call(i, 20);
}
[Test]
public void TestThreading()
{
using (Lua lua = new Lua())
{
object lua_locker = new object();
DoWorkClass doWork = new DoWorkClass();
lua.RegisterFunction("dowork", doWork, typeof(DoWorkClass).GetMethod("DoWork"));
bool failureDetected = false;
int completed = 0;
int iterations = 10;
for (int i = 0; i < iterations; i++)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate (object o)
{
try
{
lock (lua_locker)
{
lua.DoString("dowork()");
}
}
catch (Exception e)
{
Console.Write(e);
failureDetected = true;
}
completed++;
}));
}
while (completed < iterations && !failureDetected)
Thread.Sleep(50);
Assert.AreEqual(false, failureDetected);
}
}
[Test]
public void TestPrivateMethod()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
try
{
lua.DoString("test:_PrivateMethod()");
}
catch
{
Assert.AreEqual(true, true);
return;
}
Assert.AreEqual(true, false);
}
}
/*
* Tests functions
*/
[Test]
public void TestFunctions()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.RegisterFunction("p", null, typeof(Console).GetMethod("WriteLine", new [] { typeof(string) }));
lua.DoString("p('Foo')");
// Yet this works...
lua.DoString("string.gsub('some string', '(%w+)', function(s) p(s) end)");
}
}
/*
* Tests making an object from a Lua table and calling one of
* methods the table overrides.
*/
[Test]
public void LuaTableOverridedMethod()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test={}");
lua.DoString("function test:overridableMethod(x,y) return x*y; end");
lua.DoString("luanet.make_object(test,'NLuaTest.Mock.TestClass')");
lua.DoString("a=TestClass.callOverridable(test,2,3)");
int a = (int)lua.GetNumber("a");
lua.DoString("luanet.free_object(test)");
Assert.AreEqual(6, a);
}
}
/*
* Tests making an object from a Lua table and calling a method
* the table does not override.
*/
[Test]
public void LuaTableInheritedMethod()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test={}");
lua.DoString("function test:overridableMethod(x,y) return x*y; end");
lua.DoString("luanet.make_object(test,'NLuaTest.Mock.TestClass')");
lua.DoString("test:setVal(3)");
lua.DoString("a=test.testval");
int a = (int)lua.GetNumber("a");
lua.DoString("luanet.free_object(test)");
Assert.AreEqual(3, a);
//Console.WriteLine("interface returned: "+a);
}
}
/// <summary>
/// Basic multiply method which expects 2 floats
/// </summary>
/// <param name="val"></param>
/// <param name="val2"></param>
/// <returns></returns>
private float _TestException(float val, float val2)
{
return val * val2;
}
class LuaEventArgsHandler : NLua.Method.LuaDelegate
{
void CallFunction(object sender, EventArgs eventArgs)
{
object[] args = new object[] { sender, eventArgs };
object[] inArgs = new object[] { sender, eventArgs };
int[] outArgs = new int[] { };
base.CallFunction(args, inArgs, outArgs);
}
}
[Test]
public void TestEventException()
{
using (Lua lua = new Lua())
{
//Register a C# function
MethodInfo testException = this.GetType().GetMethod("_TestException", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance, null, new Type[] {
typeof(float),
typeof(float)
}, null);
lua.RegisterFunction("Multiply", this, testException);
lua.RegisterLuaDelegateType(typeof(EventHandler<EventArgs>), typeof(LuaEventArgsHandler));
//create the lua event handler code for the entity
//includes the bad code!
lua.DoString("function OnClick(sender, eventArgs)\r\n" +
"--Multiply expects 2 floats, but instead receives 2 strings\r\n" +
"Multiply(asd, es)\r\n" +
"end");
//create the lua event handler code for the entity
//good code
//lua.DoString("function OnClick(sender, eventArgs)\r\n" +
// "--Multiply expects 2 floats\r\n" +
// "Multiply(2, 50)\r\n" +
// "end");
//Create the event handler script
lua.DoString("function SubscribeEntity(e)\r\ne.Clicked:Add(OnClick)\r\nend");
//Create the entity object
Entity entity = new Entity();
//Register the entity object with the event handler inside lua
LuaFunction lf = lua.GetFunction("SubscribeEntity");
lf.Call(new object[1] { entity });
try
{
//Cause the event to be fired
entity.Click();
//failed
Assert.AreEqual(true, false);
}
catch (LuaException)
{
//passed
Assert.AreEqual(true, true);
}
}
}
[Test]
public void TestExceptionWithChunkOverload()
{
using (Lua lua = new Lua())
{
try
{
lua.DoString("thiswillthrowanerror", "MyChunk");
}
catch (Exception e)
{
Assert.AreEqual(true, e.Message.StartsWith("[string \"MyChunk\"]"));
}
}
}
[Test]
public void TestGenerics()
{
//Im not sure support for generic classes is possible to implement, see: http://msdn.microsoft.com/en-us/library/system.reflection.methodinfo.containsgenericparameters.aspx
//specifically the line that says: "If the ContainsGenericParameters property returns true, the method cannot be invoked"
//TestClassGeneric<string> genericClass = new TestClassGeneric<string>();
//lua.RegisterFunction("genericMethod", genericClass, typeof(TestClassGeneric<>).GetMethod("GenericMethod"));
//lua.RegisterFunction("regularMethod", genericClass, typeof(TestClassGeneric<>).GetMethod("RegularMethod"));
using (Lua lua = new Lua())
{
TestClassWithGenericMethod classWithGenericMethod = new TestClassWithGenericMethod();
////////////////////////////////////////////////////////////////////////////
/// ////////////////////////////////////////////////////////////////////////
/// IMPORTANT: Use generic method with the type you will call or generic methods will fail with iOS
/// ////////////////////////////////////////////////////////////////////////
classWithGenericMethod.GenericMethod<double>(99.0);
classWithGenericMethod.GenericMethod<TestClass>(new TestClass(99));
////////////////////////////////////////////////////////////////////////////
/// ////////////////////////////////////////////////////////////////////////
lua.RegisterFunction("genericMethod2", classWithGenericMethod, typeof(TestClassWithGenericMethod).GetMethod("GenericMethod"));
try
{
lua.DoString("genericMethod2(100)");
}
catch
{
}
Assert.AreEqual(true, classWithGenericMethod.GenericMethodSuccess);
Assert.AreEqual(true, classWithGenericMethod.Validate<double>(100)); //note the gotcha: numbers are all being passed to generic methods as doubles
try
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass(56)");
lua.DoString("genericMethod2(test)");
}
catch
{
}
Assert.AreEqual(true, classWithGenericMethod.GenericMethodSuccess);
Assert.AreEqual(56, (classWithGenericMethod.PassedValue as TestClass).val);
}
}
[Test]
public void RegisterFunctionStressTest()
{
const int Count = 200; // it seems to work with 41
using (Lua lua = new Lua())
{
MyClass t = new MyClass();
for (int i = 1; i < Count - 1; ++i)
{
lua.RegisterFunction("func" + i, t, typeof(MyClass).GetMethod("Func1"));
}
lua.RegisterFunction("func" + (Count - 1), t, typeof(MyClass).GetMethod("Func1"));
lua.DoString("print(func1())");
}
}
[Test]
public void TestMultipleOutParameters()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
lua["netobj"] = t1;
lua.DoString("a,b,c=netobj:outValMutiple(2)");
int a = (int)lua.GetNumber("a");
string b = (string)lua.GetString("b");
string c = (string)lua.GetString("c");
Assert.AreEqual(2, a);
Assert.AreNotEqual(null, b);
Assert.AreNotEqual(null, c);
}
}
[Test]
public void TestLoadStringLeak()
{
//Test to prevent stack overflow
//See: http://code.google.com/p/nlua/issues/detail?id=5
//number of iterations to test
int count = 1000;
using (Lua lua = new Lua())
{
for (int i = 0; i < count; i++)
{
lua.LoadString("abc = 'def'", string.Empty);
}
}
//any thrown exceptions cause the test run to fail
}
[Test]
public void TestLoadFileLeak()
{
//Test to prevent stack overflow
//See: http://code.google.com/p/luainterface/issues/detail?id=5
//number of iterations to test
int count = 1000;
string file = LoadLuaFile.GetScriptsPath("test.lua");
using (Lua lua = new Lua())
{
for (int i = 0; i < count; i++)
{
lua.LoadFile(file);
}
}
//any thrown exceptions cause the test run to fail
}
[Test]
public void TestRegisterFunction()
{
using (Lua lua = new Lua())
{
lua.RegisterFunction("func1", null, typeof(TestClass2).GetMethod("func"));
object[] vals1 = lua.GetFunction("func1").Call(2, 3);
Assert.AreEqual(5.0f, Convert.ToSingle(vals1[0]));
TestClass2 obj = new TestClass2();
lua.RegisterFunction("func2", obj, typeof(TestClass2).GetMethod("funcInstance"));
vals1 = lua.GetFunction("func2").Call(2, 3);
Assert.AreEqual(5.0f, Convert.ToSingle(vals1[0]));
}
}
/*
* Tests passing a null object as a parameter to a
* method that accepts a nullable.
*/
[Test]
public void TestNullableParameter()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("a = test:NullableMethod(nil)");
Assert.AreEqual(null, lua["a"]);
lua["timeVal"] = TimeSpan.FromSeconds(5);
lua.DoString("b = test:NullableMethod(timeVal)");
Assert.AreEqual(TimeSpan.FromSeconds(5), lua["b"]);
lua.DoString("d = test:NullableMethod2(2)");
Assert.AreEqual(2, lua["d"]);
lua.DoString("c = test:NullableMethod2(nil)");
Assert.AreEqual(null, lua["c"]);
}
}
/*
* Tests if DoString is correctly returning values
*/
[Test]
public void DoString()
{
using (Lua lua = new Lua())
{
object[] res = lua.DoString("a=2\nreturn a,3");
//Console.WriteLine("a="+res[0]+", b="+res[1]);
Assert.AreEqual(res[0], 2d);
Assert.AreEqual(res[1], 3d);
}
}
/*
* Tests getting of global numeric variables
*/
[Test]
public void GetGlobalNumber()
{
using (Lua lua = new Lua())
{
lua.DoString("a=2");
double num = lua.GetNumber("a");
//Console.WriteLine("a="+num);
Assert.AreEqual(num, 2d);
}
}
/*
* Tests setting of global numeric variables
*/
[Test]
public void SetGlobalNumber()
{
using (Lua lua = new Lua())
{
lua.DoString("a=2");
lua["a"] = 3;
double num = lua.GetNumber("a");
//Console.WriteLine("a="+num);
Assert.AreEqual(num, 3d);
}
}
/*
* Tests getting of numeric variables from tables
* by specifying variable path
*/
[Test]
public void GetNumberInTable()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=2}}");
double num = lua.GetNumber("a.b.c");
//Console.WriteLine("a.b.c="+num);
Assert.AreEqual(num, 2d);
}
}
/*
* Tests setting of numeric variables from tables
* by specifying variable path
*/
[Test]
public void SetNumberInTable()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=2}}");
lua["a.b.c"] = 3;
double num = lua.GetNumber("a.b.c");
//Console.WriteLine("a.b.c="+num);
Assert.AreEqual(num, 3d);
}
}
/*
* Tests getting of global string variables
*/
[Test]
public void GetGlobalString()
{
using (Lua lua = new Lua())
{
lua.DoString("a=\"test\"");
string str = lua.GetString("a");
//Console.WriteLine("a="+str);
Assert.AreEqual(str, "test");
}
}
/*
* Tests setting of global string variables
*/
[Test]
public void SetGlobalString()
{
using (Lua lua = new Lua())
{
lua.DoString("a=\"test\"");
lua["a"] = "new test";
string str = lua.GetString("a");
//Console.WriteLine("a="+str);
Assert.AreEqual(str, "new test");
}
}
/*
* Tests getting of string variables from tables
* by specifying variable path
*/
[Test]
public void GetStringInTable()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=\"test\"}}");
string str = lua.GetString("a.b.c");
//Console.WriteLine("a.b.c="+str);
Assert.AreEqual(str, "test");
}
}
/*
* Tests setting of string variables from tables
* by specifying variable path
*/
[Test]
public void SetStringInTable()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=\"test\"}}");
lua["a.b.c"] = "new test";
string str = lua.GetString("a.b.c");
//Console.WriteLine("a.b.c="+str);
Assert.AreEqual(str, "new test");
}
}
/*
* Tests getting and setting of global table variables
*/
[Test]
public void GetAndSetTable()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=2}}\nb={c=3}");
LuaTable tab = lua.GetTable("b");
lua["a.b"] = tab;
double num = lua.GetNumber("a.b.c");
//Console.WriteLine("a.b.c="+num);
Assert.AreEqual(num, 3d);
}
}
/*
* Tests getting of numeric field of a table
*/
[Test]
public void GetTableNumericField1()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=2}}");
LuaTable tab = lua.GetTable("a.b");
double num = (double)tab["c"];
//Console.WriteLine("a.b.c="+num);
Assert.AreEqual(num, 2d);
}
}
/*
* Tests getting of numeric field of a table
* (the field is inside a subtable)
*/
[Test]
public void GetTableNumericField2()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=2}}");
LuaTable tab = lua.GetTable("a");
double num = (double)tab["b.c"];
//Console.WriteLine("a.b.c="+num);
Assert.AreEqual(num, 2d);
}
}
/*
* Tests setting of numeric field of a table
*/
[Test]
public void SetTableNumericField1()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=2}}");
LuaTable tab = lua.GetTable("a.b");
tab["c"] = 3;
double num = lua.GetNumber("a.b.c");
//Console.WriteLine("a.b.c="+num);
Assert.AreEqual(num, 3d);
}
}
/*
* Tests setting of numeric field of a table
* (the field is inside a subtable)
*/
[Test]
public void SetTableNumericField2()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=2}}");
LuaTable tab = lua.GetTable("a");
tab["b.c"] = 3;
double num = lua.GetNumber("a.b.c");
//Console.WriteLine("a.b.c="+num);
Assert.AreEqual(num, 3d);
}
}
/*
* Tests getting of string field of a table
*/
[Test]
public void GetTableStringField1()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=\"test\"}}");
LuaTable tab = lua.GetTable("a.b");
string str = (string)tab["c"];
//Console.WriteLine("a.b.c="+str);
Assert.AreEqual(str, "test");
}
}
/*
* Tests getting of string field of a table
* (the field is inside a subtable)
*/
[Test]
public void GetTableStringField2()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=\"test\"}}");
LuaTable tab = lua.GetTable("a");
string str = (string)tab["b.c"];
//Console.WriteLine("a.b.c="+str);
Assert.AreEqual(str, "test");
}
}
/*
* Tests setting of string field of a table
*/
[Test]
public void SetTableStringField1()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=\"test\"}}");
LuaTable tab = lua.GetTable("a.b");
tab["c"] = "new test";
string str = lua.GetString("a.b.c");
//Console.WriteLine("a.b.c="+str);
Assert.AreEqual(str, "new test");
}
}
/*
* Tests setting of string field of a table
* (the field is inside a subtable)
*/
[Test]
public void SetTableStringField2()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=\"test\"}}");
LuaTable tab = lua.GetTable("a");
tab["b.c"] = "new test";
string str = lua.GetString("a.b.c");
//Console.WriteLine("a.b.c="+str);
Assert.AreEqual(str, "new test");
}
}
/*
* Tests calling of a global function with zero arguments
*/
[Test]
public void CallGlobalFunctionNoArgs()
{
using (Lua lua = new Lua())
{
lua.DoString("a=2\nfunction f()\na=3\nend");
lua.GetFunction("f").Call();
double num = lua.GetNumber("a");
//Console.WriteLine("a="+num);
Assert.AreEqual(num, 3d);
}
}
/*
* Tests calling of a global function with one argument
*/
[Test]
public void CallGlobalFunctionOneArg()
{
using (Lua lua = new Lua())
{
lua.DoString("a=2\nfunction f(x)\na=a+x\nend");
lua.GetFunction("f").Call(1);
double num = lua.GetNumber("a");
//Console.WriteLine("a="+num);
Assert.AreEqual(num, 3d);
}
}
/*
* Tests calling of a global function with two arguments
*/
[Test]
public void CallGlobalFunctionTwoArgs()
{
using (Lua lua = new Lua())
{
lua.DoString("a=2\nfunction f(x,y)\na=x+y\nend");
lua.GetFunction("f").Call(1, 3);
double num = lua.GetNumber("a");
//Console.WriteLine("a="+num);
Assert.AreEqual(num, 4d);
}
}
/*
* Tests calling of a global function that returns one value
*/
[Test]
public void CallGlobalFunctionOneReturn()
{
using (Lua lua = new Lua())
{
lua.DoString("function f(x)\nreturn x+2\nend");
object[] ret = lua.GetFunction("f").Call(3);
//Console.WriteLine("ret="+ret[0]);
Assert.AreEqual(1, ret.Length);
Assert.AreEqual(5, (double)ret[0]);
}
}
/*
* Tests calling of a global function that returns two values
*/
[Test]
public void CallGlobalFunctionTwoReturns()
{
using (Lua lua = new Lua())
{
lua.DoString("function f(x,y)\nreturn x,x+y\nend");
object[] ret = lua.GetFunction("f").Call(3, 2);
//Console.WriteLine("ret="+ret[0]+","+ret[1]);
Assert.AreEqual(2, ret.Length);
Assert.AreEqual(3, (double)ret[0]);
Assert.AreEqual(5, (double)ret[1]);
}
}
/*
* Tests calling of a function inside a table
*/
[Test]
public void CallTableFunctionTwoReturns()
{
using (Lua lua = new Lua())
{
lua.DoString("a={}\nfunction a.f(x,y)\nreturn x,x+y\nend");
object[] ret = lua.GetFunction("a.f").Call(3, 2);
//Console.WriteLine("ret="+ret[0]+","+ret[1]);
Assert.AreEqual(2, ret.Length);
Assert.AreEqual(3, (double)ret[0]);
Assert.AreEqual(5, (double)ret[1]);
}
}
/*
* Tests setting of a global variable to a CLR object value
*/
[Test]
public void SetGlobalObject()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
t1.testval = 4;
lua["netobj"] = t1;
object o = lua["netobj"];
Assert.AreEqual(true, o is TestClass);
TestClass t2 = (TestClass)lua["netobj"];
Assert.AreEqual(t2.testval, 4);
Assert.AreEqual(t1, t2);
}
}
///*
// * Tests if CLR object is being correctly collected by Lua
// */
//[Test]
//public void GarbageCollection()
//{
// using (Lua lua = new Lua())
// {
// TestClass t1 = new TestClass();
// t1.testval = 4;
// lua["netobj"] = t1;
// TestClass t2 = (TestClass)lua["netobj"];
// Assert.True(lua[0] != null);
// lua.DoString("netobj=nil;collectgarbage();");
// Assert.True(lua.translator.objects[0] == null);
// }
//}
/*
* Tests setting of a table field to a CLR object value
*/
[Test]
public void SetTableObjectField1()
{
using (Lua lua = new Lua())
{
lua.DoString("a={b={c=\"test\"}}");
LuaTable tab = lua.GetTable("a.b");
TestClass t1 = new TestClass();
t1.testval = 4;
tab["c"] = t1;
TestClass t2 = (TestClass)lua["a.b.c"];
//Console.WriteLine("a.b.c="+t2.testval);
Assert.AreEqual(4, t2.testval);
Assert.AreEqual(t1, t2);
}
}
/*
* Tests reading and writing of an object's field
*/
[Test]
public void AccessObjectField()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
t1.val = 4;
lua["netobj"] = t1;
lua.DoString("var=netobj.val");
double var = (double)lua["var"];
//Console.WriteLine("value from Lua="+var);
Assert.AreEqual(4, var);
lua.DoString("netobj.val=3");
Assert.AreEqual(3, t1.val);
//Console.WriteLine("new val (from Lua)="+t1.val);
}
}
/*
* Tests reading and writing of an object's non-indexed
* property
*/
[Test]
public void AccessObjectProperty()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
t1.testval = 4;
lua["netobj"] = t1;
lua.DoString("var=netobj.testval");
double var = (double)lua["var"];
//Console.WriteLine("value from Lua="+var);
Assert.AreEqual(4, var);
lua.DoString("netobj.testval=3");
Assert.AreEqual(3, t1.testval);
//Console.WriteLine("new val (from Lua)="+t1.testval);
}
}
[Test]
public void AccessObjectStringProperty()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
t1.teststrval = "This is a string test";
lua["netobj"] = t1;
lua.DoString("var=netobj.teststrval");
string var = (string)lua["var"];
Assert.AreEqual("This is a string test", var);
lua.DoString("netobj.teststrval='Another String'");
Assert.AreEqual("Another String", t1.teststrval);
//Console.WriteLine("new val (from Lua)="+t1.testval);
}
}
/*
* Tests calling of an object's method with no overloads
*/
[Test]
public void CallObjectMethod()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
t1.testval = 4;
lua["netobj"] = t1;
lua.DoString("netobj:setVal(3)");
Assert.AreEqual(3, t1.testval);
//Console.WriteLine("new val(from C#)="+t1.testval);
lua.DoString("val=netobj:getVal()");
int val = (int)lua.GetNumber("val");
Assert.AreEqual(3, val);
//Console.WriteLine("new val(from Lua)="+val);
}
}
/*
* Tests calling of an object's method with overloading
*/
[Test]
public void CallObjectMethodByType()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
lua["netobj"] = t1;
lua.DoString("netobj:setVal('str')");
Assert.AreEqual("str", t1.getStrVal());
//Console.WriteLine("new val(from C#)="+t1.getStrVal());
}
}
/*
* Tests calling of an object's method with no overloading
* and out parameters
*/
[Test]
public void CallObjectMethodOutParam()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
lua["netobj"] = t1;
lua.DoString("a,b=netobj:outVal()");
int a = (int)lua.GetNumber("a");
int b = (int)lua.GetNumber("b");
Assert.AreEqual(3, a);
Assert.AreEqual(5, b);
//Console.WriteLine("function returned (from lua)="+a+","+b);
}
}
/*
* Tests calling of an object's method with overloading and
* out params
*/
[Test]
public void CallObjectMethodOverloadedOutParam()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
lua["netobj"] = t1;
lua.DoString("a,b=netobj:outVal(2)");
int a = (int)lua.GetNumber("a");
int b = (int)lua.GetNumber("b");
Assert.AreEqual(2, a);
Assert.AreEqual(5, b);
//Console.WriteLine("function returned (from lua)="+a+","+b);
}
}
/*
* Tests calling of an object's method with ref params
*/
[Test]
public void CallObjectMethodByRefParam()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
lua["netobj"] = t1;
lua.DoString("a,b=netobj:outVal(2,3)");
int a = (int)lua.GetNumber("a");
int b = (int)lua.GetNumber("b");
Assert.AreEqual(2, a);
Assert.AreEqual(5, b);
//Console.WriteLine("function returned (from lua)="+a+","+b);
}
}
/*
* Tests calling of two versions of an object's method that have
* the same name and signature but implement different interfaces
*/
[Test]
public void CallObjectMethodDistinctInterfaces()
{
using (Lua lua = new Lua())
{
TestClass t1 = new TestClass();
lua["netobj"] = t1;
lua.DoString("a=netobj:foo()");
lua.DoString("b=netobj['NLuaTest.Mock.IFoo1.foo']");
int a = (int)lua.GetNumber("a");
int b = (int)lua.GetNumber("b");
Assert.AreEqual(5, a);
Assert.AreEqual(1, b);
//Console.WriteLine("function returned (from lua)="+a+","+b);
}
}
/*
* Tests instantiating an object with no-argument constructor
*/
[Test]
public void CreateNetObjectNoArgsCons()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly(\"NLuaTest\")");
lua.DoString("TestClass=luanet.import_type(\"NLuaTest.Mock.TestClass\")");
lua.DoString("test=TestClass()");
lua.DoString("test:setVal(3)");
object[] res = lua.DoString("return test");
TestClass test = (TestClass)res[0];
//Console.WriteLine("returned: "+test.testval);
Assert.AreEqual(3, test.testval);
}
}
/*
* Tests instantiating an object with one-argument constructor
*/
[Test]
public void CreateNetObjectOneArgCons()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly(\"NLuaTest\")");
lua.DoString("TestClass=luanet.import_type(\"NLuaTest.Mock.TestClass\")");
lua.DoString("test=TestClass(3)");
object[] res = lua.DoString("return test");
TestClass test = (TestClass)res[0];
//Console.WriteLine("returned: "+test.testval);
Assert.AreEqual(3, test.testval);
}
}
/*
* Tests instantiating an object with overloaded constructor
*/
[Test]
public void CreateNetObjectOverloadedCons()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly(\"NLuaTest\")");
lua.DoString("TestClass=luanet.import_type(\"NLuaTest.Mock.TestClass\")");
lua.DoString("test=TestClass('str')");
object[] res = lua.DoString("return test");
TestClass test = (TestClass)res[0];
//Console.WriteLine("returned: "+test.getStrVal());
Assert.AreEqual("str", test.getStrVal());
}
}
/*
* Tests getting item of a CLR array
*/
[Test]
public void ReadArrayField()
{
using (Lua lua = new Lua())
{
string[] arr = new string[] { "str1", "str2", "str3" };
lua["netobj"] = arr;
lua.DoString("val=netobj[1]");
string val = lua.GetString("val");
Assert.AreEqual("str2", val);
//Console.WriteLine("new val(from array to Lua)="+val);
}
}
/*G
* Tests setting item of a CLR array
*/
[Test]
public void WriteArrayField()
{
using (Lua lua = new Lua())
{
string[] arr = new string[] { "str1", "str2", "str3" };
lua["netobj"] = arr;
lua.DoString("netobj[1]='test'");
Assert.AreEqual("test", arr[1]);
//Console.WriteLine("new val(from Lua to array)="+arr[1]);
}
}
/*
* Tests creating a new CLR array
*/
[Test]
public void CreateArray()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly(\"NLuaTest\")");
lua.DoString("TestClass=luanet.import_type(\"NLuaTest.Mock.TestClass\")");
lua.DoString("arr=TestClass[3]");
lua.DoString("for i=0,2 do arr[i]=TestClass(i+1) end");
TestClass[] arr = (TestClass[])lua["arr"];
Assert.AreEqual(arr[1].testval, 2);
}
}
/*
* Tests passing a Lua function to a delegate
* with value-type arguments
*/
[Test]
public void LuaDelegateValueTypes()
{
using (Lua lua = new Lua())
{
lua.RegisterLuaDelegateType(typeof(TestDelegate1), typeof(LuaTestDelegate1Handler));
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x,y) return x+y; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callDelegate1(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with value-type arguments and out params
*/
[Test]
public void LuaDelegateValueTypesOutParam()
{
using (Lua lua = new Lua())
{
lua.RegisterLuaDelegateType(typeof(TestDelegate2), typeof(LuaTestDelegate2Handler));
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x) return x,x*2; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callDelegate2(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(6, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with value-type arguments and ref params
*/
[Test]
public void LuaDelegateValueTypesByRefParam()
{
using (Lua lua = new Lua())
{
lua.RegisterLuaDelegateType(typeof(TestDelegate3), typeof(LuaTestDelegate3Handler));
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x,y) return x+y; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callDelegate3(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with value-type arguments that returns a reference type
*/
[Test]
public void LuaDelegateValueTypesReturnReferenceType()
{
using (Lua lua = new Lua())
{
lua.RegisterLuaDelegateType(typeof(TestDelegate4), typeof(LuaTestDelegate4Handler));
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x,y) return TestClass(x+y); end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callDelegate4(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with reference type arguments
*/
[Test]
public void LuaDelegateReferenceTypes()
{
using (Lua lua = new Lua())
{
lua.RegisterLuaDelegateType(typeof(TestDelegate5), typeof(LuaTestDelegate5Handler));
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x,y) return x.testval+y.testval; end");
lua.DoString("a=test:callDelegate5(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with reference type arguments and an out param
*/
[Test]
public void LuaDelegateReferenceTypesOutParam()
{
using (Lua lua = new Lua())
{
lua.RegisterLuaDelegateType(typeof(TestDelegate6), typeof(LuaTestDelegate6Handler));
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x) return x,TestClass(x*2); end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callDelegate6(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(6, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua function to a delegate
* with reference type arguments and a ref param
*/
[Test]
public void LuaDelegateReferenceTypesByRefParam()
{
using (Lua lua = new Lua())
{
lua.RegisterLuaDelegateType(typeof(TestDelegate7), typeof(LuaTestDelegate7Handler));
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("function func(x,y) return TestClass(x+y.testval); end");
lua.DoString("a=test:callDelegate7(func)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("delegate returned: "+a);
}
}
/*
* Tests passing a Lua table as an interface and
* calling one of its methods with value-type params
*/
[Test]
public void NLuaAAValueTypes()
{
using (Lua lua = new Lua())
{
lua.RegisterLuaClassType(typeof(ITest), typeof(LuaITestClassHandler));
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("itest={}");
lua.DoString("function itest:test1(x,y) return x+y; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callInterface1(itest)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("interface returned: "+a);
}
}
/*
* Tests passing a Lua table as an interface and
* calling one of its methods with value-type params
* and an out param
*/
[Test]
public void NLuaValueTypesOutParam()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("itest={}");
lua.DoString("function itest:test2(x) return x,x*2; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callInterface2(itest)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(6, a);
//Console.WriteLine("interface returned: "+a);
}
}
/*
* Tests passing a Lua table as an interface and
* calling one of its methods with value-type params
* and a ref param
*/
[Test]
public void NLuaValueTypesByRefParam()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("itest={}");
lua.DoString("function itest:test3(x,y) return x+y; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callInterface3(itest)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("interface returned: "+a);
}
}
/*
* Tests passing a Lua table as an interface and
* calling one of its methods with value-type params
* returning a reference type param
*/
[Test]
public void NLuaValueTypesReturnReferenceType()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("itest={}");
lua.DoString("function itest:test4(x,y) return TestClass(x+y); end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callInterface4(itest)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("interface returned: "+a);
}
}
/*
* Tests passing a Lua table as an interface and
* calling one of its methods with reference type params
*/
[Test]
public void NLuaReferenceTypes()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("itest={}");
lua.DoString("function itest:test5(x,y) return x.testval+y.testval; end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callInterface5(itest)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("interface returned: "+a);
}
}
/*
* Tests passing a Lua table as an interface and
* calling one of its methods with reference type params
* and an out param
*/
[Test]
public void NLuaReferenceTypesOutParam()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("itest={}");
lua.DoString("function itest:test6(x) return x,TestClass(x*2); end");
lua.DoString("test=TestClass()");
lua.DoString("a=test:callInterface6(itest)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(6, a);
//Console.WriteLine("interface returned: "+a);
}
}
/*
* Tests passing a Lua table as an interface and
* calling one of its methods with reference type params
* and a ref param
*/
[Test]
public void NLuaReferenceTypesByRefParam()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("itest={}");
lua.DoString("function itest:test7(x,y) return TestClass(x+y.testval); end");
lua.DoString("a=test:callInterface7(itest)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(5, a);
//Console.WriteLine("interface returned: "+a);
}
}
#region LUA_BOILERPLATE_CLASS
/*** This class is used to bind the .NET world with the Lua world, this boilerplate code is pratically the same, get values call Lua function return value back,
* this class is usually dynamic generated using System.Reflection.Emit, but this will not work on iOS. */
class LuaTestClassHandler : TestClass, ILuaGeneratedType
{
public LuaTable __luaInterface_luaTable;
public Type[][] __luaInterface_returnTypes;
public LuaTestClassHandler(LuaTable luaTable, Type[][] returnTypes)
{
__luaInterface_luaTable = luaTable;
__luaInterface_returnTypes = returnTypes;
}
public LuaTable LuaInterfaceGetLuaTable()
{
return __luaInterface_luaTable;
}
public override int overridableMethod(int x, int y)
{
object[] args = new object[] {
__luaInterface_luaTable,
x,
y
};
object[] inArgs = new object[] {
__luaInterface_luaTable,
x,
y
};
int[] outArgs = new int[] { };
Type[] returnTypes = __luaInterface_returnTypes[0];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "overridableMethod");
object ret = NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
return (int)ret;
}
}
class LuaITestClassHandler : ILuaGeneratedType, ITest
{
public LuaTable __luaInterface_luaTable;
public Type[][] __luaInterface_returnTypes;
public LuaITestClassHandler(LuaTable luaTable, Type[][] returnTypes)
{
__luaInterface_luaTable = luaTable;
__luaInterface_returnTypes = returnTypes;
}
public LuaTable LuaInterfaceGetLuaTable()
{
return __luaInterface_luaTable;
}
public int intProp
{
get
{
object[] args = new object[] { __luaInterface_luaTable };
object[] inArgs = new object[] { __luaInterface_luaTable };
int[] outArgs = new int[] { };
Type[] returnTypes = __luaInterface_returnTypes[0];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "get_intProp");
object ret = NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
return (int)ret;
}
set
{
int i = value;
object[] args = new object[] {
__luaInterface_luaTable ,
i
};
object[] inArgs = new object[] {
__luaInterface_luaTable,
i
};
int[] outArgs = new int[] { };
Type[] returnTypes = __luaInterface_returnTypes[1];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "set_intProp");
NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
}
}
public TestClass refProp
{
get
{
object[] args = new object[] { __luaInterface_luaTable };
object[] inArgs = new object[] { __luaInterface_luaTable };
int[] outArgs = new int[] { };
Type[] returnTypes = __luaInterface_returnTypes[2];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "get_refProp");
object ret = NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
return (TestClass)ret;
}
set
{
TestClass test = value;
object[] args = new object[] {
__luaInterface_luaTable ,
test
};
object[] inArgs = new object[] {
__luaInterface_luaTable,
test
};
int[] outArgs = new int[] { };
Type[] returnTypes = __luaInterface_returnTypes[3];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "set_refProp");
NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
}
}
public int test1(int a, int b)
{
object[] args = new object[] {
__luaInterface_luaTable,
a,
b
};
object[] inArgs = new object[] {
__luaInterface_luaTable,
a,
b
};
int[] outArgs = new int[] { };
Type[] returnTypes = __luaInterface_returnTypes[4];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "test1");
object ret = NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
return (int)ret;
}
public int test2(int a, out int b)
{
object[] args = new object[] {
__luaInterface_luaTable,
a,
0
};
object[] inArgs = new object[] {
__luaInterface_luaTable,
a
};
int[] outArgs = new int[] { 1 };
Type[] returnTypes = __luaInterface_returnTypes[5];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "test2");
object ret = NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
b = (int)args[1];
return (int)ret;
}
public void test3(int a, ref int b)
{
object[] args = new object[] {
__luaInterface_luaTable,
a,
b
};
object[] inArgs = new object[] {
__luaInterface_luaTable,
a,
b
};
int[] outArgs = new int[] { 1 };
Type[] returnTypes = __luaInterface_returnTypes[6];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "test3");
NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
b = (int)args[1];
}
public TestClass test4(int a, int b)
{
object[] args = new object[] {
__luaInterface_luaTable,
a,
b
};
object[] inArgs = new object[] {
__luaInterface_luaTable,
a,
b
};
int[] outArgs = new int[] { };
Type[] returnTypes = __luaInterface_returnTypes[7];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "test4");
object ret = NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
return (TestClass)ret;
}
public int test5(TestClass a, TestClass b)
{
object[] args = new object[] {
__luaInterface_luaTable,
a,
b
};
object[] inArgs = new object[] {
__luaInterface_luaTable,
a,
b
};
int[] outArgs = new int[] { };
Type[] returnTypes = __luaInterface_returnTypes[8];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "test5");
object ret = NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
return (int)ret;
}
public int test6(int a, out TestClass b)
{
object[] args = new object[] {
__luaInterface_luaTable,
a,
null
};
object[] inArgs = new object[] {
__luaInterface_luaTable,
a,
};
int[] outArgs = new int[] { 1 };
Type[] returnTypes = __luaInterface_returnTypes[9];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "test6");
object ret = NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
b = (TestClass)args[1];
return (int)ret;
}
public void test7(int a, ref TestClass b)
{
object[] args = new object[] {
__luaInterface_luaTable,
a,
b
};
object[] inArgs = new object[] {
__luaInterface_luaTable,
a,
b
};
int[] outArgs = new int[] { 1 };
Type[] returnTypes = __luaInterface_returnTypes[10];
LuaFunction function = NLua.Method.LuaClassHelper.GetTableFunction(__luaInterface_luaTable, "test7");
NLua.Method.LuaClassHelper.CallFunction(function, args, returnTypes, inArgs, outArgs);
b = (TestClass)args[1];
}
}
#endregion
/*
* Tests passing a Lua table as an interface and
* accessing one of its value-type properties
*/
[Test]
public void NLuaValueProperty()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("itest={}");
lua.DoString("function itest:get_intProp() return itest.int_prop; end");
lua.DoString("function itest:set_intProp(val) itest.int_prop=val; end");
lua.DoString("a=test:callInterface8(itest)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(3, a);
//Console.WriteLine("interface returned: "+a);
}
}
/*
* Tests passing a Lua table as an interface and
* accessing one of its reference type properties
*/
[Test]
public void NLuaReferenceProperty()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("itest={}");
lua.DoString("function itest:get_refProp() return TestClass(itest.int_prop); end");
lua.DoString("function itest:set_refProp(val) itest.int_prop=val.testval; end");
lua.DoString("a=test:callInterface9(itest)");
int a = (int)lua.GetNumber("a");
Assert.AreEqual(3, a);
//Console.WriteLine("interface returned: "+a);
}
}
/*
* Tests making an object from a Lua table and calling the base
* class version of one of the methods the table overrides.
*/
[Test]
public void LuaTableBaseMethod()
{
using (Lua lua = new Lua())
{
lua.RegisterLuaClassType(typeof(TestClass), typeof(LuaTestClassHandler));
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test={}");
lua.DoString("function test:overridableMethod(x,y) print(self[base]); return 6 end");
lua.DoString("luanet.make_object(test,'NLuaTest.Mock.TestClass')");
lua.DoString("a=TestClass.callOverridable(test,2,3)");
int a = (int)lua.GetNumber("a");
lua.DoString("luanet.free_object(test)");
Assert.AreEqual(6, a);
// lua.DoString("luanet.load_assembly('NLuaTest')");
// lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
// lua.DoString("test={}");
//
// lua.DoString("luanet.make_object(test,'NLuaTest.Mock.TestClass')");
// lua.DoString ("function test.overridableMethod(test,x,y) return 2*test.base.overridableMethod(test,x,y); end");
// lua.DoString("a=TestClass.callOverridable(test,2,3)");
// int a = (int)lua.GetNumber("a");
// lua.DoString("luanet.free_object(test)");
// Assert.AreEqual(10, a);
//Console.WriteLine("interface returned: "+a);
}
}
/*
* Tests getting an object's method by its signature
* (from object)
*/
[Test]
public void GetMethodBySignatureFromObj()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("setMethod=luanet.get_method_bysig(test,'setVal','System.String')");
lua.DoString("setMethod('test')");
TestClass test = (TestClass)lua["test"];
Assert.AreEqual("test", test.getStrVal());
//Console.WriteLine("interface returned: "+test.getStrVal());
}
}
/*
* Tests getting an object's method by its signature
* (from type)
*/
[Test]
public void GetMethodBySignatureFromType()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("setMethod=luanet.get_method_bysig(TestClass,'setVal','System.String')");
lua.DoString("setMethod(test,'test')");
TestClass test = (TestClass)lua["test"];
Assert.AreEqual("test", test.getStrVal());
//Console.WriteLine("interface returned: "+test.getStrVal());
}
}
/*
* Tests getting a type's method by its signature
*/
[Test]
public void GetStaticMethodBySignature()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("make_method=luanet.get_method_bysig(TestClass,'makeFromString','System.String')");
lua.DoString("test=make_method('test')");
TestClass test = (TestClass)lua["test"];
Assert.AreEqual("test", test.getStrVal());
//Console.WriteLine("interface returned: "+test.getStrVal());
}
}
/*
* Tests getting an object's constructor by its signature
*/
[Test]
public void GetConstructorBySignature()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test_cons=luanet.get_constructor_bysig(TestClass,'System.String')");
lua.DoString("test=test_cons('test')");
TestClass test = (TestClass)lua["test"];
Assert.AreEqual("test", test.getStrVal());
//Console.WriteLine("interface returned: "+test.getStrVal());
}
}
[Test]
public void TestVarargs()
{
using (Lua lua = new Lua())
{
lua.DoString("luanet.load_assembly('mscorlib')");
lua.DoString("luanet.load_assembly('NLuaTest')");
lua.DoString("TestClass=luanet.import_type('NLuaTest.Mock.TestClass')");
lua.DoString("test=TestClass()");
lua.DoString("test:Print('this will pass')");
lua.DoString("test:Print('this will ','fail')");
}
}
[Test]
public void TestCtype()
{
using (Lua lua = new Lua())
{
lua.LoadCLRPackage();
lua.DoString("import'System'");
var x = lua.DoString("return luanet.ctype(String)")[0];
Assert.AreEqual(x, typeof(String), "#1 String ctype test");
}
}
[Test]
public void TestPrintChars()
{
using (Lua lua = new Lua())
{
lua.DoString(@"print(""waüäq?=()[&]ß"")");
Assert.IsTrue(true);
}
}
[Test]
public void TestUnicodeChars()
{
using (Lua lua = new Lua())
{
lua.State.Encoding = Encoding.UTF8;
lua.LoadCLRPackage();
lua.DoString("import('NLuaTest')");
lua.DoString("res = LuaTests.UnicodeString");
string res = (string)lua["res"];
Assert.AreEqual(LuaTests.UnicodeString, res);
}
}
[Test]
public void TestUnicodeCharsInDoString()
{
using (Lua lua = new Lua())
{
lua.State.Encoding = Encoding.UTF8;
lua.DoString("res = 'Файл'");
string res = (string)lua["res"];
Assert.AreEqual(LuaTests.UnicodeStringRussian, res);
}
}
[Test]
public void TestCoroutine()
{
using (Lua lua = new Lua())
{
lua.LoadCLRPackage();
lua.RegisterFunction("func1", null, typeof(TestClass2).GetMethod("func"));
lua.DoString(@"function yielder()
a=1;
coroutine.yield();
func1(3,2);
coroutine.yield();
a=2;
coroutine.yield();
end
co_routine = coroutine.create(yielder);
while coroutine.resume(co_routine) do end;");
double num = lua.GetNumber("a");
Assert.AreEqual(num, 2d);
}
}
[Test]
public void TestDebugHook()
{
int[] lines = { 1, 2, 1, 3 };
int line = 0;
using (var lua = new Lua())
{
lua.DebugHook += (sender, args) =>
{
Assert.AreEqual(args.LuaDebug.CurrentLine, lines[line]);
line++;
};
lua.SetDebugHook(KeraLua.LuaHookMask.Line, 0);
lua.DoString(@"function testing_hooks() return 10 end
val = testing_hooks()
val = val + 1");
}
}
[Test]
public void TestKeyWithDots()
{
using (Lua lua = new Lua())
{
lua.DoString(@"g_dot = {}
g_dot['key.with.dot'] = 42");
Assert.AreEqual(42, (int)(double)lua["g_dot.key\\.with\\.dot"]);
}
}
#if !WINDOWS_PHONE && !NET_3_5
[Test]
public void TestOperatorAdd()
{
using (Lua lua = new Lua())
{
var a = new System.Numerics.Complex(10, 0);
var b = new System.Numerics.Complex(0, 3);
var x = a + b;
lua["a"] = a;
lua["b"] = b;
var res = lua.DoString(@"return a + b")[0];
Assert.AreEqual(x, res);
}
}
[Test]
public void TestOperatorMinus()
{
using (Lua lua = new Lua())
{
var a = new System.Numerics.Complex(10, 0);
var b = new System.Numerics.Complex(0, 3);
var x = a - b;
lua["a"] = a;
lua["b"] = b;
var res = lua.DoString(@"return a - b")[0];
Assert.AreEqual(x, res);
}
}
[Test]
public void TestOperatorMultiply()
{
using (Lua lua = new Lua())
{
var a = new System.Numerics.Complex(10, 0);
var b = new System.Numerics.Complex(0, 3);
var x = a * b;
lua["a"] = a;
lua["b"] = b;
var res = lua.DoString(@"return a * b")[0];
Assert.AreEqual(x, res);
}
}
[Test]
public void TestOperatorEqual()
{
using (Lua lua = new Lua())
{
var a = new System.Numerics.Complex(10, 0);
var b = new System.Numerics.Complex(0, 3);
var x = a == b;
lua["a"] = a;
lua["b"] = b;
var res = lua.DoString(@"return a == b")[0];
Assert.AreEqual(x, res);
}
}
[Test]
public void TestOperatorNotEqual()
{
using (Lua lua = new Lua())
{
var a = new System.Numerics.Complex(10, 0);
var b = new System.Numerics.Complex(0, 3);
var x = a != b;
lua["a"] = a;
lua["b"] = b;
var res = lua.DoString(@"return a ~= b")[0];
Assert.AreEqual(x, res);
}
}
[Test]
public void TestUnaryMinus()
{
using (Lua lua = new Lua())
{
lua.LoadCLRPackage();
lua.DoString(@" import ('System.Numerics')
c = Complex (10, 5)
c = -c ");
var expected = new System.Numerics.Complex(-10, -5);
var res = lua["c"];
Assert.AreEqual(expected, res);
}
}
#endif
[Test]
public void TestCaseFields()
{
using (Lua lua = new Lua())
{
lua.LoadCLRPackage();
lua.DoString(@" import ('NLuaTest')
x = TestCaseName()
name = x.name;
name2 = x.Name;
Name = x.Name;
Name2 = x.name");
Assert.AreEqual("name", lua["name"]);
Assert.AreEqual("**name**", lua["name2"]);
Assert.AreEqual("**name**", lua["Name"]);
Assert.AreEqual("name", lua["Name2"]);
}
}
[Test]
public void TestStaticOperators()
{
using (Lua lua = new Lua())
{
lua.LoadCLRPackage();
lua.DoString(@" import ('NLuaTest')
v = Vector()
v.x = 10
v.y = 3
v = v*2 ");
var v = (Vector)lua["v"];
Assert.AreEqual(20, v.x, "#1");
Assert.AreEqual(6, v.y, "#2");
lua.DoString(@" x = 2 * v");
var x = (Vector)lua["x"];
Assert.AreEqual(40, x.x, "#3");
Assert.AreEqual(12, x.y, "#4");
}
}
[Test]
public void TestExtensionMethods()
{
using (Lua lua = new Lua())
{
lua.LoadCLRPackage();
lua.DoString(@" import ('NLuaTest')
v = Vector()
v.x = 10
v.y = 3
v = v*2 ");
var v = (Vector)lua["v"];
double len = v.Length();
lua.DoString(" v:Length() ");
lua.DoString(@" len2 = v:Length()");
double len2 = (double)lua["len2"];
Assert.AreEqual(len, len2, "#1");
}
}
[Test]
public void TestBaseClassExtensionMethods()
{
using (Lua lua = new Lua())
{
lua.LoadCLRPackage();
lua.DoString(@" import ('NLuaTest')
p = Employee()
p.firstName = 'Paulo'
p.occupation = 'Programmer'");
var p = (Person)lua["p"];
string name = p.GetFirstName();
lua.DoString(" p:GetFirstName() ");
lua.DoString(@" name2 = p:GetFirstName()");
string name2 = (string)lua["name2"];
Assert.AreEqual(name, name2, "#1");
}
}
[Test]
public void TestOverloadedMethods()
{
using (Lua lua = new Lua())
{
var obj = new TestClassWithOverloadedMethod();
lua["obj"] = obj;
lua.DoString(@"
obj:Func (10)
obj:Func ('10')
obj:Func (10)
obj:Func ('10')
obj:Func (10)
");
Assert.AreEqual(3, obj.CallsToIntFunc, "#integer");
Assert.AreEqual(2, obj.CallsToStringFunc, "#string");
}
}
[Test]
public void TestGetStack()
{
using (Lua lua = new Lua())
{
lua.LoadCLRPackage();
m_lua = lua;
lua.DoString(@"
import ('NLuaTest')
function f1 ()
f2 ()
end
function f2()
f3()
end
function f3()
LuaTests.func()
end
f1 ()
");
}
m_lua = null;
}
public static void func()
{
//string expected = "[0] func:-1 -- <unknown> [func]\n[1] f3:12 -- <unknown> [f3]\n[2] f2:8 -- <unknown> [f2]\n[3] f1:4 -- <unknown> [f1]\n[4] :15 -- []\n";
var info = new KeraLua.LuaDebug();
int level = 0;
var sb = new StringBuilder();
while (m_lua.GetStack(level, ref info) != 0)
{
m_lua.GetInfo("nSl", ref info);
string name = "<unknow>";
if (!string.IsNullOrEmpty(info.Name))
name = info.Name;
sb.AppendFormat("[{0}] {1}:{2} -- {3} [{4}]\n",
level, info.ShortSource, info.CurrentLine,
name, info.NameWhat);
++level;
}
string x = sb.ToString();
Assert.True(!string.IsNullOrEmpty(x));
}
[Test]
public void TestCallImplicitBaseMethod()
{
using (var l = new Lua())
{
l.LoadCLRPackage();
l.DoString("import ('NLuaTest')");
l.DoString("res = testClass.read() ");
string res = (string)l["res"];
Assert.AreEqual(testClass.read(), res);
}
}
[Test]
public void TestPushLuaFunctionWhenReadingDelegateProperty()
{
bool called = false;
var _model = new DefaultElementModel();
_model.DrawMe = (x) =>
{
called = true;
};
using (var l = new Lua())
{
l["model"] = _model;
l.DoString(@" model.DrawMe (0) ");
}
Assert.True(called);
}
[Test]
public void TestCallDelegateWithParameters()
{
string sval = "";
int nval = 0;
using (var l = new Lua())
{
Action<string, int> c = (s, n) => { sval = s; nval = n; };
l["d"] = c;
l.DoString(" d ('string', 10) ");
}
Assert.AreEqual("string", sval, "#1");
Assert.AreEqual(10, nval, "#2");
}
[Test]
public void TestCallSimpleDelegate()
{
bool called = false;
using (var l = new Lua())
{
Action c = () => { called = true; };
l["d"] = c;
l.DoString(" d () ");
}
Assert.True(called);
}
[Test]
public void TestCallDelegateWithWrongParametersShouldFail()
{
bool fail = false;
using (var l = new Lua())
{
Action c = () => { fail = false; };
l["d"] = c;
try
{
l.DoString(" d (10) ");
}
catch (LuaScriptException)
{
fail = true;
}
}
Assert.True(fail);
}
[Test]
public void TestOverloadedMethodCallOnBase()
{
using (var l = new Lua())
{
l.LoadCLRPackage();
l.DoString(" import ('NLuaTest') ");
l.DoString(@"
p=parameter()
r1 = testClass.read(p) -- is not working. it is also not working if the method in base class has two parameters instead of one
r2 = testClass.read(1) -- is working
");
string r1 = (string)l["r1"];
string r2 = (string)l["r2"];
Assert.AreEqual("parameter-field1", r1, "#1");
Assert.AreEqual("int-test", r2, "#2");
}
}
[Test]
public void TestCallMethodWithParams2()
{
using (var l = new Lua())
{
l.LoadCLRPackage();
l.DoString(" import ('NLuaTest','NLuaTest.Mock') ");
l.DoString(@"
r = TestClass.MethodWithParams(2)
");
int r = (int)l.GetNumber("r");
Assert.AreEqual(0, r, "#1");
}
}
[Test]
public void TestCallMethodWithParamsOptional()
{
using (var l = new Lua())
{
l.LoadCLRPackage();
l.DoString(" import ('NLuaTest','NLuaTest.Mock') ");
l.DoString(@"
r = TestClass.MethodWithParams(2, 7, 4)
");
int r = (int)l.GetNumber("r");
Assert.AreEqual(2, r, "#1");
}
}
[Test]
public void TestCallMethodWithObjectParams()
{
using (var l = new Lua())
{
l.LoadCLRPackage();
l.DoString(" import ('NLuaTest','NLuaTest.Mock') ");
l.DoString(@"
r = TestClass.MethodWithObjectParams(2, nil, 4, 'abc')
");
int r = (int)l.GetNumber("r");
Assert.AreEqual(4, r, "#1");
}
}
[Test]
public void TestCallMethodWithObjectParamsAndNilAsFirstArgument()
{
using (var l = new Lua())
{
l.LoadCLRPackage();
l.DoString(" import ('NLuaTest','NLuaTest.Mock') ");
l.DoString(@"
r = TestClass.MethodWithObjectParams(nil, 4, 'abc')
");
int r = (int)l.GetNumber("r");
Assert.AreEqual(3, r, "#1");
}
}
[Test]
public void TestConstructorOverload()
{
using (var l = new Lua())
{
l.LoadCLRPackage();
l.DoString(" import ('NLuaTest','NLuaTest.Mock') ");
l.DoString(@"
e1 = Entity()
e2 = Entity ('str_param')
e3 = Entity (10)
p1 = e1.Property
p2 = e2.Property
p3 = e3.Property
");
string p1 = l.GetString("p1");
string p2 = l.GetString("p2");
string p3 = l.GetString("p3");
Assert.AreEqual("Default", p1, "#1");
Assert.AreEqual("String", p2, "#1");
Assert.AreEqual("Int", p3, "#1");
}
}
static Lua m_lua;
}
}
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Resources;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
......@@ -11,7 +9,7 @@ using System.Resources;
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("NLuaTest")]
[assembly: AssemblyCopyright("Copyright © 2013")]
[assembly: AssemblyCopyright("Copyright © 2019")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
......@@ -21,7 +19,7 @@ using System.Resources;
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("ba95d268-0e19-4bbc-a735-8a00795084d2")]
[assembly: Guid("20ae709c-fb97-48e3-89b0-a34a5c3da1db")]
// Version information for an assembly consists of the following four values:
//
......@@ -30,8 +28,10 @@ using System.Resources;
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: NeutralResourcesLanguageAttribute("en-US")]
// [assembly: AssemblyVersion("1.0.7.0")]
[assembly: AssemblyVersion("1.0.7.0")]
[assembly: AssemblyFileVersion("1.0.7.0")]
[assembly: AssemblyInformationalVersion("1.0.7+Branch.master.Sha.80a328a64f12ed9032a0f14a75e6ecad967514d0")]
using System;
using NLua;
using System.Threading;
namespace NLuaTest.Mock
{
/*
* Delegates used for testing Lua function -> delegate translation
*/
public delegate int TestDelegate1(int a, int b);
public delegate int TestDelegate2(int a, out int b);
public delegate void TestDelegate3(int a, ref int b);
public delegate TestClass TestDelegate4(int a, int b);
public delegate int TestDelegate5(TestClass a, TestClass b);
public delegate int TestDelegate6(int a, out TestClass b);
public delegate void TestDelegate7(int a, ref TestClass b);
/* Delegate Lua-handlers */
class LuaTestDelegate1Handler : NLua.Method.LuaDelegate
{
int CallFunction(int a, int b)
{
object[] args = new object[] { a, b };
object[] inArgs = new object[] { a, b };
int[] outArgs = new int[] { };
object ret = base.CallFunction(args, inArgs, outArgs);
return (int)ret;
}
}
class LuaTestDelegate2Handler : NLua.Method.LuaDelegate
{
int CallFunction(int a, out int b)
{
object[] args = new object[] { a, 0 };
object[] inArgs = new object[] { a };
int[] outArgs = new int[] { 1 };
object ret = base.CallFunction(args, inArgs, outArgs);
b = (int)args[1];
return (int)ret;
}
}
class LuaTestDelegate3Handler : NLua.Method.LuaDelegate
{
void CallFunction(int a, ref int b)
{
object[] args = new object[] { a, b };
object[] inArgs = new object[] { a, b };
int[] outArgs = new int[] { 1 };
base.CallFunction(args, inArgs, outArgs);
b = (int)args[1];
}
}
class LuaTestDelegate4Handler : NLua.Method.LuaDelegate
{
TestClass CallFunction(int a, int b)
{
object[] args = new object[] { a, b };
object[] inArgs = new object[] { a, b };
int[] outArgs = new int[] { };
object ret = base.CallFunction(args, inArgs, outArgs);
return (TestClass)ret;
}
}
class LuaTestDelegate5Handler : NLua.Method.LuaDelegate
{
int CallFunction(TestClass a, TestClass b)
{
object[] args = new object[] { a, b };
object[] inArgs = new object[] { a, b };
int[] outArgs = new int[] { };
object ret = base.CallFunction(args, inArgs, outArgs);
return (int)ret;
}
}
class LuaTestDelegate6Handler : NLua.Method.LuaDelegate
{
int CallFunction(int a, ref TestClass b)
{
object[] args = new object[] { a, b };
object[] inArgs = new object[] { a };
int[] outArgs = new int[] { 1 };
object ret = base.CallFunction(args, inArgs, outArgs);
b = (TestClass)args[1];
return (int)ret;
}
}
class LuaTestDelegate7Handler : NLua.Method.LuaDelegate
{
void CallFunction(int a, ref TestClass b)
{
object[] args = new object[] { a, b };
object[] inArgs = new object[] { a, b };
int[] outArgs = new int[] { 1 };
base.CallFunction(args, inArgs, outArgs);
b = (TestClass)args[1];
}
}
/*
* Interface used for testing Lua table -> interface translation
*/
public interface ITest
{
int intProp
{
get;
set;
}
TestClass refProp
{
get;
set;
}
int test1(int a, int b);
int test2(int a, out int b);
void test3(int a, ref int b);
TestClass test4(int a, int b);
int test5(TestClass a, TestClass b);
int test6(int a, out TestClass b);
void test7(int a, ref TestClass b);
}
public interface IFoo1
{
int foo();
}
public interface IFoo2
{
int foo();
}
class MyClass
{
public int Func1()
{
return 1;
}
}
/// <summary>
/// Use to test threading
/// </summary>
class DoWorkClass
{
public void DoWork()
{
//simulate work by sleeping
//Console.WriteLine("Started to do work on thread: " + Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(new Random().Next(0, 1000));
//Console.WriteLine("Finished work on thread: " + Thread.CurrentThread.ManagedThreadId);
}
}
/// <summary>
/// test structure passing
/// </summary>
public struct TestStruct
{
public TestStruct(float val)
{
v = val;
}
public float v;
public float val
{
get { return v; }
set { v = value; }
}
}
/// <summary>
/// test enum
/// </summary>
public enum TestEnum
{
ValueA,
ValueB
}
/// <summary>
/// Generic class with generic and non-generic methods
/// </summary>
/// <typeparam name="T"></typeparam>
public class TestClassGeneric<T>
{
private object _PassedValue;
private bool _RegularMethodSuccess;
public bool RegularMethodSuccess
{
get { return _RegularMethodSuccess; }
}
private bool _GenericMethodSuccess;
public bool GenericMethodSuccess
{
get { return _GenericMethodSuccess; }
}
public void GenericMethod(T value)
{
_PassedValue = value;
_GenericMethodSuccess = true;
}
public void RegularMethod()
{
_RegularMethodSuccess = true;
}
/// <summary>
/// Returns true if the generic method was successfully passed a matching value
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public bool Validate(T value)
{
return value.Equals(_PassedValue);
}
}
/// <summary>
/// Normal class containing a generic method
/// </summary>
public class TestClassWithGenericMethod
{
private object _PassedValue;
public object PassedValue
{
get { return _PassedValue; }
}
private bool _GenericMethodSuccess;
public bool GenericMethodSuccess
{
get { return _GenericMethodSuccess; }
}
public void GenericMethod<T>(T value)
{
_PassedValue = value;
_GenericMethodSuccess = true;
}
internal bool Validate<T>(T value)
{
return value.Equals(_PassedValue);
}
}
public class TestClass2
{
public static int func(int x, int y)
{
return x + y;
}
public int funcInstance(int x, int y)
{
return x + y;
}
}
/*
* Sample class used in several test cases to check if
* Lua scripts are accessing objects correctly
*/
public class TestClass : IFoo1, IFoo2
{
public int val;
private string strVal;
public TestClass()
{
val = 0;
}
public TestClass(int val)
{
this.val = val;
}
public TestClass(string val)
{
this.strVal = val;
}
public static TestClass makeFromString(String str)
{
return new TestClass(str);
}
bool? nb2 = null;
public bool? NullableBool
{
get { return nb2; }
set { nb2 = value; }
}
TestStruct s = new TestStruct();
public TestStruct Struct
{
get { return s; }
set { s = (TestStruct)value; }
}
public int testval
{
get
{
return this.val;
}
set
{
this.val = value;
}
}
public string teststrval
{
get
{
return this.strVal;
}
set
{
this.strVal = value;
}
}
public int this[int index]
{
get { return 1; }
set { }
}
public int this[string index]
{
get { return 1; }
set { }
}
public TimeSpan? NullableMethod(TimeSpan? input)
{
return input;
}
public int? NullableMethod2(int? input)
{
return input;
}
public object[] TestLuaFunction(LuaFunction func)
{
if (func != null)
{
return func.Call(1, 2);
}
return null;
}
public int sum(int x, int y)
{
return x + y;
}
public void setVal(int newVal)
{
val = newVal;
}
public void setVal(string newVal)
{
strVal = newVal;
}
public int getVal()
{
return val;
}
public string getStrVal()
{
return strVal;
}
public int outVal(out int val)
{
val = 5;
return 3;
}
public int outVal(out int val, int val2)
{
val = 5;
return val2;
}
public int outVal(int val, ref int val2)
{
val2 = val + val2;
return val;
}
public int outValMutiple(int arg, out string arg2, out string arg3)
{
arg2 = Guid.NewGuid().ToString();
arg3 = Guid.NewGuid().ToString();
return arg;
}
public int callDelegate1(TestDelegate1 del)
{
return del(2, 3);
}
public int callDelegate2(TestDelegate2 del)
{
int a = 3;
int b = del(2, out a);
return a + b;
}
public int callDelegate3(TestDelegate3 del)
{
int a = 3;
del(2, ref a);
//Console.WriteLine(a);
return a;
}
public int callDelegate4(TestDelegate4 del)
{
return del(2, 3).testval;
}
public int callDelegate5(TestDelegate5 del)
{
return del(new TestClass(2), new TestClass(3));
}
public int callDelegate6(TestDelegate6 del)
{
TestClass test = new TestClass();
int a = del(2, out test);
return a + test.testval;
}
public int callDelegate7(TestDelegate7 del)
{
TestClass test = new TestClass(3);
del(2, ref test);
return test.testval;
}
public int callInterface1(ITest itest)
{
return itest.test1(2, 3);
}
public int callInterface2(ITest itest)
{
int a = 3;
int b = itest.test2(2, out a);
return a + b;
}
public int callInterface3(ITest itest)
{
int a = 3;
itest.test3(2, ref a);
//Console.WriteLine(a);
return a;
}
public int callInterface4(ITest itest)
{
return itest.test4(2, 3).testval;
}
public int callInterface5(ITest itest)
{
return itest.test5(new TestClass(2), new TestClass(3));
}
public int callInterface6(ITest itest)
{
TestClass test = new TestClass();
int a = itest.test6(2, out test);
return a + test.testval;
}
public int callInterface7(ITest itest)
{
TestClass test = new TestClass(3);
itest.test7(2, ref test);
return test.testval;
}
public int callInterface8(ITest itest)
{
itest.intProp = 3;
return itest.intProp;
}
public int callInterface9(ITest itest)
{
itest.refProp = new TestClass(3);
return itest.refProp.testval;
}
public void exceptionMethod()
{
throw new Exception("exception test");
}
public virtual int overridableMethod(int x, int y)
{
return x + y;
}
public static int callOverridable(TestClass test, int x, int y)
{
return test.overridableMethod(x, y);
}
int IFoo1.foo()
{
return 3;
}
public int foo()
{
return 5;
}
private void _PrivateMethod()
{
Console.WriteLine("Private method called");
}
public void MethodOverload()
{
Console.WriteLine("Method with no params");
}
public void MethodOverload(TestClass testClass)
{
Console.WriteLine("Method with testclass param");
}
public void MethodOverload(int i, int j, int k)
{
Console.WriteLine("Overload without out param: " + i + ", " + j + ", " + k);
}
public void MethodOverload(int i, int j, out int k)
{
k = 5;
Console.WriteLine("Overload with out param" + i + ", " + j);
}
public void Print(object format, params object[] args)
{
//just for test,this is not printf implements
var output = format.ToString() + "\t";
foreach (var msg in args)
{
output += msg.ToString() + "\t";
}
Console.WriteLine(output);
}
static public int MethodWithParams(int a, params int[] others)
{
Console.WriteLine(a);
int i = 0;
foreach (int val in others)
{
Console.WriteLine(val);
i++;
}
return i;
}
static public int MethodWithObjectParams(params object[] others)
{
int i = 0;
foreach (var val in others)
{
Console.WriteLine(val);
i++;
}
return i;
}
}
public class TestClassWithOverloadedMethod
{
public int CallsToStringFunc { get; set; }
public int CallsToIntFunc { get; set; }
public void Func(string param)
{
CallsToStringFunc++;
}
public void Func(int param)
{
CallsToIntFunc++;
}
}
}
<?xml version="1.0" encoding="utf-8"?>
<RunSettings>
<RunConfiguration>
<TargetPlatform>x64</TargetPlatform>
</RunConfiguration>
</RunSettings>
\ No newline at end of file
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment