mirror of https://github.com/swig/swig
192 lines
3.5 KiB
Lua
192 lines
3.5 KiB
Lua
-- demo of lua swig capacities (operator overloading)
|
|
require("import") -- the import fn
|
|
import("operator_overload") -- import lib
|
|
|
|
for k,v in pairs(operator_overload) do _G[k]=v end -- move to global
|
|
|
|
-- first check all the operators are implemented correctly from pure C++ code
|
|
Op_sanity_check()
|
|
|
|
-- catching undefined variables
|
|
local env = _ENV -- Lua 5.2
|
|
if not env then env = getfenv () end -- Lua 5.1
|
|
setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
|
|
|
|
-- test routine:
|
|
a=Op()
|
|
b=Op(5)
|
|
c=Op(b) -- copy construct
|
|
d=Op(2)
|
|
dd=d; -- assignment operator
|
|
|
|
-- test equality
|
|
assert(a~=b)
|
|
assert(b==c)
|
|
assert(a~=d)
|
|
assert(d==dd)
|
|
|
|
-- test <
|
|
assert(a<b)
|
|
assert(a<=b)
|
|
assert(b<=c)
|
|
assert(b>=c)
|
|
assert(b>d)
|
|
assert(b>=d)
|
|
|
|
-- lua does not support += operators: skipping
|
|
|
|
-- test +
|
|
f=Op(1)
|
|
g=Op(1)
|
|
assert(f+g==Op(2))
|
|
assert(f-g==Op(0))
|
|
assert(f*g==Op(1))
|
|
assert(f/g==Op(1))
|
|
--assert(f%g==Op(0)) -- lua does not support %
|
|
|
|
-- test unary operators
|
|
--assert((not a)==true) -- lua does not allow overloading for not operator
|
|
--assert((not b)==false) -- lua does not allow overloading for not operator
|
|
|
|
--lua 5.0.2 defines that unary - is __unm(self,nil)
|
|
--lua 5.1.2 defines that unary - is __unm(self,self)
|
|
--C++ expects unary - as operator-()
|
|
--however the latest version of SWIG strictly checks the number of args
|
|
--and will complain if too many args are provided
|
|
--therefore disabling these tests for now
|
|
-- (solution will to be not to check args for this test case)
|
|
assert(-a==a)
|
|
assert(-b==Op(-5))
|
|
|
|
-- test []
|
|
h=Op(3)
|
|
assert(h[0]==3)
|
|
assert(h[1]==0)
|
|
h[0]=2 -- set
|
|
assert(h[0]==2)
|
|
h[1]=2 -- ignored
|
|
assert(h[0]==2)
|
|
assert(h[1]==0)
|
|
|
|
-- test ()
|
|
i=Op(3)
|
|
assert(i()==3)
|
|
assert(i(1)==4)
|
|
assert(i(1,2)==6)
|
|
|
|
-- plus add some code to check the __str__ fn
|
|
assert(tostring(Op(1))=="Op(1)")
|
|
assert(tostring(Op(-3))=="Op(-3)")
|
|
|
|
|
|
-- check that operator overloads are correctly propagated down inheritance hierarchy
|
|
|
|
a_d=OpDerived()
|
|
b_d=OpDerived(5)
|
|
c_d=OpDerived(5)
|
|
d_d=OpDerived(2)
|
|
-- test equality
|
|
assert(a_d~=b_d)
|
|
assert(b_d==c_d)
|
|
assert(a_d~=d_d)
|
|
|
|
-- test <
|
|
assert(a_d<b_d)
|
|
assert(a_d<=b_d)
|
|
assert(b_d<=c_d)
|
|
assert(b_d>=c_d)
|
|
assert(b_d>d_d)
|
|
assert(b_d>=d_d)
|
|
--
|
|
-- test + inheritance
|
|
f_d=OpDerived(1)
|
|
g_d=OpDerived(1)
|
|
assert(f_d+g_d==Op(2))
|
|
assert(f_d-g_d==Op(0))
|
|
assert(f_d*g_d==Op(1))
|
|
assert(f_d/g_d==Op(1))
|
|
--
|
|
-- plus add some code to check the __str__ fn inheritance
|
|
assert(tostring(OpDerived(1))=="Op(1)")
|
|
assert(tostring(OpDerived(-3))=="Op(-3)")
|
|
|
|
--[[
|
|
/* Sample test code in C++
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
|
|
int main(int argc,char** argv)
|
|
{
|
|
// test routine:
|
|
Op a;
|
|
Op b=5;
|
|
Op c=b; // copy construct
|
|
Op d=2;
|
|
|
|
// test equality
|
|
assert(a!=b);
|
|
assert(b==c);
|
|
assert(a!=d);
|
|
|
|
// test <
|
|
assert(a<b);
|
|
assert(a<=b);
|
|
assert(b<=c);
|
|
assert(b>=c);
|
|
assert(b>d);
|
|
assert(b>=d);
|
|
|
|
// test +=
|
|
Op e=3;
|
|
e+=d;
|
|
assert(e==b);
|
|
e-=c;
|
|
assert(e==a);
|
|
e=Op(1);
|
|
e*=b;
|
|
assert(e==c);
|
|
e/=d;
|
|
assert(e==d);
|
|
e%=c;
|
|
assert(e==d);
|
|
|
|
// test +
|
|
Op f(1),g(1);
|
|
assert(f+g==Op(2));
|
|
assert(f-g==Op(0));
|
|
assert(f*g==Op(1));
|
|
assert(f/g==Op(1));
|
|
assert(f%g==Op(0));
|
|
|
|
// test unary operators
|
|
assert(!a==true);
|
|
assert(!b==false);
|
|
assert(-a==a);
|
|
assert(-b==Op(-5));
|
|
|
|
// test []
|
|
Op h=3;
|
|
assert(h[0]==3);
|
|
assert(h[1]==0);
|
|
h[0]=2; // set
|
|
assert(h[0]==2);
|
|
h[1]=2; // ignored
|
|
assert(h[0]==2);
|
|
assert(h[1]==0);
|
|
|
|
// test ()
|
|
Op i=3;
|
|
assert(i()==3);
|
|
assert(i(1)==4);
|
|
assert(i(1,2)==6);
|
|
|
|
// plus add some code to check the __str__ fn
|
|
//assert(str(Op(1))=="Op(1)");
|
|
//assert(str(Op(-3))=="Op(-3)");
|
|
|
|
printf("ok\n");
|
|
}
|
|
*/
|
|
]]
|