Implemented Support of Java 21 VirtualThread
This commit is contained in:
UnlegitDqrk
@@ -1,277 +0,0 @@
|
||||
|
||||
-- tostring replacement that assigns ids
|
||||
local ts,id,nid,types = tostring,{},0,{table='tbl',thread='thr',userdata='uda',['function']='func'}
|
||||
tostring = function(x)
|
||||
if not x or not types[type(x)] then return ts(x) end
|
||||
if not id[x] then nid=nid+1; id[x]=types[type(x)]..'.'..nid end
|
||||
return id[x]
|
||||
end
|
||||
|
||||
-- wrap pcall to return one result
|
||||
-- error message are tested elsewhere
|
||||
local pc = pcall
|
||||
local pcall = function(...)
|
||||
local s,e = pc(...)
|
||||
if s then return e end
|
||||
return false, type(e)
|
||||
end
|
||||
|
||||
-- print
|
||||
print()
|
||||
print(11)
|
||||
print("abc",123,nil,"pqr")
|
||||
print( nil and 'T' or 'F' )
|
||||
print( false and 'T' or 'F' )
|
||||
print( 0 and 'T' or 'F' )
|
||||
|
||||
-- assert
|
||||
print( 'assert(true)', assert(true) )
|
||||
print( 'pcall(assert,true)', pcall(assert,true) )
|
||||
print( 'pcall(assert,false)', pcall(assert,false) )
|
||||
print( 'pcall(assert,nil)', pcall(assert,nil) )
|
||||
print( 'pcall(assert,true,"msg")', pcall(assert,true,"msg") )
|
||||
print( 'pcall(assert,false,"msg")', pcall(assert,false,"msg") )
|
||||
print( 'pcall(assert,nil,"msg")', pcall(assert,nil,"msg") )
|
||||
print( 'pcall(assert,false,"msg","msg2")', pcall(assert,false,"msg","msg2") )
|
||||
|
||||
-- collectgarbage (not supported)
|
||||
print( 'collectgarbage("count")', type(collectgarbage("count")))
|
||||
print( 'collectgarbage("collect")', type(collectgarbage("collect")))
|
||||
print( 'collectgarbage("count")', type(collectgarbage("count")))
|
||||
|
||||
-- dofile (not supported)
|
||||
-- ipairs
|
||||
print( 'pcall(ipairs)', pcall(ipairs) )
|
||||
print( 'pcall(ipairs,nil)', pcall(ipairs,nil) )
|
||||
print( 'pcall(ipairs,"a")', pcall(ipairs,"a") )
|
||||
print( 'pcall(ipairs,1)', pcall(ipairs,1) )
|
||||
for k,v in ipairs({}) do print('ipairs1',k,v)end
|
||||
for k,v in ipairs({'one','two'}) do print('ipairs2',k,v)end
|
||||
for k,v in ipairs({aa='aaa',bb='bbb'}) do print('ipairs3',k,v)end
|
||||
for k,v in ipairs({aa='aaa',bb='bbb','one','two'}) do print('ipairs4',k,v)end
|
||||
for k,v in ipairs({[30]='30',[20]='20'}) do print('ipairs5',k,v)end
|
||||
|
||||
-- load
|
||||
t = { "print ", "'table ", "loaded'", "", " print'after empty string'" }
|
||||
i = 0
|
||||
f = function() i = i + 1; return t[i]; end
|
||||
c,e = load(f)
|
||||
if c then print('load: ', pcall(c)) else print('load failed:', e) end
|
||||
|
||||
-- loadfile
|
||||
-- load
|
||||
local lst = "print(3+4); return 8"
|
||||
local chunk, err = load( lst )
|
||||
print( 'load("'..lst..'")', chunk, err )
|
||||
print( 'load("'..lst..'")()', chunk() )
|
||||
|
||||
-- pairs
|
||||
print( 'pcall(pairs)', pcall(pairs) )
|
||||
print( 'pcall(pairs,nil)', pcall(pairs,nil) )
|
||||
print( 'pcall(pairs,"a")', pcall(pairs,"a") )
|
||||
print( 'pcall(pairs,1)', pcall(pairs,1) )
|
||||
for k,v in pairs({}) do print('pairs1',k,v)end
|
||||
for k,v in pairs({'one','two'}) do print('pairs2',k,v)end
|
||||
for k,v in pairs({aa='aaa'}) do print('pairs3',k,v)end
|
||||
for k,v in pairs({aa='aaa','one','two'}) do print('pairs4',k,v)end
|
||||
for k,v in pairs({[20]='30',[30]='20'}) do print('pairs5',k,v)end
|
||||
|
||||
-- _G
|
||||
print( '_G["abc"] (before)', _G["abc"] )
|
||||
abc='def'
|
||||
print( '_G["abc"] (after)', _G["abc"] )
|
||||
|
||||
-- type
|
||||
print( 'type(nil)', type(nil) )
|
||||
print( 'type("a")', type("a") )
|
||||
print( 'type(1)', type(1) )
|
||||
print( 'type(1.5)', type(1.5) )
|
||||
print( 'type(function() end)', type(function() end) )
|
||||
print( 'type({})', type({}) )
|
||||
print( 'type(true)', type(true) )
|
||||
print( 'type(false)', type(false) )
|
||||
print( 'pcall(type,type)', pcall(type,type) )
|
||||
print( 'pcall(type)', pcall(type) )
|
||||
print( '(function() return pcall(type) end)()', (function() return pcall(type) end)() )
|
||||
local function la() return pcall(type) end
|
||||
print( 'la()', la() )
|
||||
function ga() return pcall(type) end
|
||||
print( 'ga()', ga() )
|
||||
|
||||
-- getmetatable, setmetatable
|
||||
ta = { aa1="aaa1", aa2="aaa2" }
|
||||
tb = { bb1="bbb1", bb2="bbb2" }
|
||||
print( 'getmetatable(ta)', getmetatable(ta) )
|
||||
print( 'getmetatable(tb)', getmetatable(tb) )
|
||||
print( 'setmetatable(ta),{cc1="ccc1"}', type( setmetatable(ta,{cc1="ccc1"}) ) )
|
||||
print( 'setmetatable(tb),{dd1="ddd1"}', type( setmetatable(tb,{dd1="ddd1"}) ) )
|
||||
print( 'getmetatable(ta)["cc1"]', getmetatable(ta)["cc1"] )
|
||||
print( 'getmetatable(tb)["dd1"]', getmetatable(tb)["dd1"] )
|
||||
print( 'getmetatable(1)', getmetatable(1) )
|
||||
print( 'pcall(setmetatable,1)', pcall(setmetatable,1) )
|
||||
print( 'pcall(setmetatable,nil)', pcall(setmetatable,nil) )
|
||||
print( 'pcall(setmetatable,"ABC")', pcall(setmetatable,"ABC") )
|
||||
print( 'pcall(setmetatable,function() end)', pcall(setmetatable,function() end) )
|
||||
|
||||
-- rawget,rawset
|
||||
local mt = {aa="aaa", bb="bbb"}
|
||||
mt.__index = mt
|
||||
mt.__newindex = mt
|
||||
local s = {cc="ccc", dd="ddd", }
|
||||
local t = {cc="ccc", dd="ddd"}
|
||||
setmetatable(t,mt)
|
||||
print( 'pcall(rawget)', pcall(rawget))
|
||||
print( 'pcall(rawget,"a")', pcall(rawget,"a"))
|
||||
print( 'pcall(rawget,s)', pcall(rawget,s))
|
||||
print( 'pcall(rawget,t)', pcall(rawget,t))
|
||||
|
||||
function printtables()
|
||||
function printtable(name,t)
|
||||
print( ' '..name, t["aa"], t["bb"], t["cc"], t["dd"], t["ee"], t["ff"], t["gg"] )
|
||||
print( ' '..name,
|
||||
rawget(t,"aa"),
|
||||
rawget(t,"bb"),
|
||||
rawget(t,"cc"),
|
||||
rawget(t,"dd"),
|
||||
rawget(t,"ee"),
|
||||
rawget(t,"ff"),
|
||||
rawget(t,"gg") )
|
||||
end
|
||||
printtable( 's', s )
|
||||
printtable( 't', t )
|
||||
printtable( 'mt', mt )
|
||||
end
|
||||
printtables()
|
||||
print( 'pcall(rawset,s,"aa","www")', rawset(s,"aa","www"))
|
||||
printtables()
|
||||
print( 'pcall(rawset,s,"cc","xxx")', rawset(s,"cc","xxx"))
|
||||
printtables()
|
||||
print( 'pcall(rawset,t,"aa","yyy")', rawset(t,"aa","yyy"))
|
||||
printtables()
|
||||
print( 'pcall(rawset,t,"dd","zzz")', rawset(t,"dd","zzz"))
|
||||
printtables()
|
||||
|
||||
-- rawlen
|
||||
print( 'pcall(rawlen, {})', pcall(rawlen, {}))
|
||||
print( 'pcall(rawlen, {"a"})', pcall(rawlen, {'a'}))
|
||||
print( 'pcall(rawlen, {"a","b"})', pcall(rawlen, {'a','b'}))
|
||||
print( 'pcall(rawlen, "")', pcall(rawlen, ""))
|
||||
print( 'pcall(rawlen, "a")', pcall(rawlen, 'a'))
|
||||
print( 'pcall(rawlen, "ab")', pcall(rawlen, 'ab'))
|
||||
print( 'pcall(rawlen, 1)', pcall(rawlen, 1))
|
||||
print( 'pcall(rawlen, nil)', pcall(rawlen, nil))
|
||||
print( 'pcall(rawlen)', pcall(rawlen))
|
||||
|
||||
printtables()
|
||||
print( 's["ee"]="ppp"' ); s["ee"]="ppp"
|
||||
printtables()
|
||||
print( 's["cc"]="qqq"' ); s["cc"]="qqq"
|
||||
printtables()
|
||||
print( 't["ff"]="rrr"' ); t["ff"]="rrr"
|
||||
printtables()
|
||||
print( 't["dd"]="sss"' ); t["dd"]="sss"
|
||||
printtables()
|
||||
print( 'mt["gg"]="ttt"' ); mt["gg"]="ttt"
|
||||
printtables()
|
||||
|
||||
|
||||
-- select
|
||||
print( 'pcall(select)', pcall(select) )
|
||||
print( 'select(1,11,22,33,44,55)', select(1,11,22,33,44,55) )
|
||||
print( 'select(2,11,22,33,44,55)', select(2,11,22,33,44,55) )
|
||||
print( 'select(3,11,22,33,44,55)', select(3,11,22,33,44,55) )
|
||||
print( 'select(4,11,22,33,44,55)', select(4,11,22,33,44,55) )
|
||||
print( 'pcall(select,5,11,22,33,44,55)', pcall(select,5,11,22,33,44,55) )
|
||||
print( 'pcall(select,6,11,22,33,44,55)', pcall(select,6,11,22,33,44,55) )
|
||||
print( 'pcall(select,7,11,22,33,44,55)', pcall(select,7,11,22,33,44,55) )
|
||||
print( 'pcall(select,0,11,22,33,44,55)', pcall(select,0,11,22,33,44,55) )
|
||||
print( 'pcall(select,-1,11,22,33,44,55)', pcall(select,-1,11,22,33,44,55) )
|
||||
print( 'pcall(select,-2,11,22,33,44,55)', pcall(select,-2,11,22,33,44,55) )
|
||||
print( 'pcall(select,-4,11,22,33,44,55)', pcall(select,-4,11,22,33,44,55) )
|
||||
print( 'pcall(select,-5,11,22,33,44,55)', pcall(select,-5,11,22,33,44,55) )
|
||||
print( 'pcall(select,-6,11,22,33,44,55)', pcall(select,-6,11,22,33,44,55) )
|
||||
print( 'pcall(select,1)', pcall(select,1) )
|
||||
print( 'pcall(select,select)', pcall(select,select) )
|
||||
print( 'pcall(select,{})', pcall(select,{}) )
|
||||
print( 'pcall(select,"2",11,22,33)', pcall(select,"2",11,22,33) )
|
||||
print( 'pcall(select,"abc",11,22,33)', pcall(select,"abc",11,22,33) )
|
||||
|
||||
|
||||
-- tonumber
|
||||
print( 'pcall(tonumber)', pcall(tostring) )
|
||||
print( 'pcall(tonumber,nil)', pcall(tonumber,nil) )
|
||||
print( 'pcall(tonumber,"abc")', pcall(tonumber,"abc") )
|
||||
print( 'pcall(tonumber,"123")', pcall(tonumber,"123") )
|
||||
print( 'pcall(tonumber,"123",10)', pcall(tonumber,"123", 10) )
|
||||
print( 'pcall(tonumber,"123",8)', pcall(tonumber,"123", 8) )
|
||||
print( 'pcall(tonumber,"123",6)', pcall(tonumber,"123", 6) )
|
||||
print( 'pcall(tonumber,"10101",4)', pcall(tonumber,"10101", 4) )
|
||||
print( 'pcall(tonumber,"10101",3)', pcall(tonumber,"10101", 3) )
|
||||
print( 'pcall(tonumber,"10101",2)', pcall(tonumber,"10101", 2) )
|
||||
print( 'pcall(tonumber,"1a1",16)', pcall(tonumber,"1a1", 16) )
|
||||
print( 'pcall(tonumber,"1a1",32)', pcall(tonumber,"1a1", 32) )
|
||||
print( 'pcall(tonumber,"1a1",54)', pcall(tonumber,"1a1", 54) )
|
||||
print( 'pcall(tonumber,"1a1",1)', pcall(tonumber,"1a1", 1) )
|
||||
print( 'pcall(tonumber,"1a1",0)', pcall(tonumber,"1a1", 0) )
|
||||
print( 'pcall(tonumber,"1a1",-1)', pcall(tonumber,"1a1", -1) )
|
||||
print( 'pcall(tonumber,"1a1","32")', pcall(tonumber,"1a1", "32") )
|
||||
print( 'pcall(tonumber,"123","456")', pcall(tonumber,"123","456") )
|
||||
print( 'pcall(tonumber,"1a1",10)', pcall(tonumber,"1a1", 10) )
|
||||
print( 'pcall(tonumber,"151",4)', pcall(tonumber,"151", 4) )
|
||||
print( 'pcall(tonumber,"151",3)', pcall(tonumber,"151", 3) )
|
||||
print( 'pcall(tonumber,"151",2)', pcall(tonumber,"151", 2) )
|
||||
print( 'pcall(tonumber,"123",8,8)', pcall(tonumber,"123", 8, 8) )
|
||||
print( 'pcall(tonumber,123)', pcall(tonumber,123) )
|
||||
print( 'pcall(tonumber,true)', pcall(tonumber,true) )
|
||||
print( 'pcall(tonumber,false)', pcall(tonumber,false) )
|
||||
print( 'pcall(tonumber,tonumber)', pcall(tonumber,tonumber) )
|
||||
print( 'pcall(tonumber,function() end)', pcall(tonumber,function() end) )
|
||||
print( 'pcall(tonumber,{"one","two",a="aa",b="bb"})', pcall(tonumber,{"one","two",a="aa",b="bb"}) )
|
||||
print( 'pcall(tonumber,"123.456")', pcall(tonumber,"123.456") )
|
||||
print( 'pcall(tonumber," 123.456")', pcall(tonumber," 123.456") )
|
||||
print( 'pcall(tonumber," 234qwer")', pcall(tonumber," 234qwer") )
|
||||
print( 'pcall(tonumber,"0x20")', pcall(tonumber,"0x20") )
|
||||
print( 'pcall(tonumber," 0x20")', pcall(tonumber," 0x20") )
|
||||
print( 'pcall(tonumber,"0x20 ")', pcall(tonumber,"0x20 ") )
|
||||
print( 'pcall(tonumber," 0x20 ")', pcall(tonumber," 0x20 ") )
|
||||
print( 'pcall(tonumber,"0X20")', pcall(tonumber,"0X20") )
|
||||
print( 'pcall(tonumber," 0X20")', pcall(tonumber," 0X20") )
|
||||
print( 'pcall(tonumber,"0X20 ")', pcall(tonumber,"0X20 ") )
|
||||
print( 'pcall(tonumber," 0X20 ")', pcall(tonumber," 0X20 ") )
|
||||
print( 'pcall(tonumber,"0x20",10)', pcall(tonumber,"0x20",10) )
|
||||
print( 'pcall(tonumber,"0x20",16)', pcall(tonumber,"0x20",16) )
|
||||
print( 'pcall(tonumber,"0x20",8)', pcall(tonumber,"0x20",8) )
|
||||
|
||||
-- tostring
|
||||
print( 'pcall(tostring)', pcall(tostring) )
|
||||
print( 'pcall(tostring,nil)', pcall(tostring,nil) )
|
||||
print( 'pcall(tostring,"abc")', pcall(tostring,"abc") )
|
||||
print( 'pcall(tostring,"abc","def")', pcall(tostring,"abc","def") )
|
||||
print( 'pcall(tostring,123)', pcall(tostring,123) )
|
||||
print( 'pcall(tostring,true)', pcall(tostring,true) )
|
||||
print( 'pcall(tostring,false)', pcall(tostring,false) )
|
||||
print( 'tostring(tostring)', type(tostring(tostring)) )
|
||||
print( 'tostring(function() end)', type(tostring(function() end)) )
|
||||
print( 'tostring({"one","two",a="aa",b="bb"})', type(tostring({"one","two",a="aa",b="bb"})) )
|
||||
|
||||
-- _VERSION
|
||||
print( '_VERSION', type(_VERSION) )
|
||||
|
||||
-- xpcall
|
||||
local errfunc = function( detail )
|
||||
print( ' in errfunc', type(detail) )
|
||||
return 'response-from-xpcall'
|
||||
end
|
||||
local badfunc = function() error( 'error-from-badfunc' ) end
|
||||
local wrappedbad = function() pcall( badfunc ) end
|
||||
print( 'pcall(badfunc)', pcall(badfunc) )
|
||||
print( 'pcall(badfunc,errfunc)', pcall(badfunc,errfunc) )
|
||||
print( 'pcall(badfunc,badfunc)', pcall(badfunc,badfunc) )
|
||||
print( 'pcall(wrappedbad)', pcall(wrappedbad) )
|
||||
print( 'pcall(wrappedbad,errfunc)', pcall(wrappedbad,errfunc) )
|
||||
print( 'pcall(xpcall(badfunc))', pcall(xpcall,badfunc) )
|
||||
print( 'pcall(xpcall(badfunc,errfunc))', pcall(xpcall,badfunc,errfunc) )
|
||||
print( 'pcall(xpcall(badfunc,badfunc))', pcall(xpcall,badfunc,badfunc) )
|
||||
print( 'pcall(xpcall(wrappedbad))', pcall(xpcall,wrappedbad) )
|
||||
print( 'xpcall(wrappedbad,errfunc)', xpcall(wrappedbad,errfunc) )
|
||||
|
||||
@@ -1,126 +0,0 @@
|
||||
function printrunning()
|
||||
if coroutine.running() == nil then
|
||||
print("running is nil");
|
||||
else
|
||||
print("running is not nil")
|
||||
end
|
||||
end
|
||||
|
||||
function foo (a)
|
||||
print("foo", a)
|
||||
return coroutine.yield(2*a)
|
||||
end
|
||||
|
||||
co = coroutine.create(function (a,b)
|
||||
print("co-body", a, b)
|
||||
local r = foo(a+1)
|
||||
print("co-body", r)
|
||||
local r, s = coroutine.yield(a+b, a-b)
|
||||
print("co-body", r, s)
|
||||
|
||||
printrunning()
|
||||
print("co.status.inside",coroutine.status(co));
|
||||
local co2 = coroutine.create(function()
|
||||
print("co.status.inside2",coroutine.status(co));
|
||||
end)
|
||||
print("co.status.inside",coroutine.status(co));
|
||||
coroutine.resume(co2);
|
||||
|
||||
return b, "end"
|
||||
end)
|
||||
|
||||
function exercise()
|
||||
printrunning()
|
||||
print("co.status",coroutine.status(co));
|
||||
print("main", coroutine.resume(co, 1, 10))
|
||||
print("co.status",coroutine.status(co));
|
||||
print("main", coroutine.resume(co, "r"))
|
||||
print("co.status",coroutine.status(co));
|
||||
print("main", coroutine.resume(co, "x", "y"))
|
||||
print("co.status",coroutine.status(co));
|
||||
print("main", coroutine.resume(co, "x", "y"))
|
||||
print("co.status",coroutine.status(co));
|
||||
end
|
||||
|
||||
exercise();
|
||||
|
||||
co = coroutine.create(function (a,b)
|
||||
print("co-body", a, b)
|
||||
-- TODO: make java and C behave the same for yielding in pcalls
|
||||
-- local status,r = pcall( foo, a+1 )
|
||||
foo(a+1)
|
||||
print("co-body", status,r)
|
||||
local r, s = coroutine.yield(a+b, a-b)
|
||||
print("co-body", r, s)
|
||||
return b, "end"
|
||||
end)
|
||||
|
||||
exercise();
|
||||
|
||||
|
||||
-- wrap test
|
||||
local g = coroutine.wrap(function (a,b)
|
||||
print("co-body", a, b)
|
||||
local r = foo(a+1)
|
||||
print("co-body", r)
|
||||
local r, s = coroutine.yield(a+b, a-b)
|
||||
print("co-body", r, s)
|
||||
return b, "end"
|
||||
end )
|
||||
|
||||
print("g", g(1, 10))
|
||||
print("g", g("r"))
|
||||
print("g", g("x", "y"))
|
||||
local s,e = pcall( g, "x", "y" )
|
||||
print("g", string.match(e,'cannot resume dead coroutine') or 'badmessage: '..tostring(e))
|
||||
|
||||
-- varargs passing
|
||||
local echo = function(msg,...)
|
||||
print( msg, ...)
|
||||
return ...
|
||||
end
|
||||
local echocr = function(...)
|
||||
local arg = table.pack(...)
|
||||
echo('(echocr) first args', table.unpack(arg,1,arg.n))
|
||||
local a = arg
|
||||
while true do
|
||||
a = { echo( '(echoch) yield returns', coroutine.yield( table.unpack(a) ) ) }
|
||||
end
|
||||
end
|
||||
local c = coroutine.create( echocr )
|
||||
local step = function(...)
|
||||
echo( '(main) resume returns',
|
||||
coroutine.resume(c, echo('(main) sending args', ...)) )
|
||||
end
|
||||
step(111,222,333)
|
||||
step()
|
||||
step(111)
|
||||
step(111,222,333)
|
||||
|
||||
-- test loops in resume calls
|
||||
b = coroutine.create( function( arg )
|
||||
while ( true ) do
|
||||
print( ' b-resumed', arg, b == coroutine.running() )
|
||||
print( ' b-b', coroutine.status(b) )
|
||||
print( ' b-c', coroutine.status(c) )
|
||||
print( ' b-resume-b',coroutine.resume( b, 'b-arg-for-b' ) )
|
||||
print( ' b-resume-c',coroutine.resume( c, 'b-arg-for-c' ) )
|
||||
arg = coroutine.yield( 'b-rslt' )
|
||||
end
|
||||
end )
|
||||
c = coroutine.create( function( arg )
|
||||
for i=1,3 do
|
||||
print( ' c-resumed', arg, c == coroutine.running() )
|
||||
print( ' c-b', coroutine.status(b) )
|
||||
print( ' c-c', coroutine.status(c) )
|
||||
print( ' c-resume-b',coroutine.resume( b, 'b-arg-for-b' ) )
|
||||
print( ' c-resume-c',coroutine.resume( c, 'b-arg-for-c' ) )
|
||||
arg = coroutine.yield( 'c-rslt' )
|
||||
end
|
||||
end )
|
||||
for i=1,3 do
|
||||
print( 'main-b', coroutine.status(b) )
|
||||
print( 'main-c', coroutine.status(c) )
|
||||
print( 'main-resume-b',coroutine.resume( b, 'main-arg-for-b' ) )
|
||||
print( 'main-resume-c',coroutine.resume( c, 'main-arg-for-c' ) )
|
||||
end
|
||||
@@ -1,280 +0,0 @@
|
||||
|
||||
local print,tostring,_G,pcall,ipairs,isnumber = print,tostring,_G,pcall,ipairs,isnumber
|
||||
local e,f,g,h,s
|
||||
print( 'has debug', debug~=nil )
|
||||
if not debug then error( 'no debug' ) end
|
||||
|
||||
|
||||
print( '----- debug.getlocal, debug.setlocal' )
|
||||
h = function(v,i,n)
|
||||
s = 'h-'..v..'-'..i
|
||||
local x1,y1 = debug.getlocal(v,i)
|
||||
local x2,y2 = debug.setlocal(v,i,n)
|
||||
local x3,y3 = debug.getlocal(v,i)
|
||||
return s..' -> '..v..'-'..i..' '..
|
||||
'get='..tostring(x1)..','..tostring(y1)..' '..
|
||||
'set='..tostring(x2)..','..tostring(y2)..' '..
|
||||
'get='..tostring(x3)..','..tostring(y3)..' '
|
||||
end
|
||||
g = function(...)
|
||||
local p,q,r=7,8,9
|
||||
local t = h(...)
|
||||
local b = table.concat({...},',')
|
||||
return t..'\tg locals='..p..','..q..','..r..' tbl={'..b..'}'
|
||||
end
|
||||
f = function(a,b,c)
|
||||
local d,e,f = 4,5,6
|
||||
local t = g(a,b,c)
|
||||
return t..'\tf locals='..','..a..','..b..','..c..','..d..','..e..','..f
|
||||
end
|
||||
for lvl=3,2,-1 do
|
||||
for lcl=0,7 do
|
||||
print( pcall( f, lvl, lcl, '#' ) )
|
||||
end
|
||||
end
|
||||
for lvl=1,1 do
|
||||
for lcl=3,7 do
|
||||
print( pcall( f, lvl, lcl, '#' ) )
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
print( '----- debug.getupvalue, debug.setupvalue' )
|
||||
local m,n,o = 101,102,103
|
||||
f = function(p,q,r)
|
||||
local p,q,r = 104,105,106
|
||||
local g = function(s,t,u)
|
||||
local v,w,x = 107,108,109
|
||||
return function()
|
||||
return m,n,o,p,q,r,v,w,x
|
||||
end
|
||||
end
|
||||
return g
|
||||
end
|
||||
g = f()
|
||||
h = g()
|
||||
local callh = function()
|
||||
local t = {}
|
||||
for i,v in ipairs( { pcall(h) } ) do
|
||||
t[i] = tostring(v)
|
||||
end
|
||||
return table.concat(t,',')
|
||||
end
|
||||
print( 'h', h() )
|
||||
local funs = { f, g, h }
|
||||
local names = { 'f', 'g', 'h' }
|
||||
for i=1,3 do
|
||||
local fun,name = funs[i],names[i]
|
||||
for index=0,10 do
|
||||
local s1,x1,y1 = pcall( debug.getupvalue, fun, index )
|
||||
local s2,x2,y2 = pcall( debug.setupvalue, fun, index, 666000+i*111000+index )
|
||||
local s3,x3,y3 = pcall( debug.getupvalue, fun, index )
|
||||
print( name..' -> '..i..'-'..index..' '..
|
||||
'get='..tostring(s1)..','..tostring(x1)..','..tostring(y1)..' '..
|
||||
'set='..tostring(s2)..','..tostring(x2)..','..tostring(y2)..' '..
|
||||
'get='..tostring(s3)..','..tostring(x3)..','..tostring(y3)..' '..
|
||||
'tbl='..callh() )
|
||||
end
|
||||
end
|
||||
|
||||
print( '----- debug.setmetatable, debug.getmetatable' )
|
||||
local a = {a='bbb'}
|
||||
local b = {}
|
||||
local mt = {__index={b='ccc'}}
|
||||
print( 'a.a='..tostring(a.a)..' a.b='..tostring(a.b)..' b.a='..tostring(b.a)..' b.b='..tostring(b.b))
|
||||
local s1,x1,y1 = pcall( debug.getmetatable, a )
|
||||
local s2,x2,y2 = pcall( debug.setmetatable, a, mt )
|
||||
print( 'a.a='..tostring(a.a)..' a.b='..tostring(a.b)..' b.a='..tostring(b.a)..' b.b='..tostring(b.b))
|
||||
local s3,x3,y3 = pcall( debug.getmetatable, a ) print(type(s3), type(x3), type(y3), type(getmetatable(a)))
|
||||
local s4,x4,y4 = pcall( debug.getmetatable, b ) print(type(s4), type(x4), type(y4), type(getmetatable(b)))
|
||||
local s5,x5,y5 = pcall( debug.setmetatable, a, nil ) print(type(s5), type(x5), type(y5), type(getmetatable(a)))
|
||||
print( 'a.a='..tostring(a.a)..' a.b='..tostring(a.b)..' b.a='..tostring(b.a)..' b.b='..tostring(b.b))
|
||||
local s6,x6,y6 = pcall( debug.getmetatable, a ) print(type(s6), type(x6), type(y6), type(getmetatable(a)))
|
||||
if not s1 then print( 's1 error', x1 ) end
|
||||
if not s2 then print( 's2 error', x2 ) end
|
||||
if not s3 then print( 's3 error', x3 ) end
|
||||
if not s4 then print( 's4 error', x4 ) end
|
||||
if not s5 then print( 's5 error', x5 ) end
|
||||
if not s6 then print( 's6 error', x6 ) end
|
||||
print( 'get='..tostring(s1)..','..tostring(x1==nil)..','..tostring(y1) )
|
||||
print( 'set='..tostring(s2)..','..tostring(x2==a)..','..tostring(y2) )
|
||||
print( 'get='..tostring(s3)..','..tostring(x3==mt)..','..tostring(y3) )
|
||||
print( 'get='..tostring(s4)..','..tostring(x4==nil)..','..tostring(y4) )
|
||||
print( 'set='..tostring(s5)..','..tostring(x5==a)..','..tostring(y5) )
|
||||
print( 'get='..tostring(s6)..','..tostring(x6==nil)..','..tostring(y6) )
|
||||
print( pcall( debug.getmetatable, 1 ) )
|
||||
print( pcall( debug.setmetatable, 1, {} ) )
|
||||
print( pcall( debug.setmetatable, 1, nil ) )
|
||||
|
||||
print( '----- debug.getinfo' )
|
||||
local printfield = function(tbl, field)
|
||||
local x = tbl[field]
|
||||
if x == nil then return end
|
||||
local typ = type(x)
|
||||
if typ=='table' then
|
||||
x = '{'..table.concat(x,',')..'}'
|
||||
elseif typ=='function' then
|
||||
x = typ
|
||||
end
|
||||
print( ' '..field..': '..tostring(x) )
|
||||
end
|
||||
local fields = { 'source', 'short_src', 'what',
|
||||
'currentline', 'linedefined', 'lastlinedefined',
|
||||
'nups', 'func', 'activelines' }
|
||||
local printinfo = function(...)
|
||||
for i,a in ipairs({...}) do
|
||||
if type(a) == 'table' then
|
||||
for j,field in ipairs(fields) do
|
||||
printfield( a, field)
|
||||
end
|
||||
else
|
||||
print( tostring(a) )
|
||||
end
|
||||
end
|
||||
end
|
||||
function test()
|
||||
local x = 5
|
||||
function f()
|
||||
x = x + 1
|
||||
return x
|
||||
end
|
||||
function g()
|
||||
x = x - 1
|
||||
print( '---' )
|
||||
printinfo( 'debug.getinfo(1)', debug.getinfo(1) )
|
||||
printinfo( 'debug.getinfo(1,"")', debug.getinfo(1, "") )
|
||||
printinfo( 'debug.getinfo(1,"l")', debug.getinfo(1, "l") )
|
||||
printinfo( 'debug.getinfo(1,"fL")', debug.getinfo(1, "fL") )
|
||||
printinfo( 'debug.getinfo(2)', debug.getinfo(2) )
|
||||
printinfo( 'debug.getinfo(2,"l")', debug.getinfo(2, "l") )
|
||||
printinfo( 'debug.getinfo(2,"fL")', debug.getinfo(2, "fL") )
|
||||
printinfo( 'debug.getinfo(10,"")', pcall( debug.getinfo, 10, "" ) )
|
||||
printinfo( 'debug.getinfo(-10,"")', pcall( debug.getinfo, -10, "" ) )
|
||||
print( '---' )
|
||||
return x
|
||||
end
|
||||
print(f())
|
||||
print(g())
|
||||
return f, g
|
||||
end
|
||||
|
||||
local options = "nSlufL"
|
||||
local e,f,g = pcall( test )
|
||||
print( 'e,f,g', e, type(f), type(g) )
|
||||
printinfo( 'debug.getinfo(f)', pcall(debug.getinfo, f) )
|
||||
printinfo( 'debug.getinfo(f,"'..options..'")', pcall(debug.getinfo, f, options) )
|
||||
for j=1,6 do
|
||||
local opts = options:sub(j,j)
|
||||
printinfo( 'debug.getinfo(f,"'..opts..'")', pcall(debug.getinfo, f, opts) )
|
||||
end
|
||||
printinfo( 'debug.getinfo(g)', pcall(debug.getinfo, g) )
|
||||
printinfo( 'debug.getinfo(test)', pcall(debug.getinfo, test) )
|
||||
|
||||
print( '----- debug.sethook, debug.gethook' )
|
||||
f = function(x)
|
||||
g = function(y)
|
||||
return math.min(x,h)
|
||||
end
|
||||
local a = g(x)
|
||||
return a + a
|
||||
end
|
||||
local hook = function(...)
|
||||
print( ' ... in hook', ... )
|
||||
local info = debug.getinfo(2,"Sl")
|
||||
if info then
|
||||
print( ' info[2]='..tostring(info.short_src)..','..tostring(info.currentline) )
|
||||
end
|
||||
end
|
||||
local tryfunc = function(hook,mask,func,arg)
|
||||
local x,f,h,m
|
||||
pcall( function()
|
||||
debug.sethook(hook,mask)
|
||||
x = func(arg)
|
||||
f,h,m = debug.gethook()
|
||||
end )
|
||||
debug.sethook()
|
||||
return x,f,h,m
|
||||
end
|
||||
|
||||
local tryhooks = function(mask)
|
||||
local s1,a1,b1,c1,d1 = pcall( tryfunc, hook, mask, f, 333 )
|
||||
print( 'hook = '..mask..' -> '..
|
||||
'result='..tostring(s1)..','..tostring(a1)..','..
|
||||
type(b1)..','..type(c1)..','..
|
||||
tostring(b1==f)..','..tostring(c1==hook)..','..
|
||||
tostring(d1)..' ' )
|
||||
end
|
||||
|
||||
tryhooks("c")
|
||||
tryhooks("r")
|
||||
tryhooks("l")
|
||||
tryhooks("crl")
|
||||
|
||||
print( '----- debug.traceback' )
|
||||
function test()
|
||||
function a(msg)
|
||||
print((string.gsub(debug.traceback(msg), "%[Java]", "[C]")))
|
||||
end
|
||||
local function b(msg)
|
||||
pcall(a,msg)
|
||||
end
|
||||
c = function(i)
|
||||
if i <= 0 then b('hi') return end
|
||||
return c(i-1)
|
||||
end
|
||||
d = setmetatable({},{__index=function(t,k) v = c(k) return v end})
|
||||
local e = function()
|
||||
return d[0]
|
||||
end
|
||||
local f = {
|
||||
g = function()
|
||||
e()
|
||||
end
|
||||
}
|
||||
h = function()
|
||||
f.g()
|
||||
end
|
||||
local i = h
|
||||
i()
|
||||
end
|
||||
pcall(test)
|
||||
|
||||
|
||||
print( '----- debug.upvalueid' )
|
||||
local x,y = 100,200
|
||||
function a(b,c)
|
||||
local z,w = b,c
|
||||
return function()
|
||||
x,y,z,w = x+1,y+1,z+1,w+1
|
||||
return x,y,z,w
|
||||
end
|
||||
end
|
||||
a1 = a(300,400)
|
||||
a2 = a(500,600)
|
||||
print('debug.getupvalue(a1,1)', debug.getupvalue(a1,1))
|
||||
print('debug.getupvalue(a1,2)', debug.getupvalue(a1,2))
|
||||
print('debug.getupvalue(a2,1)', debug.getupvalue(a2,1))
|
||||
print('debug.getupvalue(a2,2)', debug.getupvalue(a2,2))
|
||||
print('debug.upvalueid(a1,1) == debug.upvalueid(a1,1)', debug.upvalueid(a1,1) == debug.upvalueid(a1,1))
|
||||
print('debug.upvalueid(a1,1) == debug.upvalueid(a2,1)', debug.upvalueid(a1,1) == debug.upvalueid(a2,1))
|
||||
print('debug.upvalueid(a1,1) == debug.upvalueid(a1,2)', debug.upvalueid(a1,1) == debug.upvalueid(a1,2))
|
||||
|
||||
print( '----- debug.upvaluejoin' )
|
||||
print('a1',a1())
|
||||
print('a2',a2())
|
||||
print('debug.upvaluejoin(a1,1,a2,2)', debug.upvaluejoin(a1,1,a2,2))
|
||||
print('debug.upvaluejoin(a1,3,a2,4)', debug.upvaluejoin(a1,3,a2,4))
|
||||
print('a1',a1())
|
||||
print('a2',a2())
|
||||
print('a1',a1())
|
||||
print('a2',a2())
|
||||
for i = 1,4 do
|
||||
print('debug.getupvalue(a1,'..i..')', debug.getupvalue(a1,i))
|
||||
print('debug.getupvalue(a2,'..i..')', debug.getupvalue(a2,i))
|
||||
for j = 1,4 do
|
||||
print('debug.upvalueid(a1,'..i..') == debug.upvalueid(a1,'..j..')', debug.upvalueid(a1,i) == debug.upvalueid(a1,j))
|
||||
print('debug.upvalueid(a1,'..i..') == debug.upvalueid(a2,'..j..')', debug.upvalueid(a1,i) == debug.upvalueid(a2,j))
|
||||
print('debug.upvalueid(a2,'..i..') == debug.upvalueid(a1,'..j..')', debug.upvalueid(a2,i) == debug.upvalueid(a1,j))
|
||||
print('debug.upvalueid(a2,'..i..') == debug.upvalueid(a2,'..j..')', debug.upvalueid(a2,i) == debug.upvalueid(a2,j))
|
||||
end
|
||||
end
|
||||
@@ -1,137 +0,0 @@
|
||||
-- tostring replacement that assigns ids
|
||||
local ts,id,nid,types = tostring,{},0,{table='tbl',thread='thr',userdata='uda',['function']='func'}
|
||||
tostring = function(x)
|
||||
if not x or not types[type(x)] then return ts(x) end
|
||||
if not id[x] then nid=nid+1; id[x]=types[type(x)]..'.'..nid end
|
||||
return id[x]
|
||||
end
|
||||
|
||||
-- test of common types of errors
|
||||
-- local function c(f,...) return f(...) end
|
||||
-- local function b(...) return c(...) end
|
||||
--local function a(...) return (pcall(b,...)) end
|
||||
local function a(...) local s,e=pcall(...) if s then return s,e else return false,type(e) end end
|
||||
s = 'some string'
|
||||
local t = {}
|
||||
-- error message tests
|
||||
print( 'a(error)', a(error) )
|
||||
print( 'a(error,"msg")', a(error,"msg") )
|
||||
print( 'a(error,"msg",0)', a(error,"msg",0) )
|
||||
print( 'a(error,"msg",1)', a(error,"msg",1) )
|
||||
print( 'a(error,"msg",2)', a(error,"msg",2) )
|
||||
print( 'a(error,"msg",3)', a(error,"msg",3) )
|
||||
print( 'a(error,"msg",4)', a(error,"msg",4) )
|
||||
print( 'a(error,"msg",5)', a(error,"msg",5) )
|
||||
print( 'a(error,"msg",6)', a(error,"msg",6) )
|
||||
|
||||
-- call errors
|
||||
print( 'a(nil())', a(function() return n() end) )
|
||||
print( 'a(t()) ', a(function() return t() end) )
|
||||
print( 'a(s()) ', a(function() return s() end) )
|
||||
print( 'a(true())', a(function() local b = true; return b() end) )
|
||||
|
||||
-- arithmetic errors
|
||||
print( 'a(nil+1)', a(function() return nil+1 end) )
|
||||
print( 'a(a+1) ', a(function() return a+1 end) )
|
||||
print( 'a(s+1) ', a(function() return s+1 end) )
|
||||
print( 'a(true+1)', a(function() local b = true; return b+1 end) )
|
||||
|
||||
-- table errors
|
||||
print( 'a(nil.x)', a(function() return n.x end) )
|
||||
print( 'a(a.x) ', a(function() return a.x end) )
|
||||
print( 'a(s.x) ', a(function() return s.x end) )
|
||||
print( 'a(true.x)', a(function() local b = true; return b.x end) )
|
||||
print( 'a(nil.x=5)', a(function() n.x=5 end) )
|
||||
print( 'a(a.x=5) ', a(function() a.x=5 end) )
|
||||
print( 'a(s.x=5) ', a(function() s.x=5 end) )
|
||||
print( 'a(true.x=5)', a(function() local b = true; b.x=5 end) )
|
||||
|
||||
-- len operator
|
||||
print( 'a(#nil) ', a(function() return #n end) )
|
||||
print( 'a(#t) ', a(function() return #t end) )
|
||||
print( 'a(#s) ', a(function() return #s end) )
|
||||
print( 'a(#a) ', a(function() return #a end) )
|
||||
print( 'a(#true)', a(function() local b = true; return #b end) )
|
||||
|
||||
-- comparison errors
|
||||
print( 'a(nil>1)', a(function() return nil>1 end) )
|
||||
print( 'a(a>1) ', a(function() return a>1 end) )
|
||||
print( 'a(s>1) ', a(function() return s>1 end) )
|
||||
print( 'a(true>1)', a(function() local b = true; return b>1 end) )
|
||||
|
||||
-- unary minus errors
|
||||
print( 'a(-nil)', a(function() return -n end) )
|
||||
print( 'a(-a) ', a(function() return -a end) )
|
||||
print( 'a(-s) ', a(function() return -s end) )
|
||||
print( 'a(-true)', a(function() local b = true; return -b end) )
|
||||
|
||||
-- string concatenation
|
||||
local function concatsuite(comparefunc)
|
||||
print( '"a".."b"', comparefunc("a","b") )
|
||||
print( '"a"..nil', comparefunc("a",nil) )
|
||||
print( 'nil.."b"', comparefunc(nil,"b") )
|
||||
print( '"a"..{}', comparefunc("a",{}) )
|
||||
print( '{}.."b"', comparefunc({},"b") )
|
||||
print( '"a"..2', comparefunc("a",2) )
|
||||
print( '2.."b"', comparefunc(2,"b") )
|
||||
print( '"a"..print', comparefunc("a",print) )
|
||||
print( 'print.."b"', comparefunc(print,"b") )
|
||||
print( '"a"..true', comparefunc("a",true) )
|
||||
print( 'true.."b"', comparefunc(true,"b") )
|
||||
print( 'nil..true', comparefunc(nil,true) )
|
||||
print( '"a"..3.5', comparefunc("a",3.5) )
|
||||
print( '3.5.."b"', comparefunc(3.5,"b") )
|
||||
end
|
||||
local function strconcat(a,b)
|
||||
return (pcall( function() return a..b end) )
|
||||
end
|
||||
local function tblconcat(a,b)
|
||||
local t={a,b}
|
||||
return (pcall( function() return table.concat(t,'-',1,2) end ))
|
||||
end
|
||||
|
||||
print( '-------- string concatenation' )
|
||||
concatsuite(strconcat)
|
||||
print( '-------- table concatenation' )
|
||||
concatsuite(tblconcat)
|
||||
|
||||
-- pairs
|
||||
print( '-------- pairs tests' )
|
||||
print( 'a(pairs(nil))', a(function() return pairs(nil,{}) end) )
|
||||
print( 'a(pairs(a)) ', a(function() return pairs(a,{}) end) )
|
||||
print( 'a(pairs(s)) ', a(function() return pairs(s,{}) end) )
|
||||
print( 'a(pairs(t)) ', a(function() return pairs(t,{}) end) )
|
||||
print( 'a(pairs(true))', a(function() local b = true; return pairs(b,{}) end) )
|
||||
|
||||
-- setmetatable
|
||||
print( '-------- setmetatable tests' )
|
||||
function sm(...)
|
||||
return tostring(setmetatable(...))
|
||||
end
|
||||
print( 'a(setmetatable(nil))', a(function() return sm(nil,{}) end) )
|
||||
print( 'a(setmetatable(a)) ', a(function() return sm(a,{}) end) )
|
||||
print( 'a(setmetatable(s)) ', a(function() return sm(s,{}) end) )
|
||||
print( 'a(setmetatable(true))', a(function() local b = true; return sm(b,{}) end) )
|
||||
print( 'a(setmetatable(t)) ', a(function() return sm(t,{}) end) )
|
||||
print( 'a(getmetatable(t)) ', a(function() return getmetatable(t),type(getmetatable(t)) end) )
|
||||
print( 'a(setmetatable(t*)) ', a(function() return sm(t,{__metatable={}}) end) )
|
||||
print( 'a(getmetatable(t)) ', a(function() return getmetatable(t),type(getmetatable(t)) end) )
|
||||
print( 'a(setmetatable(t)) ', a(function() return sm(t,{}) end) )
|
||||
print( 'a(getmetatable(t)) ', a(function() return getmetatable(t),type(getmetatable(t)) end) )
|
||||
t = {}
|
||||
print( 'a(setmetatable(t)) ', a(function() return sm(t,{}) end) )
|
||||
print( 'a(getmetatable(t)) ', a(function() return getmetatable(t),type(getmetatable(t)) end) )
|
||||
print( 'a(setmetatable(t*)) ', a(function() return sm(t,{__metatable='some string'}) end) )
|
||||
print( 'a(getmetatable(t)) ', a(function() return getmetatable(t),type(getmetatable(t)) end) )
|
||||
print( 'a(setmetatable(t)) ', a(function() return sm(t,{}) end) )
|
||||
print( 'a(getmetatable(t)) ', a(function() return getmetatable(t),type(getmetatable(t)) end) )
|
||||
print( 'a(setmetatable(t,nil)) ', a(function() return sm(t,nil) end) )
|
||||
print( 'a(setmetatable(t)) ', a(function() return sm(t) end) )
|
||||
print( 'a(setmetatable({},"abc")) ', a(function() return sm({},'abc') end) )
|
||||
|
||||
-- bad args to error!
|
||||
print( 'error("msg","arg")', a(function() error('some message', 'some bad arg') end) )
|
||||
|
||||
-- loadfile, dofile on missing files
|
||||
print( 'loadfile("bogus.txt")', a(function() return loadfile("bogus.txt") end) )
|
||||
print( 'dofile("bogus.txt")', a(function() return dofile("bogus.txt") end) )
|
||||
@@ -1,198 +0,0 @@
|
||||
-- utilities to check that args of various types pass or fail
|
||||
-- argument type checking
|
||||
local ok = '-\t'
|
||||
local fail = 'fail '
|
||||
local needcheck = 'needcheck '
|
||||
local badmsg = 'badmsg '
|
||||
|
||||
akey = 'aa'
|
||||
astring = 'abc'
|
||||
astrnum = '789'
|
||||
anumber = 1.25
|
||||
ainteger = 345
|
||||
adouble = 12.75
|
||||
aboolean = true
|
||||
atable = {[akey]=456}
|
||||
afunction = function() end
|
||||
anil = nil
|
||||
athread = coroutine.create(afunction)
|
||||
|
||||
anylua = { nil, astring, anumber, aboolean, atable, afunction, athread }
|
||||
|
||||
somestring = { astring, anumber }
|
||||
somenumber = { anumber, astrnum }
|
||||
someboolean = { aboolean }
|
||||
sometable = { atable }
|
||||
somefunction = { afunction }
|
||||
somenil = { anil }
|
||||
somekey = { akey }
|
||||
notakey = { astring, anumber, aboolean, atable, afunction }
|
||||
|
||||
notastring = { nil, aboolean, atable, afunction, athread }
|
||||
notanumber = { nil, astring, aboolean, atable, afunction, athread }
|
||||
notaboolean = { nil, astring, anumber, atable, afunction, athread }
|
||||
notatable = { nil, astring, anumber, aboolean, afunction, athread }
|
||||
notafunction = { nil, astring, anumber, aboolean, atable, athread }
|
||||
notathread = { nil, astring, anumber, aboolean, atable, afunction }
|
||||
notanil = { astring, anumber, aboolean, atable, afunction, athread }
|
||||
|
||||
nonstring = { aboolean, atable, afunction, athread }
|
||||
nonnumber = { astring, aboolean, atable, afunction, athread }
|
||||
nonboolean = { astring, anumber, atable, afunction, athread }
|
||||
nontable = { astring, anumber, aboolean, afunction, athread }
|
||||
nonfunction = { astring, anumber, aboolean, atable, athread }
|
||||
nonthread = { astring, anumber, aboolean, atable, afunction }
|
||||
nonkey = { astring, anumber, aboolean, atable, afunction }
|
||||
|
||||
local structtypes = {
|
||||
['table']='<table>',
|
||||
['function']='<function>',
|
||||
['thread']='<thread>',
|
||||
['userdata']='<userdata>',
|
||||
}
|
||||
|
||||
local function bracket(v)
|
||||
return "<"..type(v)..">"
|
||||
end
|
||||
|
||||
local function quote(v)
|
||||
return "'"..v.."'"
|
||||
end
|
||||
|
||||
local function ellipses(v)
|
||||
local s = tostring(v)
|
||||
return #s <= 8 and s or (string.sub(s,1,8)..'...')
|
||||
end
|
||||
|
||||
local pretty = {
|
||||
['table']=bracket,
|
||||
['function']=bracket,
|
||||
['thread']=bracket,
|
||||
['userdata']=bracket,
|
||||
['string']= quote,
|
||||
['number']= ellipses,
|
||||
}
|
||||
|
||||
local function values(list)
|
||||
local t = {}
|
||||
for i=1,(list.n or #list) do
|
||||
local ai = list[i]
|
||||
local fi = pretty[type(ai)]
|
||||
t[i] = fi and fi(ai) or tostring(ai)
|
||||
end
|
||||
return table.concat(t,',')
|
||||
end
|
||||
|
||||
local function types(list)
|
||||
local t = {}
|
||||
for i=1,(list.n or #list) do
|
||||
local ai = list[i]
|
||||
t[i] = type(ai)
|
||||
end
|
||||
return table.concat(t,',')
|
||||
end
|
||||
|
||||
local function signature(name,arglist)
|
||||
return name..'('..values(arglist)..')'
|
||||
end
|
||||
|
||||
local function dup(t)
|
||||
local s = {}
|
||||
for i=1,(t.n or #t) do
|
||||
s[i] = t[i]
|
||||
end
|
||||
return s
|
||||
end
|
||||
|
||||
local function split(t)
|
||||
local s = {}
|
||||
local n = (t.n or #t)
|
||||
for i=1,n-1 do
|
||||
s[i] = t[i]
|
||||
end
|
||||
return s,t[n]
|
||||
end
|
||||
|
||||
local function expand(argsets, typesets, ...)
|
||||
local arg = table.pack(...)
|
||||
local n = typesets and #typesets or 0
|
||||
if n <= 0 then
|
||||
table.insert(argsets,arg)
|
||||
return argsets
|
||||
end
|
||||
|
||||
local s,v = split(typesets)
|
||||
for i=1,(v.n or #v) do
|
||||
expand(argsets, s, v[i], table.unpack(arg,1,arg.n))
|
||||
end
|
||||
return argsets
|
||||
end
|
||||
|
||||
local function arglists(typesets)
|
||||
local argsets = expand({},typesets)
|
||||
return ipairs(argsets)
|
||||
end
|
||||
|
||||
function lookup( name )
|
||||
return load('return '..name)()
|
||||
end
|
||||
|
||||
function invoke( name, arglist )
|
||||
local s,c = pcall(lookup, name)
|
||||
if not s then return s,c end
|
||||
return pcall(c, table.unpack(arglist,1,arglist.n or #arglist))
|
||||
end
|
||||
|
||||
-- messages, banners
|
||||
local _print = print
|
||||
local _tostring = tostring
|
||||
local _find = string.find
|
||||
function banner(name)
|
||||
_print( '====== '.._tostring(name)..' ======' )
|
||||
end
|
||||
|
||||
local function subbanner(name)
|
||||
_print( '--- '.._tostring(name) )
|
||||
end
|
||||
|
||||
local function pack(s,...)
|
||||
return s,{...}
|
||||
end
|
||||
|
||||
-- check that all combinations of arguments pass
|
||||
function checkallpass( name, typesets, typesonly )
|
||||
subbanner('checkallpass')
|
||||
for i,v in arglists(typesets) do
|
||||
local sig = signature(name,v)
|
||||
local s,r = pack( invoke( name, v ) )
|
||||
if s then
|
||||
if typesonly then
|
||||
_print( ok, sig, types(r) )
|
||||
else
|
||||
_print( ok, sig, values(r) )
|
||||
end
|
||||
else
|
||||
_print( fail, sig, values(r) )
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- check that all combinations of arguments fail in some way,
|
||||
-- ignore error messages
|
||||
function checkallerrors( name, typesets, template )
|
||||
subbanner('checkallerrors')
|
||||
template = _tostring(template)
|
||||
for i,v in arglists(typesets) do
|
||||
local sig = signature(name,v)
|
||||
local s,e = invoke( name, v )
|
||||
if not s then
|
||||
if _find(e, template, 1, true) then
|
||||
_print( ok, sig, '...'..template..'...' )
|
||||
else
|
||||
_print( badmsg, sig, "template='"..template.."' actual='"..e.."'" )
|
||||
end
|
||||
else
|
||||
_print( needcheck, sig, e )
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -1,145 +0,0 @@
|
||||
package.path = "?.lua;test/lua/errors/?.lua"
|
||||
require 'args'
|
||||
|
||||
-- arg types for basic library functions
|
||||
|
||||
-- assert
|
||||
banner('assert')
|
||||
checkallpass('assert',{{true,123},anylua})
|
||||
checkallerrors('assert',{{nil,false,n=2},{nil,n=1}},'assertion failed')
|
||||
checkallerrors('assert',{{nil,false,n=2},{'message'}},'message')
|
||||
|
||||
-- collectgarbage
|
||||
banner('collectgarbage')
|
||||
checkallpass('collectgarbage',{{'collect','count'}},true)
|
||||
checkallerrors('collectgarbage',{{astring, anumber}},'bad argument')
|
||||
checkallerrors('collectgarbage',{{aboolean, atable, afunction, athread}},'string expected')
|
||||
|
||||
-- dofile
|
||||
banner('dofile')
|
||||
--checkallpass('dofile', {})
|
||||
--checkallpass('dofile', {{'test/lua/errors/args.lua'}})
|
||||
--checkallerrors('dofile', {{'foo.bar'}}, 'cannot open foo.bar')
|
||||
--checkallerrors('dofile', {nonstring}, 'bad argument')
|
||||
|
||||
-- error
|
||||
banner('error')
|
||||
--checkallerrors('error', {{'message'},{nil,0,1,2,n=4}}, 'message')
|
||||
--checkallerrors('error', {{123},{nil,1,2,n=3}}, 123)
|
||||
|
||||
-- getmetatable
|
||||
banner('getmetatable')
|
||||
checkallpass('getmetatable', {notanil})
|
||||
checkallerrors('getmetatable',{},'bad argument')
|
||||
|
||||
-- ipairs
|
||||
banner('ipairs')
|
||||
checkallpass('ipairs', {sometable})
|
||||
checkallerrors('ipairs', {notatable}, 'bad argument')
|
||||
|
||||
-- load
|
||||
banner('load')
|
||||
checkallpass('load', {somefunction,{nil,astring,n=2}})
|
||||
checkallerrors('load', {notafunction,{nil,astring,anumber,n=3}}, 'bad argument')
|
||||
checkallerrors('load', {somefunction,{afunction,atable}}, 'bad argument')
|
||||
|
||||
-- loadfile
|
||||
banner('loadfile')
|
||||
--checkallpass('loadfile', {})
|
||||
--checkallpass('loadfile', {{'bogus'}})
|
||||
--checkallpass('loadfile', {{'test/lua/errors/args.lua'}})
|
||||
--checkallpass('loadfile', {{'args.lua'}})
|
||||
--checkallerrors('loadfile', {nonstring}, 'bad argument')
|
||||
|
||||
-- load
|
||||
banner('load')
|
||||
checkallpass('load', {{'return'}})
|
||||
checkallpass('load', {{'return'},{'mychunk'}})
|
||||
checkallpass('load', {{'return a ... b'},{'mychunk'}},true)
|
||||
checkallerrors('load', {notastring,{nil,astring,anumber,n=3}}, 'bad argument')
|
||||
checkallerrors('load', {{'return'},{afunction,atable}}, 'bad argument')
|
||||
|
||||
-- next
|
||||
banner('next')
|
||||
checkallpass('next', {sometable,somekey})
|
||||
checkallerrors('next', {notatable,{nil,1,n=2}}, 'bad argument')
|
||||
checkallerrors('next', {sometable,nonkey}, 'invalid key')
|
||||
|
||||
-- pairs
|
||||
banner('pairs')
|
||||
checkallpass('pairs', {sometable})
|
||||
checkallerrors('pairs', {notatable}, 'bad argument')
|
||||
|
||||
-- pcall
|
||||
banner('pcall')
|
||||
checkallpass('pcall', {notanil,anylua}, true)
|
||||
checkallerrors('pcall',{},'bad argument')
|
||||
|
||||
-- print
|
||||
banner('print')
|
||||
checkallpass('print', {})
|
||||
checkallpass('print', {{nil,astring,anumber,aboolean,n=4}})
|
||||
|
||||
-- rawequal
|
||||
banner('rawequal')
|
||||
checkallpass('rawequal', {notanil,notanil})
|
||||
checkallerrors('rawequal', {}, 'bad argument')
|
||||
checkallerrors('rawequal', {notanil}, 'bad argument')
|
||||
|
||||
-- rawget
|
||||
banner('rawget')
|
||||
checkallpass('rawget', {sometable,somekey})
|
||||
checkallpass('rawget', {sometable,nonkey})
|
||||
checkallerrors('rawget', {sometable,somenil},'bad argument')
|
||||
checkallerrors('rawget', {notatable,notakey}, 'bad argument')
|
||||
checkallerrors('rawget', {}, 'bad argument')
|
||||
|
||||
-- rawset
|
||||
banner('rawset')
|
||||
checkallpass('rawset', {sometable,somekey,notanil})
|
||||
checkallpass('rawset', {sometable,nonkey,notanil})
|
||||
checkallerrors('rawset', {sometable,somenil},'table index is nil')
|
||||
checkallerrors('rawset', {}, 'bad argument')
|
||||
checkallerrors('rawset', {notatable,somestring,somestring}, 'bad argument')
|
||||
checkallerrors('rawset', {sometable,somekey}, 'bad argument')
|
||||
|
||||
-- select
|
||||
banner('select')
|
||||
checkallpass('select', {{anumber,'#'},anylua})
|
||||
checkallerrors('select', {notanumber}, 'bad argument')
|
||||
|
||||
-- setmetatable
|
||||
banner('setmetatable')
|
||||
checkallpass('setmetatable', {sometable,sometable})
|
||||
checkallpass('setmetatable', {sometable,{}})
|
||||
checkallerrors('setmetatable',{notatable,sometable},'bad argument')
|
||||
checkallerrors('setmetatable',{sometable,nontable},'bad argument')
|
||||
|
||||
-- tonumber
|
||||
banner('tonumber')
|
||||
checkallpass('tonumber',{somenumber,{nil,2,10,36,n=4}})
|
||||
checkallpass('tonumber',{notanil,{nil,10,n=2}})
|
||||
checkallerrors('tonumber',{{nil,afunction,atable,n=3},{2,9,11,36}},'bad argument')
|
||||
checkallerrors('tonumber',{somenumber,{1,37,atable,afunction,aboolean}},'bad argument')
|
||||
|
||||
-- tostring
|
||||
banner('tostring')
|
||||
checkallpass('tostring',{{astring,anumber,aboolean}})
|
||||
checkallpass('tostring',{{atable,afunction,athread}},true)
|
||||
checkallpass('tostring',{{astring,anumber,aboolean},{'anchor'}})
|
||||
checkallpass('tostring',{{atable,afunction,athread},{'anchor'}},true)
|
||||
checkallerrors('tostring',{},'bad argument')
|
||||
|
||||
-- type
|
||||
banner('type')
|
||||
checkallpass('type',{notanil})
|
||||
checkallpass('type',{anylua,{'anchor'}})
|
||||
checkallerrors('type',{},'bad argument')
|
||||
|
||||
-- xpcall
|
||||
banner('xpcall')
|
||||
checkallpass('xpcall', {notanil,nonfunction})
|
||||
checkallpass('xpcall', {notanil,{function(...)return 'aaa', 'bbb', #{...} end}})
|
||||
checkallerrors('xpcall',{anylua},'bad argument')
|
||||
|
||||
|
||||
@@ -1,47 +0,0 @@
|
||||
package.path = "?.lua;test/lua/errors/?.lua"
|
||||
require 'args'
|
||||
|
||||
-- arg type tests for coroutine library functions
|
||||
|
||||
-- coroutine.create
|
||||
banner('coroutine.create')
|
||||
checkallpass('coroutine.create',{somefunction})
|
||||
checkallerrors('coroutine.create',{notafunction},'bad argument')
|
||||
|
||||
-- coroutine.resume
|
||||
banner('coroutine.resume')
|
||||
local co = coroutine.create(function() while true do coroutine.yield() end end)
|
||||
checkallpass('coroutine.resume',{{co},anylua})
|
||||
checkallerrors('coroutine.resume',{notathread},'bad argument')
|
||||
|
||||
-- coroutine.running
|
||||
banner('coroutine.running')
|
||||
checkallpass('coroutine.running',{anylua})
|
||||
|
||||
-- coroutine.status
|
||||
banner('coroutine.status')
|
||||
checkallpass('coroutine.status',{{co}})
|
||||
checkallerrors('coroutine.status',{notathread},'bad argument')
|
||||
|
||||
-- coroutine.wrap
|
||||
banner('coroutine.wrap')
|
||||
checkallpass('coroutine.wrap',{somefunction})
|
||||
checkallerrors('coroutine.wrap',{notafunction},'bad argument')
|
||||
|
||||
-- coroutine.yield
|
||||
banner('coroutine.yield')
|
||||
local function f()
|
||||
print( 'yield', coroutine.yield() )
|
||||
print( 'yield', coroutine.yield(astring,anumber,aboolean) )
|
||||
error('error within coroutine thread')
|
||||
end
|
||||
local co = coroutine.create( f )
|
||||
print( 'status', coroutine.status(co) )
|
||||
print( coroutine.resume(co,astring,anumber) )
|
||||
print( 'status', coroutine.status(co) )
|
||||
print( coroutine.resume(co,astring,anumber) )
|
||||
print( 'status', coroutine.status(co) )
|
||||
local s,e = coroutine.resume(co,astring,anumber)
|
||||
print( s, string.match(e,'error within coroutine thread') or 'bad message: '..tostring(e) )
|
||||
print( 'status', coroutine.status(co) )
|
||||
|
||||
@@ -1,150 +0,0 @@
|
||||
package.path = "?.lua;test/lua/errors/?.lua"
|
||||
require 'args'
|
||||
|
||||
local alevel = {25,'25'}
|
||||
local afuncorlevel = {afunction,25,'25'}
|
||||
local notafuncorlevel = {nil,astring,aboolean,athread}
|
||||
local notafuncorthread = {nil,astring,aboolean}
|
||||
|
||||
-- debug.debug()
|
||||
banner('debug.debug - no tests')
|
||||
|
||||
-- debug.gethook ([thread])
|
||||
banner('debug.gethook')
|
||||
checkallpass('debug.gethook',{})
|
||||
|
||||
-- debug.getinfo ([thread,] f [, what])
|
||||
banner('debug.getinfo')
|
||||
local awhat = {"","n","flnStu"}
|
||||
local notawhat = {"qzQZ"}
|
||||
checkallpass('debug.getinfo',{afuncorlevel})
|
||||
checkallpass('debug.getinfo',{somethread,afuncorlevel})
|
||||
checkallpass('debug.getinfo',{afuncorlevel,awhat})
|
||||
checkallpass('debug.getinfo',{somethread,afuncorlevel,awhat})
|
||||
checkallerrors('debug.getinfo',{},'function or level')
|
||||
checkallerrors('debug.getinfo',{notafuncorlevel},'function or level')
|
||||
checkallerrors('debug.getinfo',{somefunction,nonstring}, 'string expected')
|
||||
checkallerrors('debug.getinfo',{notafuncorthread,somefunction}, 'string expected')
|
||||
checkallerrors('debug.getinfo',{nonthread,somefunction,{astring}}, 'string expected')
|
||||
checkallerrors('debug.getinfo',{somethread,somefunction,notawhat}, 'invalid option')
|
||||
|
||||
-- debug.getlocal ([thread,] f, local)
|
||||
banner('debug.getlocal')
|
||||
local p,q = 'p','q';
|
||||
f = function(x,y)
|
||||
print('f: x,y,a,b,p,q', x, y, a, b, p, q)
|
||||
local a,b = x,y
|
||||
local t = coroutine.running()
|
||||
checkallpass('debug.getlocal',{{f,1},{1,'2'}})
|
||||
checkallpass('debug.getlocal',{{t},{f},{1}})
|
||||
checkallerrors('debug.getlocal',{},'number expected')
|
||||
checkallerrors('debug.getlocal',{afuncorlevel,notanumber},'number expected')
|
||||
checkallerrors('debug.getlocal',{notafuncorlevel,somenumber}, 'number expected')
|
||||
checkallerrors('debug.getlocal',{{t},afuncorlevel}, 'got no value')
|
||||
checkallerrors('debug.getlocal',{nonthread,{f},{1,'2'}}, 'number expected')
|
||||
checkallerrors('debug.getlocal',{{t},{100},{1}}, 'level out of range')
|
||||
end
|
||||
f(1,2)
|
||||
|
||||
-- debug.getmetatable (value)
|
||||
banner('debug.getmetatable')
|
||||
checkallpass('debug.getmetatable',{anylua})
|
||||
checkallerrors('debug.getmetatable',{},'value expected')
|
||||
|
||||
-- debug.getregistry ()
|
||||
banner('debug.getregistry')
|
||||
checkallpass('debug.getregistry',{})
|
||||
checkallpass('debug.getregistry',{anylua})
|
||||
|
||||
-- debug.getupvalue (f, up)
|
||||
banner('debug.getupvalue')
|
||||
checkallpass('debug.getupvalue',{{f},{1,'2'}})
|
||||
checkallerrors('debug.getupvalue',{},'number expected')
|
||||
checkallerrors('debug.getupvalue',{notafunction,{1,'2'}}, 'function expected')
|
||||
checkallerrors('debug.getupvalue',{{f},notanumber}, 'number expected')
|
||||
|
||||
-- debug.getuservalue (u)
|
||||
checkallpass('debug.getuservalue',{})
|
||||
checkallpass('debug.getuservalue',{anylua})
|
||||
|
||||
-- debug.sethook ([thread,] hook, mask [, count])
|
||||
local ahookstr = {"cr","l"}
|
||||
checkallpass('debug.sethook',{})
|
||||
checkallpass('debug.sethook',{somenil,ahookstr})
|
||||
checkallpass('debug.sethook',{somefunction,ahookstr})
|
||||
checkallpass('debug.sethook',{{nil,athread,n=2},somefunction,ahookstr})
|
||||
checkallerrors('debug.sethook',{{astring,afunction,aboolean}},'string expected')
|
||||
checkallerrors('debug.sethook',{{astring,afunction,aboolean},{nil,afunction,n=2},ahookstr},'string expected')
|
||||
|
||||
-- debug.setlocal ([thread,] level, local, value)
|
||||
banner('debug.setlocal')
|
||||
local p,q = 'p','q';
|
||||
f = function(x,y)
|
||||
print('f: x,y,a,b,p,q', x, y, a, b, p, q)
|
||||
local a,b = x,y
|
||||
local t = coroutine.running()
|
||||
checkallpass('debug.setlocal',{{1},{1},{nil,'foo',n=2}})
|
||||
print('f: x,y,a,b,p,q', x, y, a, b, p, q)
|
||||
checkallpass('debug.setlocal',{{t},{1},{2},{nil,'bar',n=2}})
|
||||
print('f: x,y,a,b,p,q', x, y, a, b, p, q)
|
||||
checkallerrors('debug.setlocal',{},'number expected')
|
||||
checkallerrors('debug.setlocal',{{1}},'value expected')
|
||||
checkallerrors('debug.setlocal',{{1},{1}}, 'value expected')
|
||||
checkallerrors('debug.setlocal',{{t},{1},{2}}, 'value expected')
|
||||
checkallerrors('debug.setlocal',{{atable,astring},{1}}, 'number expected')
|
||||
checkallerrors('debug.setlocal',{{1},nonnumber}, 'value expected')
|
||||
checkallerrors('debug.setlocal',{{atable,astring},{1},{1},{nil,'foo',n=2}}, 'number expected')
|
||||
checkallerrors('debug.setlocal',{{10},{1},{'foo'}}, 'level out of range')
|
||||
return p,q
|
||||
end
|
||||
f(1,2)
|
||||
|
||||
-- debug.setmetatable (value, table)
|
||||
banner('debug.setmetatable')
|
||||
checkallpass('debug.setmetatable',{anylua,{atable,nil,n=2}})
|
||||
checkallerrors('debug.setmetatable',{},'nil or table')
|
||||
checkallerrors('debug.setmetatable',{anylua},'nil or table')
|
||||
|
||||
-- debug.setupvalue (f, up, value)
|
||||
banner('debug.setupvalue')
|
||||
checkallpass('debug.setupvalue',{{f},{2,'3'},{nil,aboolean,astring,n=3}})
|
||||
print('p,q', p, q)
|
||||
checkallerrors('debug.setupvalue',{},'value expected')
|
||||
checkallerrors('debug.setupvalue',{{f}},'value expected')
|
||||
checkallerrors('debug.setupvalue',{{f},{2}},'value expected')
|
||||
checkallerrors('debug.setupvalue',{notafunction,{2}}, 'value expected')
|
||||
checkallerrors('debug.setupvalue',{{f},notanumber}, 'value expected')
|
||||
|
||||
-- debug.setuservalue (udata, value)
|
||||
banner('debug.setuservalue')
|
||||
checkallerrors('debug.setuservalue',{},'userdata expected')
|
||||
checkallerrors('debug.setuservalue',{anylua},'userdata expected')
|
||||
checkallerrors('debug.setuservalue',{anylua,somestring},'userdata expected')
|
||||
|
||||
-- debug.traceback ([thread,] [message [, level]])
|
||||
banner('debug.traceback')
|
||||
local t = coroutine.running()
|
||||
checkallpass('debug.traceback',{})
|
||||
checkallpass('debug.traceback',{{astring}})
|
||||
checkallpass('debug.traceback',{{astring},{anumber}})
|
||||
checkallpass('debug.traceback',{{t}})
|
||||
checkallpass('debug.traceback',{{t},{astring}})
|
||||
checkallpass('debug.traceback',{{t},{astring},{anumber}})
|
||||
checkallpass('debug.traceback',{{afunction,aboolean,atable}})
|
||||
checkallpass('debug.traceback',{{afunction,aboolean,atable},notanumber})
|
||||
|
||||
-- debug.upvalueid (f, n)
|
||||
banner('debug.upvalueid')
|
||||
checkallpass('debug.upvalueid',{{f},{1,'2'}})
|
||||
checkallerrors('debug.upvalueid',{},'number expected')
|
||||
checkallerrors('debug.upvalueid',{notafunction,{1,'2'}}, 'function expected')
|
||||
checkallerrors('debug.upvalueid',{{f},notanumber}, 'number expected')
|
||||
|
||||
-- debug.upvaluejoin (f1, n1, f2, n2)
|
||||
banner('debug.upvaluejoin')
|
||||
checkallpass('debug.upvaluejoin',{{f},{1,'2'},{f},{1,'2'}})
|
||||
checkallerrors('debug.upvaluejoin',{},'number expected')
|
||||
checkallerrors('debug.upvaluejoin',{notafunction,{1,'2'}}, 'function expected')
|
||||
checkallerrors('debug.upvaluejoin',{{f},notanumber}, 'number expected')
|
||||
checkallerrors('debug.upvaluejoin',{{f},{1},notafunction,{1,'2'}}, 'function expected')
|
||||
checkallerrors('debug.upvaluejoin',{{f},{1},{f},notanumber}, 'number expected')
|
||||
@@ -1,85 +0,0 @@
|
||||
package.path = "?.lua;test/lua/errors/?.lua"
|
||||
require 'args'
|
||||
|
||||
-- arg type tests for io library functions
|
||||
local f
|
||||
|
||||
-- io.close ([file])
|
||||
banner('io.close')
|
||||
f = io.open("abc.txt","w")
|
||||
checkallpass('io.close',{{f}})
|
||||
checkallerrors('io.close',{notanil},'bad argument')
|
||||
|
||||
-- io.input ([file])
|
||||
banner('io.input')
|
||||
f = io.open("abc.txt","r")
|
||||
checkallpass('io.input',{{nil,f,"abc.txt",n=3}})
|
||||
checkallerrors('io.input',{nonstring},'bad argument')
|
||||
|
||||
-- io.lines ([filename])
|
||||
banner('io.lines')
|
||||
io.input("abc.txt")
|
||||
checkallpass('io.lines',{{"abc.txt"}})
|
||||
checkallerrors('io.lines',{{f}},'bad argument')
|
||||
checkallerrors('io.lines',{notastring},'bad argument')
|
||||
|
||||
-- io.open (filename [, mode])
|
||||
banner('io.open')
|
||||
checkallpass('io.open',{{"abc.txt"},{nil,"r","w","a","r+","w+","a+"}})
|
||||
checkallerrors('io.open',{notastring},'bad argument')
|
||||
checkallerrors('io.open',{{"abc.txt"},{nonstring}},'bad argument')
|
||||
|
||||
-- io.output ([file])
|
||||
banner('io.output')
|
||||
checkallpass('io.output',{{nil,f,"abc.txt",n=3}})
|
||||
checkallerrors('io.output',{nonstring},'bad argument')
|
||||
|
||||
-- io.popen (prog [, mode])
|
||||
banner('io.popen')
|
||||
--checkallpass('io.popen',{{"hostname"},{nil,"w",n=2}})
|
||||
checkallerrors('io.popen',{notastring},'bad argument')
|
||||
checkallerrors('io.popen',{{"hostname"},{nonstring}},'bad argument')
|
||||
|
||||
-- io.read (<28><><EFBFBD>)
|
||||
banner('io.read')
|
||||
checkallpass('io.read',{})
|
||||
checkallpass('io.read',{{2,"*n","*a","*l"}})
|
||||
checkallpass('io.read',{{2,"*n","*a","*l"},{2,"*a","*l"}})
|
||||
checkallerrors('io.read',{{aboolean,afunction,atable,"3"}},'bad argument')
|
||||
|
||||
-- io.write (<28><><EFBFBD>)
|
||||
banner('io.write')
|
||||
checkallpass('io.write',{})
|
||||
checkallpass('io.write',{somestring})
|
||||
checkallpass('io.write',{somestring,somestring})
|
||||
checkallerrors('io.write',{nonstring},'bad argument')
|
||||
checkallerrors('io.write',{somestring,nonstring},'bad argument')
|
||||
|
||||
-- file:write ()
|
||||
banner('file:write')
|
||||
file = io.open("seektest.txt","w")
|
||||
checkallpass('file.write',{{file},somestring})
|
||||
checkallpass('file.write',{{file},somestring,somestring})
|
||||
checkallerrors('file.write',{},'bad argument')
|
||||
checkallerrors('file.write',{{file},nonstring},'bad argument')
|
||||
checkallerrors('file.write',{{file},somestring,nonstring},'bad argument')
|
||||
pcall( file.close, file )
|
||||
|
||||
-- file:seek ([whence] [, offset])
|
||||
banner('file:seek')
|
||||
file = io.open("seektest.txt","r")
|
||||
checkallpass('file.seek',{{file}})
|
||||
checkallpass('file.seek',{{file},{"set","cur","end"}})
|
||||
checkallpass('file.seek',{{file},{"set","cur","end"},{2,"3"}})
|
||||
checkallerrors('file.seek',{},'bad argument')
|
||||
checkallerrors('file.seek',{{file},nonstring},'bad argument')
|
||||
checkallerrors('file.seek',{{file},{"set","cur","end"},nonnumber},'bad argument')
|
||||
|
||||
-- file:setvbuf (mode [, size])
|
||||
banner('file:setvbuf')
|
||||
checkallpass('file.setvbuf',{{file},{"no","full","line"}})
|
||||
checkallpass('file.setvbuf',{{file},{"full"},{1024,"512"}})
|
||||
checkallerrors('file.setvbuf',{},'bad argument')
|
||||
checkallerrors('file.setvbuf',{{file},notastring},'bad argument')
|
||||
checkallerrors('file.setvbuf',{{file},{"full"},nonnumber},'bad argument')
|
||||
|
||||
@@ -1,112 +0,0 @@
|
||||
package.path = "?.lua;test/lua/errors/?.lua"
|
||||
require 'args'
|
||||
|
||||
local tostring = tostring
|
||||
_G.tostring = function(x)
|
||||
local s = tostring(x)
|
||||
return type(x)=='number' and #s>4 and (s:sub(1,5)..'...') or s
|
||||
end
|
||||
|
||||
-- arg type tests for math library functions
|
||||
local somenumber = {1,0.75,'-1','-0.25'}
|
||||
local somepositive = {1,0.75,'2', '2.5'}
|
||||
local notanumber = {nil,astring,aboolean,afunction,atable,athread}
|
||||
local nonnumber = {astring,aboolean,afunction,atable}
|
||||
|
||||
local singleargfunctions = {
|
||||
'abs', 'acos', 'asin', 'atan', 'cos', 'cosh', 'deg', 'exp', 'floor',
|
||||
'rad', 'randomseed', 'sin', 'sinh', 'tan', 'tanh', 'frexp',
|
||||
}
|
||||
|
||||
local singleargposdomain = {
|
||||
'log', 'sqrt', 'ceil',
|
||||
}
|
||||
|
||||
local twoargfunctions = {
|
||||
'atan2',
|
||||
}
|
||||
|
||||
local twoargsposdomain = {
|
||||
'pow', 'fmod',
|
||||
}
|
||||
|
||||
-- single argument tests
|
||||
for i,v in ipairs(singleargfunctions) do
|
||||
local funcname = 'math.'..v
|
||||
banner(funcname)
|
||||
checkallpass(funcname,{somenumber})
|
||||
checkallerrors(funcname,{notanumber},'bad argument')
|
||||
end
|
||||
|
||||
-- single argument, positive domain tests
|
||||
for i,v in ipairs(singleargposdomain) do
|
||||
local funcname = 'math.'..v
|
||||
banner(funcname)
|
||||
checkallpass(funcname,{somepositive})
|
||||
checkallerrors(funcname,{notanumber},'bad argument')
|
||||
end
|
||||
|
||||
-- two-argument tests
|
||||
for i,v in ipairs(twoargfunctions) do
|
||||
local funcname = 'math.'..v
|
||||
banner(funcname)
|
||||
checkallpass(funcname,{somenumber,somenumber})
|
||||
checkallerrors(funcname,{},'bad argument')
|
||||
checkallerrors(funcname,{notanumber},'bad argument')
|
||||
checkallerrors(funcname,{notanumber,somenumber},'bad argument')
|
||||
checkallerrors(funcname,{somenumber},'bad argument')
|
||||
checkallerrors(funcname,{somenumber,notanumber},'bad argument')
|
||||
end
|
||||
|
||||
-- two-argument, positive domain tests
|
||||
for i,v in ipairs(twoargsposdomain) do
|
||||
local funcname = 'math.'..v
|
||||
banner(funcname)
|
||||
checkallpass(funcname,{somepositive,somenumber})
|
||||
checkallerrors(funcname,{},'bad argument')
|
||||
checkallerrors(funcname,{notanumber},'bad argument')
|
||||
checkallerrors(funcname,{notanumber,somenumber},'bad argument')
|
||||
checkallerrors(funcname,{somenumber},'bad argument')
|
||||
checkallerrors(funcname,{somenumber,notanumber},'bad argument')
|
||||
end
|
||||
|
||||
-- math.max
|
||||
banner('math.max')
|
||||
checkallpass('math.max',{somenumber})
|
||||
checkallpass('math.max',{somenumber,somenumber})
|
||||
checkallerrors('math.max',{},'bad argument')
|
||||
checkallerrors('math.max',{nonnumber},'bad argument')
|
||||
checkallerrors('math.max',{somenumber,nonnumber},'bad argument')
|
||||
|
||||
-- math.min
|
||||
banner('math.min')
|
||||
checkallpass('math.min',{somenumber})
|
||||
checkallpass('math.min',{somenumber,somenumber})
|
||||
checkallerrors('math.min',{},'bad argument')
|
||||
checkallerrors('math.min',{nonnumber},'bad argument')
|
||||
checkallerrors('math.min',{somenumber,nonnumber},'bad argument')
|
||||
|
||||
-- math.random
|
||||
local somem = {3,4.5,'6.7'}
|
||||
local somen = {8,9.10,'12.34'}
|
||||
local notamn = {astring,aboolean,atable,afunction}
|
||||
banner('math.random')
|
||||
checkallpass('math.random',{},true)
|
||||
checkallpass('math.random',{somem},true)
|
||||
checkallpass('math.random',{somem,somen},true)
|
||||
checkallpass('math.random',{{-4,-5.6,'-7','-8.9'},{-1,100,23.45,'-1.23'}},true)
|
||||
checkallerrors('math.random',{{-4,-5.6,'-7','-8.9'}},'interval is empty')
|
||||
checkallerrors('math.random',{somen,somem},'interval is empty')
|
||||
checkallerrors('math.random',{notamn,somen},'bad argument')
|
||||
checkallerrors('math.random',{somem,notamn},'bad argument')
|
||||
|
||||
-- math.ldexp
|
||||
local somee = {-3,0,3,9.10,'12.34'}
|
||||
local notae = {nil,astring,aboolean,atable,afunction}
|
||||
banner('math.ldexp')
|
||||
checkallpass('math.ldexp',{somenumber,somee})
|
||||
checkallerrors('math.ldexp',{},'bad argument')
|
||||
checkallerrors('math.ldexp',{notanumber},'bad argument')
|
||||
checkallerrors('math.ldexp',{notanumber,somee},'bad argument')
|
||||
checkallerrors('math.ldexp',{somenumber},'bad argument')
|
||||
checkallerrors('math.ldexp',{somenumber,notae},'bad argument')
|
||||
@@ -1,21 +0,0 @@
|
||||
package.path = "?.lua;test/lua/errors/?.lua"
|
||||
require 'args'
|
||||
|
||||
-- arg type tests for module library functions
|
||||
|
||||
-- require
|
||||
banner('require')
|
||||
checkallpass('require',{{'math','coroutine','package','string','table'}},true)
|
||||
checkallerrors('require',{{anumber}},'not found')
|
||||
checkallerrors('require',{{anil,aboolean,afunction,atable}},'bad argument')
|
||||
|
||||
-- package.loadlib
|
||||
banner('package.loadlib')
|
||||
checkallpass('package.loadlib',{{'foo'},{'bar'}},true)
|
||||
checkallerrors('package.loadlib',{notastring},'bad argument')
|
||||
|
||||
-- package.seeall
|
||||
banner('package.seeall')
|
||||
checkallpass('package.seeall',{sometable})
|
||||
checkallerrors('package.seeall',{notatable},'bad argument')
|
||||
|
||||
@@ -1,157 +0,0 @@
|
||||
package.path = "?.lua;test/lua/errors/?.lua"
|
||||
require 'args'
|
||||
|
||||
-- arg types for language operator
|
||||
|
||||
-- ========= unary operators: - # not
|
||||
|
||||
-- unary minus -
|
||||
banner('unary -')
|
||||
negative = function(a) return - a end
|
||||
checkallpass('negative',{somenumber})
|
||||
checkallerrors('negative',{notanumber},'attempt to perform arithmetic')
|
||||
|
||||
-- length
|
||||
banner('#')
|
||||
lengthop = function(a) return #a end
|
||||
checkallpass('lengthop',{sometable})
|
||||
checkallerrors('lengthop',{notatable},'attempt to get length of')
|
||||
|
||||
-- length
|
||||
banner('not')
|
||||
notop = function(a) return not a end
|
||||
checkallpass('notop',{somenumber})
|
||||
checkallpass('notop',{notanumber})
|
||||
|
||||
-- function call
|
||||
banner( '()' )
|
||||
funcop = function(a) return a() end
|
||||
checkallpass('funcop',{somefunction})
|
||||
checkallerrors('funcop',{notafunction},'attempt to call')
|
||||
|
||||
-- ========= binary ops: .. + - * / % ^ == ~= <= >= < > [] . and or
|
||||
banner( '..' )
|
||||
concatop = function(a,b) return a..b end
|
||||
checkallpass('concatop',{somestring,somestring})
|
||||
checkallerrors('concatop',{notastring,somestring},'attempt to concatenate')
|
||||
checkallerrors('concatop',{somestring,notastring},'attempt to concatenate')
|
||||
|
||||
banner( '+' )
|
||||
plusop = function(a,b) return a+b end
|
||||
checkallpass('plusop',{somenumber,somenumber})
|
||||
checkallerrors('plusop',{notanumber,somenumber},'attempt to perform arithmetic')
|
||||
checkallerrors('plusop',{somenumber,notanumber},'attempt to perform arithmetic')
|
||||
|
||||
banner( '-' )
|
||||
minusop = function(a,b) return a-b end
|
||||
checkallpass('minusop',{somenumber,somenumber})
|
||||
checkallerrors('minusop',{notanumber,somenumber},'attempt to perform arithmetic')
|
||||
checkallerrors('minusop',{somenumber,notanumber},'attempt to perform arithmetic')
|
||||
|
||||
banner( '*' )
|
||||
timesop = function(a,b) return a*b end
|
||||
checkallpass('timesop',{somenumber,somenumber})
|
||||
checkallerrors('timesop',{notanumber,somenumber},'attempt to perform arithmetic')
|
||||
checkallerrors('timesop',{somenumber,notanumber},'attempt to perform arithmetic')
|
||||
|
||||
banner( '/' )
|
||||
divideop = function(a,b) return a/b end
|
||||
checkallpass('divideop',{somenumber,somenumber})
|
||||
checkallerrors('divideop',{notanumber,somenumber},'attempt to perform arithmetic')
|
||||
checkallerrors('divideop',{somenumber,notanumber},'attempt to perform arithmetic')
|
||||
|
||||
banner( '%' )
|
||||
modop = function(a,b) return a%b end
|
||||
checkallpass('modop',{somenumber,somenumber})
|
||||
checkallerrors('modop',{notanumber,somenumber},'attempt to perform arithmetic')
|
||||
checkallerrors('modop',{somenumber,notanumber},'attempt to perform arithmetic')
|
||||
|
||||
banner( '^' )
|
||||
powerop = function(a,b) return a^b end
|
||||
checkallpass('powerop',{{2,'2.5'},{3,'3.5'}})
|
||||
checkallerrors('powerop',{notanumber,{3,'3.1'}},'attempt to perform arithmetic')
|
||||
checkallerrors('powerop',{{2,'2.1'},notanumber},'attempt to perform arithmetic')
|
||||
|
||||
banner( '==' )
|
||||
equalsop = function(a,b) return a==b end
|
||||
checkallpass('equalsop',{anylua,anylua})
|
||||
|
||||
banner( '~=' )
|
||||
noteqop = function(a,b) return a~=b end
|
||||
checkallpass('noteqop',{anylua,anylua})
|
||||
|
||||
banner( '<=' )
|
||||
leop = function(a,b) return a<=b end
|
||||
checkallpass('leop',{{anumber},{anumber}})
|
||||
checkallpass('leop',{{astring,astrnum},{astring,astrnum}})
|
||||
checkallerrors('leop',{notanumber,{anumber}},'attempt to compare')
|
||||
checkallerrors('leop',{{astrnum},{anumber}},'attempt to compare')
|
||||
checkallerrors('leop',{notastring,{astring,astrnum}},'attempt to compare')
|
||||
checkallerrors('leop',{{anumber},notanumber},'attempt to compare')
|
||||
checkallerrors('leop',{{anumber},{astrnum}},'attempt to compare')
|
||||
checkallerrors('leop',{{astring,astrnum},notastring},'attempt to compare')
|
||||
|
||||
banner( '>=' )
|
||||
geop = function(a,b) return a>=b end
|
||||
checkallpass('geop',{{anumber},{anumber}})
|
||||
checkallpass('geop',{{astring,astrnum},{astring,astrnum}})
|
||||
checkallerrors('geop',{notanumber,{anumber}},'attempt to compare')
|
||||
checkallerrors('geop',{{astrnum},{anumber}},'attempt to compare')
|
||||
checkallerrors('geop',{notastring,{astring,astrnum}},'attempt to compare')
|
||||
checkallerrors('geop',{{anumber},notanumber},'attempt to compare')
|
||||
checkallerrors('geop',{{anumber},{astrnum}},'attempt to compare')
|
||||
checkallerrors('geop',{{astring,astrnum},notastring},'attempt to compare')
|
||||
|
||||
banner( '<' )
|
||||
ltop = function(a,b) return a<b end
|
||||
checkallpass('ltop',{{anumber},{anumber}})
|
||||
checkallpass('ltop',{{astring,astrnum},{astring,astrnum}})
|
||||
checkallerrors('ltop',{notanumber,{anumber}},'attempt to compare')
|
||||
checkallerrors('ltop',{{astrnum},{anumber}},'attempt to compare')
|
||||
checkallerrors('ltop',{notastring,{astring,astrnum}},'attempt to compare')
|
||||
checkallerrors('ltop',{{anumber},notanumber},'attempt to compare')
|
||||
checkallerrors('ltop',{{anumber},{astrnum}},'attempt to compare')
|
||||
checkallerrors('ltop',{{astring,astrnum},notastring},'attempt to compare')
|
||||
|
||||
banner( '>' )
|
||||
gtop = function(a,b) return a>b end
|
||||
checkallpass('gtop',{{anumber},{anumber}})
|
||||
checkallpass('gtop',{{astring,astrnum},{astring,astrnum}})
|
||||
checkallerrors('gtop',{notanumber,{anumber}},'attempt to compare')
|
||||
checkallerrors('gtop',{{astrnum},{anumber}},'attempt to compare')
|
||||
checkallerrors('gtop',{notastring,{astring,astrnum}},'attempt to compare')
|
||||
checkallerrors('gtop',{{anumber},notanumber},'attempt to compare')
|
||||
checkallerrors('gtop',{{anumber},{astrnum}},'attempt to compare')
|
||||
checkallerrors('gtop',{{astring,astrnum},notastring},'attempt to compare')
|
||||
|
||||
banner( '[]' )
|
||||
bracketop = function(a,b) return a[b] end
|
||||
checkallpass('bracketop',{sometable,notanil})
|
||||
checkallerrors('bracketop',{notatable,notanil},'attempt to index')
|
||||
checkallerrors('bracketop',{sometable},'attempt to index')
|
||||
|
||||
banner( '.' )
|
||||
dotop = function(a,b) return a.b end
|
||||
checkallpass('dotop',{sometable,notanil})
|
||||
checkallerrors('dotop',{notatable,notanil},'attempt to index')
|
||||
checkallerrors('dotop',{sometable},'attempt to index')
|
||||
|
||||
banner( 'and' )
|
||||
types = {['table']='table',['function']='function',['thread']='thread'}
|
||||
clean = function(x) return types[type(x)] or x end
|
||||
andop = function(a,b) return clean(a and b) end
|
||||
checkallpass('andop',{anylua,anylua})
|
||||
|
||||
banner( 'or' )
|
||||
orop = function(a,b) return clean(a or b) end
|
||||
checkallpass('orop',{anylua,anylua})
|
||||
|
||||
-- ========= for x in y
|
||||
banner( 'for x=a,b,c' )
|
||||
forop = function(a,b,c) for x=a,b,c do end end
|
||||
checkallpass('forop',{{1,'1.1'},{10,'10.1'},{2,'2.1'}})
|
||||
checkallerrors('forop',{notanumber,{10,'10.1'},{2,'2.1'}},"'for' initial value must be a number")
|
||||
checkallerrors('forop',{{1,'1.1'},notanumber,{2,'2.1'}},"'for' limit must be a number")
|
||||
checkallerrors('forop',{{1,'1.1'},{10,'10.1'},notanumber},"'for' step must be a number")
|
||||
|
||||
|
||||
@@ -1,120 +0,0 @@
|
||||
package.path = "?.lua;test/lua/errors/?.lua"
|
||||
require 'args'
|
||||
|
||||
-- arg type tests for string library functions
|
||||
|
||||
-- string.byte
|
||||
banner('string.byte')
|
||||
checkallpass('string.byte',{somestring})
|
||||
checkallpass('string.byte',{somestring,somenumber})
|
||||
checkallpass('string.byte',{somestring,somenumber,somenumber})
|
||||
checkallerrors('string.byte',{somestring,{astring,afunction,atable}},'bad argument')
|
||||
checkallerrors('string.byte',{notastring,{nil,111,n=2}},'bad argument')
|
||||
|
||||
-- string.char
|
||||
function string_char(...)
|
||||
return string.byte( string.char( ... ) )
|
||||
end
|
||||
banner('string_char')
|
||||
checkallpass('string.char',{{60}})
|
||||
checkallpass('string.char',{{60},{70}})
|
||||
checkallpass('string.char',{{60},{70},{80}})
|
||||
checkallpass('string_char',{{0,9,40,127,128,255,'0','9','255','9.2',9.2}})
|
||||
checkallpass('string_char',{{0,127,255},{0,127,255}})
|
||||
checkallerrors('string_char',{},'bad argument')
|
||||
checkallerrors('string_char',{{nil,-1,256,3}},'bad argument')
|
||||
checkallerrors('string_char',{notanumber,{23,'45',6.7}},'bad argument')
|
||||
checkallerrors('string_char',{{23,'45',6.7},nonnumber},'bad argument')
|
||||
|
||||
-- string.dump
|
||||
banner('string.dump')
|
||||
local someupval = 435
|
||||
local function funcwithupvals() return someupval end
|
||||
checkallpass('string.dump',{{function() return 123 end}})
|
||||
checkallpass('string.dump',{{funcwithupvals}})
|
||||
checkallerrors('string.dump',{notafunction},'bad argument')
|
||||
|
||||
-- string.find
|
||||
banner('string.find')
|
||||
checkallpass('string.find',{somestring,somestring})
|
||||
checkallpass('string.find',{somestring,somestring,{nil,-3,3,n=3}})
|
||||
checkallpass('string.find',{somestring,somestring,somenumber,anylua})
|
||||
checkallerrors('string.find',{notastring,somestring},'bad argument')
|
||||
checkallerrors('string.find',{somestring,notastring},'bad argument')
|
||||
checkallerrors('string.find',{somestring,somestring,nonnumber},'bad argument')
|
||||
|
||||
-- string.format
|
||||
--local numfmts = {'%c','%d','%E','%e','%f','%g','%G','%i','%o','%u','%X','%x'}
|
||||
local numfmts = {'%c','%d','%i','%o','%u','%X','%x'}
|
||||
local strfmts = {'%q','%s'}
|
||||
local badfmts = {'%w'}
|
||||
banner('string.format')
|
||||
checkallpass('string.format',{somestring,anylua})
|
||||
checkallpass('string.format',{numfmts,somenumber})
|
||||
checkallpass('string.format',{strfmts,somestring})
|
||||
checkallerrors('string.format',{numfmts,notanumber},'bad argument')
|
||||
checkallerrors('string.format',{strfmts,notastring},'bad argument')
|
||||
checkallerrors('string.format',{badfmts,somestring},"invalid option '%w'")
|
||||
|
||||
-- string.gmatch
|
||||
banner('string.gmatch')
|
||||
checkallpass('string.gmatch',{somestring,somestring})
|
||||
checkallerrors('string.gmatch',{notastring,somestring},'bad argument')
|
||||
checkallerrors('string.gmatch',{somestring,notastring},'bad argument')
|
||||
|
||||
-- string.gsub
|
||||
local somerepl = {astring,atable,afunction}
|
||||
local notarepl = {nil,aboolean,n=2}
|
||||
banner('string.gsub')
|
||||
checkallpass('string.gsub',{somestring,somestring,somerepl,{nil,-1,n=2}})
|
||||
checkallerrors('string.gsub',{nonstring,somestring,somerepl},'bad argument')
|
||||
checkallerrors('string.gsub',{somestring,nonstring,somerepl},'bad argument')
|
||||
checkallerrors('string.gsub',{{astring},{astring},notarepl},'bad argument')
|
||||
checkallerrors('string.gsub',{{astring},{astring},somerepl,nonnumber},'bad argument')
|
||||
|
||||
-- string.len
|
||||
banner('string.len')
|
||||
checkallpass('string.len',{somestring})
|
||||
checkallerrors('string.len',{notastring},'bad argument')
|
||||
|
||||
-- string.lower
|
||||
banner('string.lower')
|
||||
checkallpass('string.lower',{somestring})
|
||||
checkallerrors('string.lower',{notastring},'bad argument')
|
||||
|
||||
-- string.match
|
||||
banner('string.match')
|
||||
checkallpass('string.match',{somestring,somestring})
|
||||
checkallpass('string.match',{somestring,somestring,{nil,-3,3,n=3}})
|
||||
checkallerrors('string.match',{},'bad argument')
|
||||
checkallerrors('string.match',{nonstring,somestring},'bad argument')
|
||||
checkallerrors('string.match',{somestring},'bad argument')
|
||||
checkallerrors('string.match',{somestring,nonstring},'bad argument')
|
||||
checkallerrors('string.match',{somestring,somestring,notanumber},'bad argument')
|
||||
|
||||
-- string.reverse
|
||||
banner('string.reverse')
|
||||
checkallpass('string.reverse',{somestring})
|
||||
checkallerrors('string.reverse',{notastring},'bad argument')
|
||||
|
||||
-- string.rep
|
||||
banner('string.rep')
|
||||
checkallpass('string.rep',{somestring,somenumber})
|
||||
checkallerrors('string.rep',{notastring,somenumber},'bad argument')
|
||||
checkallerrors('string.rep',{somestring,notanumber},'bad argument')
|
||||
|
||||
-- string.sub
|
||||
banner('string.sub')
|
||||
checkallpass('string.sub',{somestring,somenumber})
|
||||
checkallpass('string.sub',{somestring,somenumber,somenumber})
|
||||
checkallerrors('string.sub',{},'bad argument')
|
||||
checkallerrors('string.sub',{nonstring,somenumber,somenumber},'bad argument')
|
||||
checkallerrors('string.sub',{somestring},'bad argument')
|
||||
checkallerrors('string.sub',{somestring,nonnumber,somenumber},'bad argument')
|
||||
checkallerrors('string.sub',{somestring,somenumber,nonnumber},'bad argument')
|
||||
|
||||
-- string.upper
|
||||
banner('string.upper')
|
||||
checkallpass('string.upper',{somestring})
|
||||
checkallerrors('string.upper',{notastring},'bad argument')
|
||||
|
||||
@@ -1,70 +0,0 @@
|
||||
package.path = "?.lua;test/lua/errors/?.lua"
|
||||
require 'args'
|
||||
|
||||
-- arg type tests for table library functions
|
||||
|
||||
-- table.concat
|
||||
local somestringstable = {{8,7,6,5,4,3,2,1,}}
|
||||
local somenonstringtable = {{true,true,true,true,true,true,true,true,}}
|
||||
local somesep = {',',1.23}
|
||||
local notasep = {aboolean,atable,afunction}
|
||||
local somei = {2,'2','2.2'}
|
||||
local somej = {4,'4','4.4'}
|
||||
local notij = {astring,aboolean,atable,afunction}
|
||||
banner('table.concat')
|
||||
checkallpass('table.concat',{somestringstable})
|
||||
checkallpass('table.concat',{somestringstable,somesep})
|
||||
checkallpass('table.concat',{somestringstable,{'-'},somei})
|
||||
checkallpass('table.concat',{somestringstable,{'-'},{2},somej})
|
||||
checkallerrors('table.concat',{notatable},'bad argument')
|
||||
checkallerrors('table.concat',{somenonstringtable},'boolean')
|
||||
checkallerrors('table.concat',{somestringstable,notasep},'bad argument')
|
||||
checkallerrors('table.concat',{somestringstable,{'-'},notij},'bad argument')
|
||||
checkallerrors('table.concat',{somestringstable,{'-'},{2},notij},'bad argument')
|
||||
|
||||
-- table.insert
|
||||
banner('table.insert')
|
||||
checkallpass('table.insert',{sometable,notanil})
|
||||
checkallpass('table.insert',{sometable,somei,notanil})
|
||||
checkallerrors('table.insert',{notatable,somestring},'bad argument')
|
||||
checkallerrors('table.insert',{sometable,notij,notanil},'bad argument')
|
||||
|
||||
-- table.remove
|
||||
banner('table.remove')
|
||||
checkallpass('table.remove',{sometable})
|
||||
checkallpass('table.remove',{sometable,somei})
|
||||
checkallerrors('table.remove',{notatable},'bad argument')
|
||||
checkallerrors('table.remove',{notatable,somei},'bad argument')
|
||||
checkallerrors('table.remove',{sometable,notij},'bad argument')
|
||||
|
||||
-- table.sort
|
||||
local somecomp = {nil,afunction,n=2}
|
||||
local notacomp = {astring,anumber,aboolean,atable}
|
||||
banner('table.sort')
|
||||
checkallpass('table.sort',{somestringstable,somecomp})
|
||||
checkallerrors('table.sort',{sometable},'attempt to')
|
||||
checkallerrors('table.sort',{notatable,somecomp},'bad argument')
|
||||
checkallerrors('table.sort',{sometable,notacomp},'bad argument')
|
||||
|
||||
-- table get
|
||||
banner('table_get - tbl[key]')
|
||||
function table_get(tbl,key) return tbl[key] end
|
||||
checkallpass('table_get',{sometable,anylua})
|
||||
|
||||
-- table set
|
||||
banner('table_set - tbl[key]=val')
|
||||
function table_set(tbl,key,val) tbl[key]=val end
|
||||
function table_set_nil_key(tbl,val) tbl[nil]=val end
|
||||
checkallpass('table_set',{sometable,notanil,anylua})
|
||||
checkallerrors('table_set_nil_key',{sometable,anylua},'table index')
|
||||
|
||||
-- table.unpack
|
||||
banner('table.unpack')
|
||||
checkallpass('table.unpack',{sometable})
|
||||
checkallpass('table.unpack',{sometable,{3,'5'}})
|
||||
checkallpass('table.unpack',{sometable,{3,'5'},{1.25,'7'}})
|
||||
checkallerrors('table.unpack',{notatable,somenumber,somenumber},'bad argument')
|
||||
checkallerrors('table.unpack',{sometable,nonnumber,somenumber},'bad argument')
|
||||
checkallerrors('table.unpack',{sometable,somenumber,nonnumber},'bad argument')
|
||||
|
||||
|
||||
@@ -1,74 +0,0 @@
|
||||
|
||||
function f0() print( "f0:" ) end
|
||||
function f1(a) print( "f1:", a ) end
|
||||
function f2(a,b) print( "f2:", a, b ) end
|
||||
function f3(a,b,c) print( "f3:", a, b, c ) end
|
||||
function f4(a,b,c,d) print( "f4:", a, b, c, d ) end
|
||||
|
||||
f0() f0( "a1/1" ) f0( "a1/2", "a2/2" ) f0( "a1/3", "a2/3", "a3/3" ) f0( "a1/4", "a2/4", "a3/4", "a4/4" )
|
||||
f1() f1( "a1/1" ) f1( "a1/2", "a2/2" ) f1( "a1/3", "a2/3", "a3/3" ) f1( "a1/4", "a2/4", "a3/4", "a4/4" )
|
||||
f2() f2( "a1/1" ) f2( "a1/2", "a2/2" ) f2( "a1/3", "a2/3", "a3/3" ) f2( "a1/4", "a2/4", "a3/4", "a4/4" )
|
||||
f3() f3( "a1/1" ) f3( "a1/2", "a2/2" ) f3( "a1/3", "a2/3", "a3/3" ) f3( "a1/4", "a2/4", "a3/4", "a4/4" )
|
||||
f4() f4( "a1/1" ) f4( "a1/2", "a2/2" ) f4( "a1/3", "a2/3", "a3/3" ) f4( "a1/4", "a2/4", "a3/4", "a4/4" )
|
||||
|
||||
function g0(a,b,c,d) return end
|
||||
function g1(a,b,c,d) return d end
|
||||
function g2(a,b,c,d) return c, d end
|
||||
function g3(a,b,c,d) return b, c, d end
|
||||
function g4(a,b,c,d) return a, b, c, d end
|
||||
|
||||
z = g0("c0.1/4", "c0.2/4", "c0.3/4", "c0.4/4")
|
||||
print( "z0:", z )
|
||||
z = g2("c2.1/4", "c2.2/4", "c2.3/4", "c2.4/4")
|
||||
print( "z2:", z )
|
||||
z = g4("c4.1/4", "c4.2/4", "c4.3/4", "c4.4/4")
|
||||
print( "z4:", z )
|
||||
|
||||
a,b,c,d = g0( "c0.1/4", "c0.2/4", "c0.3/4", "c0.4/4" )
|
||||
print( "g0:", a, b, c, d, "(eol)" )
|
||||
a,b,c,d = g2( "b2.1/4", "b2.2/4", "b2.3/4", "b2.4/4" )
|
||||
print( "g2:", a, b, c, d, "(eol)" )
|
||||
a,b,c,d = g4( "b4.1/4", "b4.2/4", "b4.3/4", "b4.4/4" )
|
||||
print( "g4:", a, b, c, d, "(eol)" )
|
||||
|
||||
function func(a,b,c)
|
||||
return a, b, c
|
||||
end
|
||||
|
||||
print( func(11, 12, 13) )
|
||||
print( func(23, 22, 21) )
|
||||
print( func(func(32,33,34), func(45,46,47), func(58,59,50)) )
|
||||
|
||||
function p(a,...)
|
||||
print("a",a)
|
||||
print("...",...)
|
||||
print("...,a",...,a)
|
||||
print("a,...",a,...)
|
||||
end
|
||||
p()
|
||||
p("q")
|
||||
p("q","r")
|
||||
p("q","r","s")
|
||||
|
||||
-- tail call tests
|
||||
function first(...)
|
||||
return 'abc', ..., '|', ...
|
||||
end
|
||||
|
||||
function second(a,...)
|
||||
return 'def', ..., '|', a, ...
|
||||
end
|
||||
|
||||
function third( a, b, c )
|
||||
print( 'third', first( a, b, c ) )
|
||||
print( 'third', second( a, b, c ) )
|
||||
return second( a, b, c )
|
||||
end
|
||||
|
||||
print( 'third', third() )
|
||||
print( 'third', third('p') )
|
||||
print( 'third', third('p','q') )
|
||||
print( 'third', third('p','q','r') )
|
||||
print( 'third', third('p','q','r','s') )
|
||||
print( 'third', third() )
|
||||
|
||||
@@ -1,153 +0,0 @@
|
||||
local platform = ...
|
||||
--print( 'platform', platform )
|
||||
|
||||
-- simple io-library tests
|
||||
--
|
||||
-- C version on Windows will add change \n into \r\n for text files at least
|
||||
--
|
||||
local tostr,files,nfiles = tostring,{},0
|
||||
tostring = function(x)
|
||||
local s = tostr(x)
|
||||
if s:sub(1,4) ~= 'file' then return s end
|
||||
if files[s] then return files[s] end
|
||||
files[s] = 'file.'..nfiles
|
||||
nfiles = nfiles + 1
|
||||
return files[s]
|
||||
end
|
||||
print( io ~= nil )
|
||||
print( io.open ~= nil )
|
||||
print( io.stdin ~= nil )
|
||||
print( io.stdout ~= nil )
|
||||
print( io.stderr ~= nil )
|
||||
print( 'write', io.write() )
|
||||
print( 'write', io.write("This") )
|
||||
print( 'write', io.write(" is a pen.") )
|
||||
print( 'flush', io.flush() )
|
||||
|
||||
local f = io.open("abc.txt","w")
|
||||
print( 'f', type(f) )
|
||||
print( io.type(f) )
|
||||
print( 'write', f:write("abcdef 12345 \t\t 678910 more\aaaaaaa\bbbbthe rest") )
|
||||
print( 'type(f)', io.type(f) )
|
||||
print( 'close', f:close() )
|
||||
print( 'type(f)', io.type(f) )
|
||||
print( 'type("f")', io.type("f") )
|
||||
|
||||
local g = io.open("abc.txt","r")
|
||||
local t = { g:read(3, 3, "*n", "*n", "*l", "*l", "*a") }
|
||||
for i,v in ipairs(t) do
|
||||
print( string.format("%q",tostring(v)), type(v))
|
||||
print( '----- ', i )
|
||||
end
|
||||
|
||||
local h,s = io.open("abc.txt", "a")
|
||||
print( 'h', io.type(h), string.sub(tostring(h),1,6), s )
|
||||
print( 'write', h:write('and more and more and more text.') )
|
||||
print( 'close', h:close() )
|
||||
|
||||
if platform ~= 'JME' then
|
||||
local j = io.open( "abc.txt", "r" )
|
||||
print( 'j', io.type(j) )
|
||||
print( 'seek', j:seek("set", 3) )
|
||||
print( 'read', j:read(4), j:read(3) )
|
||||
print( 'seek', j:seek("set", 2) )
|
||||
print( 'read', j:read(4), j:read(3) )
|
||||
print( 'seek', j:seek("cur", -8 ) )
|
||||
print( 'read', j:read(4), j:read(3) )
|
||||
print( 'seek(cur,0)', j:seek("cur",0) )
|
||||
print( 'seek(cur,20)', j:seek("cur",20) )
|
||||
print( 'seek(end,-5)', j:seek("end", -5) )
|
||||
print( 'read(4)', string.format("%q", tostring(j:read(4))) )
|
||||
print( 'read(4)', string.format("%q", tostring(j:read(4))) )
|
||||
print( 'read(4)', string.format("%q", tostring(j:read(4))) )
|
||||
print( 'close', j:close() )
|
||||
end
|
||||
|
||||
-- write a few lines, including a non-terminating one
|
||||
files = {}
|
||||
f = io.open("abc.txt","w")
|
||||
print( 'f.type', io.type(f) )
|
||||
print( 'f', f )
|
||||
print( 'write', f:write("line one\nline two\n\nafter blank line\nunterminated line") )
|
||||
print( 'type(f)', io.type(f) )
|
||||
print( 'close', f:close() )
|
||||
files = {}
|
||||
|
||||
-- read using io.lines()
|
||||
for l in io.lines("abc.txt") do
|
||||
print( string.format('%q',l) )
|
||||
end
|
||||
io.input("abc.txt")
|
||||
for l in io.lines() do
|
||||
print( string.format('%q',l) )
|
||||
end
|
||||
io.input(io.open("abc.txt","r"))
|
||||
for l in io.lines() do
|
||||
print( string.format('%q',l) )
|
||||
end
|
||||
io.input("abc.txt")
|
||||
io.input(io.input())
|
||||
for l in io.lines() do
|
||||
print( string.format('%q',l) )
|
||||
end
|
||||
|
||||
local count = 0
|
||||
io.tmpfile = function()
|
||||
count = count + 1
|
||||
return io.open("tmp"..count..".out","w")
|
||||
end
|
||||
|
||||
local a = io.tmpfile()
|
||||
local b = io.tmpfile()
|
||||
print( io.type(a) )
|
||||
print( io.type(b) )
|
||||
print( "a:write", a:write('aaaaaaa') )
|
||||
print( "b:write", b:write('bbbbbbb') )
|
||||
print( "a:setvbuf", a:setvbuf("no") )
|
||||
print( "a:setvbuf", a:setvbuf("full",1024) )
|
||||
print( "a:setvbuf", a:setvbuf("line") )
|
||||
print( "a:write", a:write('ccccc') )
|
||||
print( "b:write", b:write('ddddd') )
|
||||
print( "a:flush", a:flush() )
|
||||
print( "b:flush", b:flush() )
|
||||
--[[
|
||||
print( "a:read", a:read(7) )
|
||||
print( "b:read", b:read(7) )
|
||||
print( "a:seek", a:seek("cur",-4) )
|
||||
print( "b:seek", b:seek("cur",-4) )
|
||||
print( "a:read", ( a:read(7) ) )
|
||||
print( "b:read", ( b:read(7) ) )
|
||||
print( "a:seek", a:seek("cur",-8) )
|
||||
print( "b:seek", b:seek("cur",-8) )
|
||||
print( "a:read", ( a:read(7) ) )
|
||||
print( "b:read", ( b:read(7) ) )
|
||||
--]]
|
||||
|
||||
local pcall = function(...)
|
||||
local s,e = pcall(...)
|
||||
if s then return s end
|
||||
return s,e:match("closed")
|
||||
end
|
||||
|
||||
print( 'a:close', pcall( a.close, a ) )
|
||||
print( 'a:write', pcall( a.write, a, 'eee') )
|
||||
print( 'a:flush', pcall( a.flush, a) )
|
||||
print( 'a:read', pcall( a.read, a, 5) )
|
||||
print( 'a:lines', pcall( a.lines, a) )
|
||||
print( 'a:seek', pcall( a.seek, a, "cur", -2) )
|
||||
print( 'a:setvbuf', pcall( a.setvbuf, a, "no") )
|
||||
print( 'a:close', pcall( a.close, a ) )
|
||||
print( 'io.type(a)', pcall( io.type, a ) )
|
||||
|
||||
print( 'io.close()', pcall( io.close ) )
|
||||
print( 'io.close(io.output())', pcall( io.close, io.output() ) )
|
||||
|
||||
io.output('abc.txt')
|
||||
print( 'io.close()', pcall( io.close ) )
|
||||
print( 'io.write', pcall( io.write, 'eee') )
|
||||
print( 'io.flush', pcall( io.flush) )
|
||||
print( 'io.close', pcall( io.close ) )
|
||||
io.input('abc.txt'):close()
|
||||
print( 'io.read', pcall( io.read, 5) )
|
||||
print( 'io.lines', pcall( io.lines) )
|
||||
|
||||
Binary file not shown.
@@ -1,37 +0,0 @@
|
||||
local t = {}
|
||||
local template = [[
|
||||
local f<i>
|
||||
do
|
||||
local result
|
||||
function f<i>()
|
||||
if not result then
|
||||
result = f<i-2>() + f<i-1>()
|
||||
end
|
||||
return result
|
||||
end
|
||||
end
|
||||
]]
|
||||
t[1] = [[
|
||||
local f1
|
||||
f1 = function() return 1 end
|
||||
]]
|
||||
t[2] = [[
|
||||
local f2
|
||||
f2 = function() return 1 end
|
||||
]]
|
||||
for i = 3, 199 do
|
||||
t[i] = template:gsub("<([^>]+)>", function(s)
|
||||
local c = assert(load('return '..s, 'f'..i, 'bt', { i = i }), 'could not compile: '..s)
|
||||
return c()
|
||||
end)
|
||||
end
|
||||
t[200] = [[
|
||||
print("5th fibonacci number is", f5())
|
||||
print("10th fibonacci number is", f10())
|
||||
print("199th fibonacci number is", f199())
|
||||
]]
|
||||
|
||||
local s = table.concat(t)
|
||||
print(s)
|
||||
f = load(s)
|
||||
f()
|
||||
@@ -1,239 +0,0 @@
|
||||
local platform = ...
|
||||
--print( 'platform', platform )
|
||||
|
||||
local aliases = {
|
||||
['0']='<zero>',
|
||||
['-0']='<zero>',
|
||||
['nan']='<nan>',
|
||||
['inf']='<pos-inf>',
|
||||
['-inf']='<neg-inf>',
|
||||
['1.#INF']='<pos-inf>',
|
||||
['-1.#INF']='<neg-inf>',
|
||||
['1.#IND']='<nan>',
|
||||
['-1.#IND']='<nan>',
|
||||
}
|
||||
|
||||
local UNOPVALUES = { -2.5, -2, 0, 2, 2.5, "'-2.5'", "'-2'", "'0'", "'2'", "'2.5'" }
|
||||
|
||||
local NUMBERPAIRS = {
|
||||
{ 2, 0 }, { -2.5, 0 }, { 2, 1 },
|
||||
{ 5, 2 }, {-5, 2 }, {16, 2}, {-16, -2},
|
||||
{ .5, 0}, {.5, 1}, {.5, 2}, {.5, -1}, {.5, 2},
|
||||
{2.25, 0}, {2.25, 2}, {-2, 0},
|
||||
{ 3, 3 },
|
||||
}
|
||||
|
||||
local STRINGPAIRS = {
|
||||
{ "'2'", "'0'" }, { "'2.5'","'3'" }, { "'-2'", "'1.5'" }, { "'-2.5'", "'-1.5'" },
|
||||
{ "'3.0'", "'3.0'" }, { 2.75, 2.75 }, { "'2.75'", "'2.75'" },
|
||||
}
|
||||
|
||||
local MIXEDPAIRS = {
|
||||
{ 3, "'3'" }, { "'3'", 3 }, { 2.75, "'2.75'" }, { "'2.75'", 2.75 },
|
||||
{ -3, "'-4'" }, { "'-3'", 4 }, { -3, "'4'" }, { "'-3'", -4 },
|
||||
{ -4.75, "'2.75'" }, { "'-2.75'", 1.75 }, { 4.75, "'-2.75'" }, { "'2.75'", -1.75 },
|
||||
}
|
||||
|
||||
local BINOPVALUES = {}
|
||||
|
||||
local RELATIONALOPVALUES = {}
|
||||
|
||||
local function addall( t, s )
|
||||
for i,v in ipairs(s) do
|
||||
t[#t+1] = v
|
||||
end
|
||||
end
|
||||
addall( BINOPVALUES, NUMBERPAIRS )
|
||||
addall( BINOPVALUES, STRINGPAIRS )
|
||||
addall( BINOPVALUES, MIXEDPAIRS )
|
||||
addall( RELATIONALOPVALUES, NUMBERPAIRS )
|
||||
addall( RELATIONALOPVALUES, STRINGPAIRS )
|
||||
|
||||
local VARARGSVALUES = {
|
||||
{ 4, }, { -4.5 }, { "'5.5'" }, { "'-5'" },
|
||||
{ 4, "'8'" }, { -4.5, "'-8'" }, { "'5.5'", 2.2 }, { "'-5'", -2.2 },
|
||||
{ 111,222,333 }, { -222,-333,-111 }, { 444,-111,-222 },
|
||||
}
|
||||
|
||||
local CONSTANTS = {
|
||||
"huge", "pi",
|
||||
}
|
||||
local UNARYOPS = {
|
||||
"-", "not ",
|
||||
}
|
||||
local BINARYOPS = {
|
||||
"+", "-", "*", "^", "/", "%",
|
||||
}
|
||||
local RELATIONALS = {
|
||||
"==", "~=", ">", "<", ">=", "<=",
|
||||
}
|
||||
local ONEARG_JME = {
|
||||
"abs", "ceil", "cos", "deg",
|
||||
"exp", "floor", "frexp", "modf",
|
||||
"rad", "sin", "sqrt", "tan",
|
||||
}
|
||||
local ONEARG_JSE = {
|
||||
"acos", "asin", "atan", "cosh",
|
||||
"log", "sinh", "tanh",
|
||||
}
|
||||
local TWOARGS_JME = {
|
||||
"fmod", "ldexp", "pow",
|
||||
}
|
||||
local TWOARGS_JSE = {
|
||||
"atan2",
|
||||
}
|
||||
local VARARGSFUNCS = {
|
||||
"max", "min",
|
||||
}
|
||||
|
||||
local ts = tostring
|
||||
tostring = function(x)
|
||||
local s = ts(x)
|
||||
if type(x)~='number' then return s end
|
||||
if aliases[s] then return aliases[s] end
|
||||
if #s < 7 then return s end
|
||||
local a,b = string.match(s,'([%-0-9%.]*)([eE]?[%-0-9]*)')
|
||||
return a and (string.sub(a,1,6)..(b or '')) or s
|
||||
end
|
||||
|
||||
local function eval( expr, script )
|
||||
script = script or ('return '..expr)
|
||||
local s,a,b = load( script, 'expr' )
|
||||
if s then print( expr, pcall( s ) )
|
||||
else print( expr, 'load:', a ) end
|
||||
end
|
||||
|
||||
-- misc tests
|
||||
print( '---------- miscellaneous tests ----------' )
|
||||
eval( 'math.sin( 0.0 )' )
|
||||
eval( 'math.cos( math.pi )' )
|
||||
eval( 'math.sqrt( 9.0 )' )
|
||||
eval( 'math.modf( 5.25 )')
|
||||
eval( 'math.frexp(0.00625)' )
|
||||
eval( '-5 ^ 2' )
|
||||
eval( '-5 / 2' )
|
||||
eval( '-5 % 2' )
|
||||
|
||||
-- constants
|
||||
print( '---------- constants ----------' )
|
||||
for i,v in ipairs(CONSTANTS) do
|
||||
eval( 'math.'..v )
|
||||
end
|
||||
|
||||
-- unary operators
|
||||
for i,v in ipairs(UNARYOPS) do
|
||||
print( '---------- unary operator '..v..' ----------' )
|
||||
for j,a in ipairs(UNOPVALUES) do
|
||||
eval( v..a, 'return '..v..a )
|
||||
end
|
||||
end
|
||||
|
||||
-- binary operators
|
||||
for i,v in ipairs(BINARYOPS) do
|
||||
print( '---------- binary operator '..v..' ----------' )
|
||||
for j,xy in ipairs(BINOPVALUES) do
|
||||
eval( xy[1]..v..xy[2],
|
||||
'local x,y='..xy[1]..','..xy[2]..'; return x'..v..'y' )
|
||||
end
|
||||
end
|
||||
|
||||
-- relational operators
|
||||
for i,v in ipairs(RELATIONALS) do
|
||||
print( '---------- binary operator '..v..' ----------' )
|
||||
for j,xy in ipairs(RELATIONALOPVALUES) do
|
||||
eval( xy[1]..v..xy[2],
|
||||
'local x,y='..xy[1]..','..xy[2]..'; return x'..v..'y' )
|
||||
end
|
||||
end
|
||||
|
||||
-- one-argument math functions
|
||||
for i,v in ipairs(ONEARG_JME) do
|
||||
print( '---------- math.'..v..' ----------' )
|
||||
for j,x in ipairs(UNOPVALUES) do
|
||||
eval( 'math.'..v..'('..x..')' )
|
||||
end
|
||||
end
|
||||
if platform ~= 'JME' then
|
||||
for i,v in ipairs(ONEARG_JSE) do
|
||||
print( '---------- math.'..v..' (jse only) ----------' )
|
||||
for j,x in ipairs(UNOPVALUES) do
|
||||
eval( 'math.'..v..'('..x..')' )
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- two-argument math functions
|
||||
for i,v in ipairs(TWOARGS_JME) do
|
||||
print( '---------- math.'..v..' ----------' )
|
||||
for j,x in ipairs(BINOPVALUES) do
|
||||
eval( 'math.'..v..'('..x[1]..','..x[2]..')' )
|
||||
end
|
||||
end
|
||||
if platform ~= 'JME' then
|
||||
for i,v in ipairs(TWOARGS_JSE) do
|
||||
print( '---------- math.'..v..' (jse only) ----------' )
|
||||
for j,x in ipairs(BINOPVALUES) do
|
||||
eval( 'math.'..v..'('..x[1]..','..x[2]..')' )
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- var-arg math functions
|
||||
for i,v in ipairs(VARARGSFUNCS) do
|
||||
print( '---------- math.'..v..' ----------' )
|
||||
for j,x in ipairs(VARARGSVALUES) do
|
||||
eval( 'math.'..v..'('..table.concat(x,',')..')' )
|
||||
end
|
||||
end
|
||||
|
||||
-- random tests
|
||||
print("----------- Random number tests")
|
||||
local function testrandom(string,lo,hi)
|
||||
local c,e = load('return '..string)
|
||||
for i=1,5 do
|
||||
local s,e = pcall(c)
|
||||
if s then
|
||||
print( string, s and type(e) or e, (e>=lo) and (e<=hi) )
|
||||
else
|
||||
print( string, 'error', e )
|
||||
end
|
||||
end
|
||||
end
|
||||
testrandom('math.random()',0,1)
|
||||
testrandom('math.random(5,10)',5,10)
|
||||
testrandom('math.random(30)',0,30)
|
||||
testrandom('math.random(-4,-2)',-4,-2)
|
||||
local t = {}
|
||||
print( math.randomseed(20) )
|
||||
for i=1,20 do
|
||||
t[i] = math.random()
|
||||
end
|
||||
print( '-- comparing new numbers')
|
||||
for i=1,20 do
|
||||
print( t[i] == math.random(), t[i] == t[0] )
|
||||
end
|
||||
print( '-- resetting seed')
|
||||
|
||||
print( math.randomseed(20) )
|
||||
for i=1,20 do
|
||||
print( t[i] == math.random() )
|
||||
end
|
||||
|
||||
-- tests involving -0, which is folded into 0 for luaj, but not for plain lua
|
||||
print("----------- Tests involving -0 and NaN")
|
||||
print('0 == -0', 0 == -0)
|
||||
t = {[0] = 10, 20, 30, 40, 50}
|
||||
print('t[-0] == t[0]',t[-0] == t[0])
|
||||
local x = -1
|
||||
local mz, z = 0/x, 0 -- minus zero, zero
|
||||
print('mz, z', mz, z)
|
||||
print('mz == z', mz == z)
|
||||
local a = {[mz] = 1}
|
||||
print('a[z] == 1 and a[mz] == 1', a[z] == 1 and a[mz] == 1)
|
||||
-- string with same binary representation as 0.0 (may create problems
|
||||
-- for constant manipulation in the pre-compiler)
|
||||
local a1, a2, a3, a4, a5 = 0, 0, "\0\0\0\0\0\0\0\0", 0, "\0\0\0\0\0\0\0\0"
|
||||
assert(a1 == a2 and a2 == a4 and a1 ~= a3)
|
||||
assert(a3 == a5)
|
||||
|
||||
--]]
|
||||
@@ -1,286 +0,0 @@
|
||||
local anumber,bnumber = 111,23.45
|
||||
local astring,bstring = "abc","def"
|
||||
local anumstr,bnumstr = tostring(anumber),tostring(bnumber)
|
||||
local aboolean,bboolean = false,true
|
||||
local afunction,bfunction = function() end, function() end
|
||||
local athread,bthead = coroutine.create(afunction),coroutine.create(bfunction)
|
||||
local atable,btable = {},{}
|
||||
local values = { anumber, aboolean, afunction, athread, atable }
|
||||
local groups
|
||||
local ts = tostring
|
||||
local tb,count = {},0
|
||||
|
||||
tostring = function(o)
|
||||
local t = type(o)
|
||||
if t~='thread' and t~='function' and t~='table' then return ts(o) end
|
||||
if not tb[o] then
|
||||
count = count + 1
|
||||
tb[o] = t..'.'..count
|
||||
end
|
||||
return tb[o]
|
||||
end
|
||||
|
||||
local buildop = function(name)
|
||||
return function(a,b)
|
||||
print( 'mt.__'..name..'()', a, b )
|
||||
return '__'..name..'-result'
|
||||
end
|
||||
end
|
||||
local buildop3 = function(name)
|
||||
return function(a,b,c)
|
||||
print( 'mt.__'..name..'()', a, b, c )
|
||||
return '__'..name..'-result'
|
||||
end
|
||||
end
|
||||
local buildop1 = function(name)
|
||||
return function(a)
|
||||
print( 'mt.__'..name..'()', a )
|
||||
return '__'..name..'-result'
|
||||
end
|
||||
end
|
||||
|
||||
local mt = {
|
||||
__call=buildop('call'),
|
||||
__add=buildop('add'),
|
||||
__sub=buildop('sub'),
|
||||
__mul=buildop('mul'),
|
||||
__div=buildop('div'),
|
||||
__pow=buildop('pow'),
|
||||
__mod=buildop('mod'),
|
||||
__unm=buildop1('unm'),
|
||||
__len=buildop1('len'),
|
||||
__lt=buildop('lt'),
|
||||
__le=buildop('le'),
|
||||
__index=buildop('index'),
|
||||
__newindex=buildop3('newindex'),
|
||||
__concat=buildop('concat'),
|
||||
}
|
||||
|
||||
-- pcall a function and check for a pattern in the error string
|
||||
ecall = function(pattern, ...)
|
||||
local s,e = pcall(...)
|
||||
if not s then e = string.match(e,pattern) or e end
|
||||
return s,e
|
||||
end
|
||||
|
||||
print( '---- __eq same types' )
|
||||
local eqmt = { __eq=buildop('eq'), }
|
||||
groups = { {nil,nil}, {true,false}, {123,456}, {11,5.5}, {afunction,bfunction}, {athread,bthread}, {astring,bstring}, {anumber,anumstr} }
|
||||
for i=1,#groups do
|
||||
local a,b = groups[i][1], groups[i][2]
|
||||
local amt,bmt = debug.getmetatable(a),debug.getmetatable(b)
|
||||
print( type(a), type(b), 'before', pcall( function() return a==b end ) )
|
||||
print( type(a), type(b), 'before', pcall( function() return a~=b end ) )
|
||||
print( debug.setmetatable( a, eqmt ) )
|
||||
print( debug.setmetatable( b, eqmt ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a==b end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a~=b end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
print( debug.setmetatable( b, bmt ) )
|
||||
end
|
||||
|
||||
print( '---- __eq, tables - should invoke metatag comparison' )
|
||||
groups = { {atable,btable} }
|
||||
for i=1,#groups do
|
||||
local a,b = groups[i][1], groups[i][2]
|
||||
local amt,bmt = debug.getmetatable(a),debug.getmetatable(b)
|
||||
print( type(a), type(b), 'before', pcall( function() return a==b end ) )
|
||||
print( type(a), type(b), 'before', pcall( function() return a~=b end ) )
|
||||
print( debug.setmetatable( a, eqmt ) )
|
||||
print( debug.setmetatable( b, eqmt ) )
|
||||
print( type(a), type(b), 'after-a', pcall( function() return a==b end ) )
|
||||
print( type(a), type(b), 'after-a', pcall( function() return a~=b end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
print( debug.setmetatable( b, bmt ) )
|
||||
end
|
||||
|
||||
|
||||
print( 'nilmt', debug.getmetatable(nil) )
|
||||
print( 'boolmt', debug.getmetatable(true) )
|
||||
print( 'number', debug.getmetatable(1) )
|
||||
print( 'function', debug.getmetatable(afunction) )
|
||||
print( 'thread', debug.getmetatable(athread) )
|
||||
|
||||
print( '---- __call' )
|
||||
for i=1,#values do
|
||||
local a = values[i]
|
||||
local amt = debug.getmetatable(a)
|
||||
print( type(a), 'before', ecall( 'attempt to call', function() return a('a','b') end ) )
|
||||
print( debug.setmetatable( a, mt ) )
|
||||
print( type(a), 'after', pcall( function() return a() end ) )
|
||||
print( type(a), 'after', pcall( function() return a('a') end ) )
|
||||
print( type(a), 'after', pcall( function() return a('a','b') end ) )
|
||||
print( type(a), 'after', pcall( function() return a('a','b','c') end ) )
|
||||
print( type(a), 'after', pcall( function() return a('a','b','c','d') end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
end
|
||||
|
||||
print( '---- __add, __sub, __mul, __div, __pow, __mod' )
|
||||
local groups = { {aboolean, aboolean}, {aboolean, athread}, {aboolean, afunction}, {aboolean, "abc"}, {aboolean, atable} }
|
||||
for i=1,#groups do
|
||||
local a,b = groups[i][1], groups[i][2]
|
||||
local amt,bmt = debug.getmetatable(a),debug.getmetatable(b)
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to perform arithmetic', function() return a+b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to perform arithmetic', function() return b+a end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to perform arithmetic', function() return a-b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to perform arithmetic', function() return b-a end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to perform arithmetic', function() return a*b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to perform arithmetic', function() return b*a end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to perform arithmetic', function() return a^b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to perform arithmetic', function() return b^a end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to perform arithmetic', function() return a%b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to perform arithmetic', function() return b%a end ) )
|
||||
print( debug.setmetatable( a, mt ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a+b end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return b+a end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a-b end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return b-a end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a*b end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return b*a end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a^b end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return b^a end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a%b end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return b%a end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
print( debug.setmetatable( b, bmt ) )
|
||||
end
|
||||
|
||||
print( '---- __len' )
|
||||
values = { aboolean, afunction, athread, anumber }
|
||||
for i=1,#values do
|
||||
local a = values[i]
|
||||
local amt = debug.getmetatable(a)
|
||||
print( type(a), 'before', ecall( 'attempt to get length of ', function() return #a end ) )
|
||||
print( debug.setmetatable( a, mt ) )
|
||||
print( type(a), 'after', pcall( function() return #a end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
end
|
||||
--
|
||||
print( '---- __neg' )
|
||||
values = { aboolean, afunction, athread, "abcd", atable, anumber }
|
||||
for i=1,#values do
|
||||
local a = values[i]
|
||||
local amt = debug.getmetatable(a)
|
||||
print( type(v), 'before', ecall( 'attempt to perform arithmetic ', function() return -a end ) )
|
||||
print( debug.setmetatable( a, mt ) )
|
||||
print( type(v), 'after', pcall( function() return -a end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
end
|
||||
|
||||
print( '---- __lt, __le, same types' )
|
||||
local bfunction = function() end
|
||||
local bthread = coroutine.create( bfunction )
|
||||
local btable = {}
|
||||
local groups
|
||||
groups = { {true, true}, {true, false}, {afunction, bfunction}, {athread, bthread}, {atable, atable}, {atable, btable} }
|
||||
for i=1,#groups do
|
||||
local a,b = groups[i][1], groups[i][2]
|
||||
local amt,bmt = debug.getmetatable(a),debug.getmetatable(b)
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to compare', function() return a<b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to compare', function() return a<=b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to compare', function() return a>b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to compare', function() return a>=b end ) )
|
||||
print( debug.setmetatable( a, mt ) )
|
||||
print( debug.setmetatable( b, mt ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a<b end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a<=b end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a>b end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a>=b end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
print( debug.setmetatable( b, bmt ) )
|
||||
end
|
||||
|
||||
print( '---- __lt, __le, different types' )
|
||||
groups = { {aboolean, athread}, }
|
||||
for i=1,#groups do
|
||||
local a,b = groups[i][1], groups[i][2]
|
||||
local amt,bmt = debug.getmetatable(a),debug.getmetatable(b)
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to compare', function() return a<b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to compare', function() return a<=b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to compare', function() return a>b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to compare', function() return a>=b end ) )
|
||||
print( debug.setmetatable( a, mt ) )
|
||||
print( debug.setmetatable( b, mt ) )
|
||||
print( type(a), type(b), 'after-a', ecall( 'attempt to compare', function() return a<b end ) )
|
||||
print( type(a), type(b), 'after-a', ecall( 'attempt to compare', function() return a<=b end ) )
|
||||
print( type(a), type(b), 'after-a', ecall( 'attempt to compare', function() return a>b end ) )
|
||||
print( type(a), type(b), 'after-a', ecall( 'attempt to compare', function() return a>=b end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
print( debug.setmetatable( b, bmt ) )
|
||||
end
|
||||
|
||||
print( '---- __tostring' )
|
||||
values = { aboolean, afunction, athread, atable, "abc" }
|
||||
local strmt = { __tostring=function(a)
|
||||
return 'mt.__tostring('..type(a)..')'
|
||||
end,
|
||||
}
|
||||
for i=1,#values do
|
||||
local a = values[i]
|
||||
local amt = debug.getmetatable(a)
|
||||
print( debug.setmetatable( a, strmt ) )
|
||||
print( type(a), 'after', pcall( function() return ts(a) end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
end
|
||||
|
||||
print( '---- __index, __newindex' )
|
||||
values = { aboolean, anumber, afunction, athread }
|
||||
for i=1,#values do
|
||||
local a = values[i]
|
||||
local amt = debug.getmetatable(a)
|
||||
print( type(a), 'before', ecall( 'attempt to index', function() return a.foo end ) )
|
||||
print( type(a), 'before', ecall( 'attempt to index', function() return a[123] end ) )
|
||||
print( type(a), 'before', ecall( 'index', function() a.foo = 'bar' end ) )
|
||||
print( type(a), 'before', ecall( 'index', function() a[123] = 'bar' end ) )
|
||||
print( type(a), 'before', ecall( 'attempt to index', function() return a:foo() end ) )
|
||||
print( debug.setmetatable( a, mt ) )
|
||||
print( type(a), 'after', pcall( function() return a.foo end ) )
|
||||
print( type(a), 'after', pcall( function() return a[123] end ) )
|
||||
print( type(a), 'after', pcall( function() a.foo = 'bar' end ) )
|
||||
print( type(a), 'after', pcall( function() a[123] = 'bar' end ) )
|
||||
print( type(a), 'after', ecall( 'attempt to call', function() return a:foo() end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
end
|
||||
|
||||
print( '---- __concat' )
|
||||
groups = { {atable, afunction}, {afunction, atable}, {123, nil}, {nil, 123} }
|
||||
local s,t,u = 'sss',777
|
||||
local concatresult = setmetatable( { '__concat-result' }, {
|
||||
__tostring=function()
|
||||
return 'concat-string-result'
|
||||
end } )
|
||||
local concatmt = {
|
||||
__concat=function(a,b)
|
||||
print( 'mt.__concat('..type(a)..','..type(b)..')', a, b )
|
||||
return concatresult
|
||||
end
|
||||
}
|
||||
for i=1,#groups do
|
||||
local a,b = groups[i][1], groups[i][2]
|
||||
local amt,bmt = debug.getmetatable(a),debug.getmetatable(b)
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to concatenate ', function() return a..b end ) )
|
||||
print( type(a), type(b), 'before', ecall( 'attempt to concatenate ', function() return b..a end ) )
|
||||
print( type(a), type(s), type(t), 'before', ecall( 'attempt to concatenate ', function() return a..s..t end ) )
|
||||
print( type(s), type(a), type(t), 'before', ecall( 'attempt to concatenate ', function() return s..a..t end ) )
|
||||
print( type(s), type(t), type(a), 'before', ecall( 'attempt to concatenate ', function() return s..t..a end ) )
|
||||
print( debug.setmetatable( a, concatmt ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return a..b end ) )
|
||||
print( type(a), type(b), 'after', pcall( function() return b..a end ) )
|
||||
print( type(a), type(s), type(t), 'before', pcall( function() return a..s..t end ) )
|
||||
print( type(s), type(a), type(t), 'before', ecall( 'attempt to concatenate ', function() return s..a..t end ) )
|
||||
print( type(s), type(t), type(a), 'before', ecall( 'attempt to concatenate ', function() return s..t..a end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
print( debug.setmetatable( b, bmt ) )
|
||||
end
|
||||
|
||||
print( '---- __metatable' )
|
||||
values = { aboolean, afunction, athread, atable, "abc" }
|
||||
local mtmt = { __metatable={}, }
|
||||
for i=1,#values do
|
||||
local a = values[i]
|
||||
local amt = debug.getmetatable(a)
|
||||
print( type(a), 'before', pcall( function() return debug.getmetatable(a), getmetatable(a) end ) )
|
||||
print( debug.setmetatable( a, mtmt ) )
|
||||
print( type(a), 'after', pcall( function() return debug.getmetatable(a), getmetatable(a) end ) )
|
||||
print( debug.setmetatable( a, amt ) )
|
||||
end
|
||||
@@ -1,60 +0,0 @@
|
||||
-- simple os-library tests
|
||||
--
|
||||
-- because the nature of the "os" library is to provide os-specific behavior,
|
||||
-- the compatibility tests must be extremely loose, and can really only
|
||||
-- compare things like return value type to be meaningful.
|
||||
--
|
||||
-- actual os behavior needs to go in an oslib function test
|
||||
--
|
||||
local pcall = function(...)
|
||||
local s,e,f = pcall(...)
|
||||
return s,type(e),type(f)
|
||||
end
|
||||
print( 'os', type(os) )
|
||||
print( 'os.clock()', pcall( os.clock ) )
|
||||
print( 'os.date()', pcall( os.date ) )
|
||||
print( 'os.difftime(123000, 21500)', pcall( os.difftime, 123000, 21250 ) )
|
||||
print( 'os.getenv()', pcall( os.getenv ) )
|
||||
print( 'os.getenv("bogus.key")', pcall( os.getenv, 'bogus.key' ) )
|
||||
local s,p = pcall( os.tmpname )
|
||||
local s,q = pcall( os.tmpname )
|
||||
print( 'os.tmpname()', s, p )
|
||||
print( 'os.tmpname()', s, q )
|
||||
-- permission denied on windows
|
||||
--print( 'os.remove(p)', pcall( os.remove, p ) )
|
||||
--print( 'os.rename(p,q)', pcall( os.rename, p, q ) )
|
||||
local s,f = pcall( io.open, p,"w" )
|
||||
print( 'io.open', s, f )
|
||||
print( 'write', pcall( f.write, f, "abcdef 12345" ) )
|
||||
print( 'close', pcall( f.close, f ) )
|
||||
print( 'os.rename(p,q)', pcall( os.rename, p, q ) )
|
||||
print( 'os.remove(q)', pcall( os.remove, q ) )
|
||||
print( 'os.remove(q)', pcall( os.remove, q ) )
|
||||
-- setlocale not supported on jse yet
|
||||
-- print( 'os.setlocale()', pcall( os.setlocale ) )
|
||||
-- print( 'os.setlocale("jp")', pcall( os.setlocale, "jp" ) )
|
||||
-- print( 'os.setlocale("us","monetary")', pcall( os.setlocale, "us", "monetary" ) )
|
||||
-- print( 'os.setlocale(nil,"all")', pcall( os.setlocale, nil, "all" ) )
|
||||
print( 'os.setlocale("C")', pcall( os.setlocale, "C" ) )
|
||||
print( 'os.exit', type(os.exit) )
|
||||
|
||||
-- os.date() formatting
|
||||
local t = 1281364496 -- Aug 9, 2010, 2:34:56 PM (Monday)
|
||||
local function p(s)
|
||||
if pcall(os.date, s, t) then
|
||||
print( "os.date('"..s.."', "..t..")", pcall(os.date, s, t))
|
||||
end
|
||||
end
|
||||
for i= 65, 90 do
|
||||
p('%'..string.char(i + 97 - 65))
|
||||
p('%'..string.char(i))
|
||||
end
|
||||
local tbl = os.date('*t', t)
|
||||
for i,k in ipairs({'year', 'month', 'day', 'hour', 'min', 'sec', 'wday', 'yday', 'isdst'}) do
|
||||
local v = tbl[k]
|
||||
print('k', type(k), k, 'v', type(v), v)
|
||||
end
|
||||
|
||||
print('type(os.time())', type(os.time()))
|
||||
print('os.time({year=1971, month=2, day=25})', os.time({year=1971, month=2, day=25}))
|
||||
print('os.time({year=1971, month=2, day=25, hour=11, min=22, sec=33})', os.time({year=1971, month=2, day=25, hour=11, min=22, sec=33}))
|
||||
@@ -1,50 +0,0 @@
|
||||
-- The Computer Language Benchmarks Game
|
||||
-- http://shootout.alioth.debian.org/
|
||||
-- contributed by Mike Pall
|
||||
|
||||
local function BottomUpTree(item, depth)
|
||||
if depth > 0 then
|
||||
local i = item + item
|
||||
depth = depth - 1
|
||||
local left, right = BottomUpTree(i-1, depth), BottomUpTree(i, depth)
|
||||
return { item, left, right }
|
||||
else
|
||||
return { item }
|
||||
end
|
||||
end
|
||||
|
||||
local function ItemCheck(tree)
|
||||
if tree[2] then
|
||||
return tree[1] + ItemCheck(tree[2]) - ItemCheck(tree[3])
|
||||
else
|
||||
return tree[1]
|
||||
end
|
||||
end
|
||||
|
||||
local N = tonumber(arg and arg[1]) or 0
|
||||
local mindepth = 4
|
||||
local maxdepth = mindepth + 2
|
||||
if maxdepth < N then maxdepth = N end
|
||||
|
||||
do
|
||||
local stretchdepth = maxdepth + 1
|
||||
local stretchtree = BottomUpTree(0, stretchdepth)
|
||||
io.write(string.format("stretch tree of depth %d\t check: %d\n",
|
||||
stretchdepth, ItemCheck(stretchtree)))
|
||||
end
|
||||
|
||||
local longlivedtree = BottomUpTree(0, maxdepth)
|
||||
|
||||
for depth=mindepth,maxdepth,2 do
|
||||
local iterations = 2 ^ (maxdepth - depth + mindepth)
|
||||
local check = 0
|
||||
for i=1,iterations do
|
||||
check = check + ItemCheck(BottomUpTree(1, depth)) +
|
||||
ItemCheck(BottomUpTree(-1, depth))
|
||||
end
|
||||
io.write(string.format("%d\t trees of depth %d\t check: %d\n",
|
||||
iterations*2, depth, check))
|
||||
end
|
||||
|
||||
io.write(string.format("long lived tree of depth %d\t check: %d\n",
|
||||
maxdepth, ItemCheck(longlivedtree)))
|
||||
@@ -1,51 +0,0 @@
|
||||
-- The Computer Language Benchmarks Game
|
||||
-- http://shootout.alioth.debian.org/
|
||||
-- contributed by Mike Pall
|
||||
|
||||
local function fannkuch(n)
|
||||
local p, q, s, odd, check, maxflips = {}, {}, {}, true, 0, 0
|
||||
for i=1,n do p[i] = i; q[i] = i; s[i] = i end
|
||||
repeat
|
||||
-- Print max. 30 permutations.
|
||||
if check < 30 then
|
||||
if not p[n] then return maxflips end -- Catch n = 0, 1, 2.
|
||||
io.write(table.unpack(p)); io.write("\n")
|
||||
check = check + 1
|
||||
end
|
||||
-- Copy and flip.
|
||||
local q1 = p[1] -- Cache 1st element.
|
||||
if p[n] ~= n and q1 ~= 1 then -- Avoid useless work.
|
||||
for i=2,n do q[i] = p[i] end -- Work on a copy.
|
||||
for flips=1,1000000 do -- Flip ...
|
||||
local qq = q[q1]
|
||||
if qq == 1 then -- ... until 1st element is 1.
|
||||
if flips > maxflips then maxflips = flips end -- New maximum?
|
||||
break
|
||||
end
|
||||
q[q1] = q1
|
||||
if q1 >= 4 then
|
||||
local i, j = 2, q1 - 1
|
||||
repeat q[i], q[j] = q[j], q[i]; i = i + 1; j = j - 1; until i >= j
|
||||
end
|
||||
q1 = qq
|
||||
end
|
||||
end
|
||||
-- Permute.
|
||||
if odd then
|
||||
p[2], p[1] = p[1], p[2]; odd = false -- Rotate 1<-2.
|
||||
else
|
||||
p[2], p[3] = p[3], p[2]; odd = true -- Rotate 1<-2 and 1<-2<-3.
|
||||
for i=3,n do
|
||||
local sx = s[i]
|
||||
if sx ~= 1 then s[i] = sx-1; break end
|
||||
if i == n then return maxflips end -- Out of permutations.
|
||||
s[i] = i
|
||||
-- Rotate 1<-...<-i+1.
|
||||
local t = p[1]; for j=1,i do p[j] = p[j+1] end; p[i+1] = t
|
||||
end
|
||||
end
|
||||
until false
|
||||
end
|
||||
|
||||
local n = tonumber(arg and arg[1]) or 1
|
||||
io.write("Pfannkuchen(", n, ") = ", fannkuch(n), "\n")
|
||||
@@ -1,123 +0,0 @@
|
||||
-- The Great Computer Language Shootout
|
||||
-- http://shootout.alioth.debian.org/
|
||||
-- contributed by Isaac Gouy, tuned by Mike Pall
|
||||
|
||||
local sqrt = math.sqrt
|
||||
|
||||
local PI = 3.141592653589793
|
||||
local SOLAR_MASS = 4 * PI * PI
|
||||
local DAYS_PER_YEAR = 365.24
|
||||
|
||||
local Jupiter = {
|
||||
x = 4.84143144246472090e+00
|
||||
,y = -1.16032004402742839e+00
|
||||
,z = -1.03622044471123109e-01
|
||||
,vx = 1.66007664274403694e-03 * DAYS_PER_YEAR
|
||||
,vy = 7.69901118419740425e-03 * DAYS_PER_YEAR
|
||||
,vz = -6.90460016972063023e-05 * DAYS_PER_YEAR
|
||||
,mass = 9.54791938424326609e-04 * SOLAR_MASS
|
||||
}
|
||||
|
||||
local Saturn = {
|
||||
x = 8.34336671824457987e+00
|
||||
,y = 4.12479856412430479e+00
|
||||
,z = -4.03523417114321381e-01
|
||||
,vx = -2.76742510726862411e-03 * DAYS_PER_YEAR
|
||||
,vy = 4.99852801234917238e-03 * DAYS_PER_YEAR
|
||||
,vz = 2.30417297573763929e-05 * DAYS_PER_YEAR
|
||||
,mass = 2.85885980666130812e-04 * SOLAR_MASS
|
||||
}
|
||||
|
||||
local Uranus = {
|
||||
x = 1.28943695621391310e+01
|
||||
,y = -1.51111514016986312e+01
|
||||
,z = -2.23307578892655734e-01
|
||||
,vx = 2.96460137564761618e-03 * DAYS_PER_YEAR
|
||||
,vy = 2.37847173959480950e-03 * DAYS_PER_YEAR
|
||||
,vz = -2.96589568540237556e-05 * DAYS_PER_YEAR
|
||||
,mass = 4.36624404335156298e-05 * SOLAR_MASS
|
||||
}
|
||||
|
||||
local Neptune = {
|
||||
x = 1.53796971148509165e+01
|
||||
,y = -2.59193146099879641e+01
|
||||
,z = 1.79258772950371181e-01
|
||||
,vx = 2.68067772490389322e-03 * DAYS_PER_YEAR
|
||||
,vy = 1.62824170038242295e-03 * DAYS_PER_YEAR
|
||||
,vz = -9.51592254519715870e-05 * DAYS_PER_YEAR
|
||||
,mass = 5.15138902046611451e-05 * SOLAR_MASS
|
||||
}
|
||||
|
||||
local Sun = { x = 0, y = 0, z = 0,
|
||||
vx = 0, vy = 0, vz = 0, mass = SOLAR_MASS }
|
||||
|
||||
local function advance(bodies, nbody, dt)
|
||||
for i=1,nbody do
|
||||
local bi = bodies[i]
|
||||
local bix, biy, biz, bimass = bi.x, bi.y, bi.z, bi.mass
|
||||
local bivx, bivy, bivz = bi.vx, bi.vy, bi.vz
|
||||
for j=i+1,nbody do
|
||||
local bj = bodies[j]
|
||||
local dx, dy, dz = bix-bj.x, biy-bj.y, biz-bj.z
|
||||
local distance = sqrt(dx*dx + dy*dy + dz*dz)
|
||||
local mag = dt / (distance * distance * distance)
|
||||
local bim, bjm = bimass*mag, bj.mass*mag
|
||||
bivx = bivx - (dx * bjm)
|
||||
bivy = bivy - (dy * bjm)
|
||||
bivz = bivz - (dz * bjm)
|
||||
bj.vx = bj.vx + (dx * bim)
|
||||
bj.vy = bj.vy + (dy * bim)
|
||||
bj.vz = bj.vz + (dz * bim)
|
||||
end
|
||||
bi.vx = bivx
|
||||
bi.vy = bivy
|
||||
bi.vz = bivz
|
||||
end
|
||||
for i=1,nbody do
|
||||
local bi = bodies[i]
|
||||
bi.x = bi.x + (dt * bi.vx)
|
||||
bi.y = bi.y + (dt * bi.vy)
|
||||
bi.z = bi.z + (dt * bi.vz)
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
local function energy(bodies, nbody)
|
||||
local e = 0
|
||||
for i=1,nbody do
|
||||
local bi = bodies[i]
|
||||
local vx, vy, vz, bim = bi.vx, bi.vy, bi.vz, bi.mass
|
||||
e = e + (0.5 * bim * (vx*vx + vy*vy + vz*vz))
|
||||
for j=i+1,nbody do
|
||||
local bj = bodies[j]
|
||||
local dx, dy, dz = bi.x-bj.x, bi.y-bj.y, bi.z-bj.z
|
||||
local distance = sqrt(dx*dx + dy*dy + dz*dz)
|
||||
e = e - ((bim * bj.mass) / distance)
|
||||
end
|
||||
end
|
||||
return e
|
||||
end
|
||||
|
||||
|
||||
local function offsetMomentum(b, nbody)
|
||||
local px, py, pz = 0, 0, 0
|
||||
for i=1,nbody do
|
||||
local bi = b[i]
|
||||
local bim = bi.mass
|
||||
px = px + (bi.vx * bim)
|
||||
py = py + (bi.vy * bim)
|
||||
pz = pz + (bi.vz * bim)
|
||||
end
|
||||
b[1].vx = -px / SOLAR_MASS
|
||||
b[1].vy = -py / SOLAR_MASS
|
||||
b[1].vz = -pz / SOLAR_MASS
|
||||
end
|
||||
|
||||
local N = tonumber(arg and arg[1]) or 1000
|
||||
local bodies = { Sun, Jupiter, Saturn, Uranus, Neptune }
|
||||
local nbody = #bodies
|
||||
|
||||
offsetMomentum(bodies, nbody)
|
||||
io.write( string.format("%0.9f",energy(bodies, nbody)), "\n")
|
||||
for i=1,N do advance(bodies, nbody, 0.01) end
|
||||
io.write( string.format("%0.9f",energy(bodies, nbody)), "\n")
|
||||
@@ -1,35 +0,0 @@
|
||||
-- The Computer Language Shootout
|
||||
-- http://shootout.alioth.debian.org/
|
||||
-- contributed by Isaac Gouy
|
||||
-- modified by Mike Pall
|
||||
|
||||
|
||||
local function nsieve(m,isPrime)
|
||||
for i=2,m do
|
||||
isPrime[i] = true
|
||||
end
|
||||
local count = 0
|
||||
|
||||
for i=2,m do
|
||||
if isPrime[i] then
|
||||
for k=i+i, m, i do
|
||||
if isPrime[k] then isPrime[k] = false end
|
||||
end
|
||||
count = count + 1
|
||||
end
|
||||
end
|
||||
return count
|
||||
end
|
||||
|
||||
|
||||
local n = tonumber(arg and arg[1]) or 1
|
||||
local flags = {}
|
||||
|
||||
local m = (2^n)*10000
|
||||
print( string.format("Primes up to %8d %8d", m, nsieve(m,flags)))
|
||||
|
||||
m = (2^(n-1))*10000
|
||||
print( string.format("Primes up to %8d %8d", m, nsieve(m,flags)))
|
||||
|
||||
m = (2^(n-2))*10000
|
||||
print( string.format("Primes up to %8d %8d", m, nsieve(m,flags)))
|
||||
@@ -1,39 +0,0 @@
|
||||
#!/bin/bash
|
||||
#
|
||||
# unpack the luaj test archive, compile and run it locally, and repack the results
|
||||
|
||||
# unzip existing archive
|
||||
unzip -n luaj3.0-tests.zip
|
||||
rm *.lc *.out */*.lc */*.out
|
||||
|
||||
# compile tests for compiler and save binary files
|
||||
for DIR in "lua5.2.1-tests" "regressions"; do
|
||||
cd ${DIR}
|
||||
FILES=`ls -1 *.lua | awk 'BEGIN { FS="." } ; { print $1 }'`
|
||||
for FILE in $FILES ; do
|
||||
echo 'compiling' `pwd` $FILE
|
||||
luac ${FILE}.lua
|
||||
mv luac.out ${FILE}.lc
|
||||
done
|
||||
cd ..
|
||||
done
|
||||
|
||||
# run test lua scripts and save output
|
||||
for DIR in "errors" "perf" "."; do
|
||||
cd ${DIR}
|
||||
FILES=`ls -1 *.lua | awk 'BEGIN { FS="." } ; { print $1 }'`
|
||||
for FILE in $FILES ; do
|
||||
echo 'executing' `pwd` $FILE
|
||||
lua ${FILE}.lua JSE > ${FILE}.out
|
||||
done
|
||||
cd ..
|
||||
done
|
||||
cd lua
|
||||
|
||||
# create new zipfile
|
||||
rm -f luaj3.0-tests.zip regressions
|
||||
zip luaj3.0-tests.zip *.lua *.lc *.out */*.lua */*.lc */*.out
|
||||
|
||||
# cleanup
|
||||
rm *.out */*.lc */*.out
|
||||
rm -r lua5.2.1-tests
|
||||
@@ -1,192 +0,0 @@
|
||||
print( string.find("1234567890", ".", 0, true) )
|
||||
print( string.find( 'alo alx 123 b\0o b\0o', '(..*) %1' ) )
|
||||
print( string.find( 'aloALO', '%l*' ) )
|
||||
print( string.find( ' \n isto <20> assim', '%S%S*' ) )
|
||||
|
||||
print( string.find( "", "" ) )
|
||||
print( string.find( "ababaabbaba", "abb" ) )
|
||||
print( string.find( "ababaabbaba", "abb", 7 ) )
|
||||
|
||||
print( string.match( "aabaa", "a*" ) )
|
||||
print( string.match( "aabaa", "a*", 3 ) )
|
||||
print( string.match( "aabaa", "a*b" ) )
|
||||
print( string.match( "aabaa", "a*b", 3 ) )
|
||||
|
||||
print( string.match( "abbaaababaabaaabaa", "b(a*)b" ) )
|
||||
|
||||
print( string.match( "abbaaababaabaaabaa", "b(a*)()b" ) )
|
||||
print( string.match( "abbaaababaabaaabaa", "b(a*)()b", 3 ) )
|
||||
print( string.match( "abbaaababaabaaabaa", "b(a*)()b", 8 ) )
|
||||
print( string.match( "abbaaababaabaaabaa", "b(a*)()b", 12 ) )
|
||||
|
||||
print( string.byte("hi", -3) )
|
||||
|
||||
print( string.gsub("ABC", "@(%x+)", function(s) return "|abcd" end) )
|
||||
print( string.gsub("@123", "@(%x+)", function(s) return "|abcd" end) )
|
||||
print( string.gsub("ABC@123", "@(%x+)", function(s) return "|abcd" end) )
|
||||
print( string.gsub("ABC@123@def", "@(%x+)", function(s) return "|abcd" end) )
|
||||
print( string.gsub("ABC@123@qrs@def@tuv", "@(%x+)", function(s) return "|abcd" end) )
|
||||
print( string.gsub("ABC@123@qrs@def@tuv", "@(%x+)", function(s) return "@ab" end) )
|
||||
|
||||
print( tostring(1234567890123) )
|
||||
print( tostring(1234567890124) )
|
||||
print( tostring(1234567890125) )
|
||||
|
||||
function f1(s, p)
|
||||
print(p)
|
||||
p = string.gsub(p, "%%([0-9])", function (s) return "%" .. (s+1) end)
|
||||
print(p)
|
||||
p = string.gsub(p, "^(^?)", "%1()", 1)
|
||||
print(p)
|
||||
p = string.gsub(p, "($?)$", "()%1", 1)
|
||||
print(p)
|
||||
local t = {string.match(s, p)}
|
||||
return string.sub(s, t[1], t[#t] - 1)
|
||||
end
|
||||
|
||||
print( pcall( f1, 'alo alx 123 b\0o b\0o', '(..*) %1' ) )
|
||||
|
||||
local function badpat()
|
||||
print( string.gsub( "alo", "(.)", "%2" ) )
|
||||
end
|
||||
|
||||
print( ( pcall( badpat ) ) )
|
||||
|
||||
for k, v in string.gmatch("w=200&h=150", "(%w+)=(%w+)") do
|
||||
print(k, v)
|
||||
end
|
||||
|
||||
-- string.sub
|
||||
function t(str)
|
||||
local i = { 0, 1, 2, 8, -1 }
|
||||
for ki,vi in ipairs(i) do
|
||||
local s,v = pcall( string.sub, str, vi )
|
||||
print( 'string.sub("'..str..'",'..tostring(vi)..')='..tostring(s)..',"'..tostring(v)..'"' )
|
||||
local j = { 0, 1, 2, 4, 8, -1 }
|
||||
for kj,vj in ipairs(j) do
|
||||
local s,v = pcall( string.sub, str, vi, vj )
|
||||
print( 'string.sub("'..str..'",'..tostring(vi)..','..tostring(vj)..')='..tostring(s)..',"'..tostring(v)..'"' )
|
||||
end
|
||||
end
|
||||
end
|
||||
t( 'abcdefghijklmn' )
|
||||
t( 'abcdefg' )
|
||||
t( 'abcd' )
|
||||
t( 'abc' )
|
||||
t( 'ab' )
|
||||
t( 'a' )
|
||||
t( '' )
|
||||
|
||||
print(string.len("Hello, world"))
|
||||
print(#"Hello, world")
|
||||
print(string.len("\0\0\0"))
|
||||
print(#"\0\0\0")
|
||||
print(string.len("\0\1\2\3"))
|
||||
print(#"\0\1\2\3")
|
||||
local s = "My JaCk-O-lAnTeRn CaSe TeXt"
|
||||
print(s, string.len(s), #s)
|
||||
|
||||
|
||||
-- string.format
|
||||
print(string.format("(%.0d) (%.0d) (%.0d)", 0, -5, 9))
|
||||
print(string.format("(%.1d) (%.1d) (%.1d)", 0, -5, 9))
|
||||
print(string.format("(%.2d) (%.2d) (%.2d)", 0, -5, 9))
|
||||
|
||||
print(string.format("(%+.0d) (%+.0d) (%+.0d)", 0, -5, 9))
|
||||
print(string.format("(%+.1d) (%+.1d) (%+.1d)", 0, -5, 9))
|
||||
print(string.format("(%+.2d) (%+.2d) (%+.2d)", 0, -5, 9))
|
||||
|
||||
print(string.format("(%+3d) (% 3d) (%+ 3d)", 55, 55, 55))
|
||||
|
||||
print(string.format("(%-1d) (%-1d) (%-1d)", 1, 12, -12))
|
||||
print(string.format("(%-2d) (%-2d) (%-2d)", 1, 12, -12))
|
||||
print(string.format("(%-3d) (%-3d) (%-3d)", 1, 12, -12))
|
||||
|
||||
|
||||
print(string.format("(%8x) (%8d) (%8o)", 255, 255, 255))
|
||||
print(string.format("(%08x) (%08d) (%08o)", 255, 255, 255))
|
||||
|
||||
print(string.format("simple%ssimple", " simple "))
|
||||
|
||||
local testformat = function(message,fmt,...)
|
||||
local s,e = pcall( string.format, fmt, ... )
|
||||
if s then
|
||||
if string.find(fmt, 'q') then
|
||||
print(message, e)
|
||||
end
|
||||
print( message, string.byte(e,1,#e) )
|
||||
else
|
||||
print( message, 'error', e )
|
||||
end
|
||||
end
|
||||
|
||||
testformat('plain %', "%%")
|
||||
testformat("specials (%s)", "---%s---", " %% \000 \r \n ")
|
||||
testformat("specials (%q)", "---%q---", " %% \000 \r \n ")
|
||||
testformat("specials (%q)", "---%q---", "0%%0\0000\r0\n0")
|
||||
testformat("controls (%q)", "---%q---", ' \a \b \f \t \v \\ ')
|
||||
testformat("controls (%q)", "---%q---", '0\a0\b0\f0\t0\v0\\0')
|
||||
testformat("extended (%q)", "---%q---", ' \222 \223 \224 ')
|
||||
testformat("extended (%q)", "---%q---", '0\2220\2230\2240')
|
||||
testformat("embedded newlines", "%s\r%s\n%s", '===', '===', '===')
|
||||
|
||||
-- format long string
|
||||
print("this is a %s long string", string.rep("really, ", 30))
|
||||
|
||||
local function pc(...)
|
||||
local s,e = pcall(...)
|
||||
return s and e or 'false-'..type(e)
|
||||
end
|
||||
|
||||
local function strtests(name,func,...)
|
||||
print(name, 'good', pc( func, ... ) )
|
||||
print(name, 'empty', pc( func ) )
|
||||
print(name, 'table', pc( func, {} ) )
|
||||
print(name, 'nil', pc( func, nil ) )
|
||||
end
|
||||
|
||||
strtests('lower', string.lower, s )
|
||||
strtests('upper', string.upper, s )
|
||||
strtests('reverse', string.reverse, s )
|
||||
strtests('char', string.char, 92, 60, 61, 93 )
|
||||
stringdumptest = function()
|
||||
return load(string.dump(function(x) return 'foo->'..x end),'bar')('bat')
|
||||
end
|
||||
print( 'string.dump test:', pcall(stringdumptest) )
|
||||
|
||||
|
||||
-- floating point formats (not supported yet)
|
||||
--[==[
|
||||
local prefixes = {'','+','-'}
|
||||
local lengths = {'7','2','0','1',''}
|
||||
local letters = {'f','e','g'}
|
||||
local fmt, spec, desc
|
||||
for i,letter in ipairs(letters) do
|
||||
for k,before in ipairs(lengths) do
|
||||
for j,prefix in ipairs(prefixes) do
|
||||
spec = '(%'..prefix..before..letter..')'
|
||||
fmt = spec..'\t'..spec..'\t'..spec..'\t'..spec..'\t'..spec..'\t'..spec
|
||||
print(spec, string.format(fmt, 12.34, -12.34, 1/11, -1/11, 300/11, -300/11) )
|
||||
for l,after in ipairs(lengths) do
|
||||
spec = '(%'..prefix..before..'.'..after..letter..')'
|
||||
fmt = spec..' '..spec..' '..spec..' '..spec..' '..spec..' '..spec
|
||||
print(spec, string.format(fmt, 12.34, -12.34, 1/11, -1/11, 300/11, -300/11) )
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
--]==]
|
||||
|
||||
local function fmterr(...)
|
||||
local r, s = pcall(...)
|
||||
if r then
|
||||
return s
|
||||
else
|
||||
s = string.gsub(s, "stdin:%d+:%s*", "")
|
||||
return s
|
||||
end
|
||||
end
|
||||
|
||||
print(fmterr(string.find, "ab%c)0(", "%"))
|
||||
print(fmterr(string.find, "ab%c)0(", "("))
|
||||
print(pcall(string.find, "ab%c)0(", ")"))
|
||||
@@ -1,284 +0,0 @@
|
||||
local func = function(t,...)
|
||||
return (...)
|
||||
end
|
||||
local tbl = setmetatable({},{__index=func})
|
||||
print( tbl[2] )
|
||||
|
||||
|
||||
-- tostring replacement that assigns ids
|
||||
local ts,id,nid,types = tostring,{},0,{table='tbl',thread='thr',userdata='uda',['function']='func'}
|
||||
tostring = function(x)
|
||||
if not x or not types[type(x)] then return ts(x) end
|
||||
if not id[x] then nid=nid+1; id[x]=types[type(x)]..'.'..nid end
|
||||
return id[x]
|
||||
end
|
||||
|
||||
local t = { "one", "two", "three", a='aaa', b='bbb', c='ccc' }
|
||||
|
||||
table.insert(t,'six');
|
||||
table.insert(t,1,'seven');
|
||||
table.insert(t,4,'eight');
|
||||
table.insert(t,7,'nine');
|
||||
table.insert(t,10,'ten'); print( #t )
|
||||
|
||||
-- concat
|
||||
print( '-- concat tests' )
|
||||
function tryconcat(t)
|
||||
print( table.concat(t) )
|
||||
print( table.concat(t,'--') )
|
||||
print( table.concat(t,',',2) )
|
||||
print( table.concat(t,',',2,2) )
|
||||
print( table.concat(t,',',5,2) )
|
||||
end
|
||||
tryconcat( { "one", "two", "three", a='aaa', b='bbb', c='ccc' } )
|
||||
tryconcat( { "one", "two", "three", "four", "five" } )
|
||||
function tryconcat(t)
|
||||
print( table.concat(t) )
|
||||
print( table.concat(t,'--') )
|
||||
print( table.concat(t,',',2) )
|
||||
end
|
||||
tryconcat( { a='aaa', b='bbb', c='ccc', d='ddd', e='eee' } )
|
||||
tryconcat( { [501]="one", [502]="two", [503]="three", [504]="four", [505]="five" } )
|
||||
tryconcat( {} )
|
||||
|
||||
-- print the elements of a table in a platform-independent way
|
||||
function eles(t,f)
|
||||
f = f or pairs
|
||||
all = {}
|
||||
for k,v in f(t) do
|
||||
table.insert( all, "["..tostring(k).."]="..tostring(v) )
|
||||
end
|
||||
table.sort( all )
|
||||
return "{"..table.concat(all,',').."}"
|
||||
end
|
||||
|
||||
-- insert, len
|
||||
print( '-- insert, len tests' )
|
||||
local t = { "one", "two", "three", a='aaa', b='bbb', c='ccc' }
|
||||
|
||||
print( eles(t), #t )
|
||||
table.insert(t,'six'); print( eles(t), #t )
|
||||
table.insert(t,1,'seven'); print( eles(t), #t )
|
||||
table.insert(t,4,'eight'); print( eles(t), #t )
|
||||
table.insert(t,7,'nine'); print( eles(t), #t )
|
||||
table.insert(t,10,'ten'); print( eles(t), #t )
|
||||
print( '#{}', #{} )
|
||||
print( '#{"a"}', #{"a"} )
|
||||
print( '#{"a","b"}', #{"a","b"} )
|
||||
print( '#{"a",nil}', #{"a",nil} )
|
||||
print( '#{nil,nil}', #{nil,nil} )
|
||||
print( '#{nil,"b"}', #{nil,"b"}==0 or #{nil,"b"}==2 )
|
||||
print( '#{"a","b","c"}', #{"a","b","c"} )
|
||||
print( '#{"a","b",nil}', #{"a","b",nil} )
|
||||
print( '#{"a",nil,nil}', #{"a",nil,nil} )
|
||||
print( '#{nil,nil,nil}', #{nil,nil,nil} )
|
||||
print( '#{nil,nil,"c"}', #{nil,nil,"c"}==0 or #{nil,nil,"c"}==3 )
|
||||
print( '#{nil,"b","c"}', #{nil,"b","c"}==0 or #{nil,"b","c"}==3 )
|
||||
print( '#{nil,"b",nil}', #{nil,"b",nil}==0 or #{nil,"b",nil}==2 )
|
||||
print( '#{"a",nil,"c"}', #{"a",nil,"c"}==1 or #{"a",nil,"c"}==3 )
|
||||
|
||||
-- remove
|
||||
print( '-- remove tests' )
|
||||
t = { "one", "two", "three", "four", "five", "six", "seven", [10]="ten", a='aaa', b='bbb', c='ccc' }
|
||||
print( eles(t), #t )
|
||||
print( 'table.remove(t)', table.remove(t) ); print( eles(t), #t )
|
||||
print( 'table.remove(t,1)', table.remove(t,1) ); print( eles(t), #t )
|
||||
print( 'table.remove(t,3)', table.remove(t,3) ); print( eles(t), #t )
|
||||
print( 'table.remove(t,5)', table.remove(t,5) ); print( eles(t), #t )
|
||||
print( 'table.remove(t,10)', table.remove(t,10) ); print( eles(t), #t )
|
||||
print( 'table.remove(t,-1)', table.remove(t,-1) ); print( eles(t), #t )
|
||||
print( 'table.remove(t,-1)', table.remove(t,-1) ) ; print( eles(t), #t )
|
||||
|
||||
-- sort
|
||||
print( '-- sort tests' )
|
||||
function sorttest(t,f)
|
||||
t = (t)
|
||||
print( table.concat(t,'-') )
|
||||
if f then
|
||||
table.sort(t,f)
|
||||
else
|
||||
table.sort(t)
|
||||
end
|
||||
print( table.concat(t,'-') )
|
||||
end
|
||||
sorttest{ "one", "two", "three" }
|
||||
sorttest{ "www", "vvv", "uuu", "ttt", "sss", "zzz", "yyy", "xxx" }
|
||||
sorttest( { "www", "vvv", "uuu", "ttt", "sss", "zzz", "yyy", "xxx" }, function(a,b) return b<a end)
|
||||
|
||||
-- pairs, ipairs
|
||||
--[[
|
||||
function testpairs(f, t, name)
|
||||
print( name )
|
||||
for a,b in f(t) do
|
||||
print( ' ', a, b )
|
||||
end
|
||||
end
|
||||
function testbothpairs(t)
|
||||
testpairs( pairs, t, 'pairs( '..eles(t)..' )' )
|
||||
testpairs( ipairs, t, 'ipairs( '..eles(t)..' )' )
|
||||
end
|
||||
for i,t in ipairs({t0,t1,t2,t3}) do
|
||||
testbothpairs(t)
|
||||
end
|
||||
|
||||
t = { 'one', 'two', 'three', 'four', 'five' }
|
||||
testbothpairs(t)
|
||||
t[6] = 'six'
|
||||
testbothpairs(t)
|
||||
t[4] = nil
|
||||
testbothpairs(t)
|
||||
--]]
|
||||
|
||||
-- tests of setlist table constructors
|
||||
-- length is tested elsewhere
|
||||
print('----- unpack tests -------')
|
||||
local unpack = table.unpack
|
||||
print( 'pcall(unpack)', (pcall(unpack)) );
|
||||
print( 'pcall(unpack,nil)', (pcall(unpack,nil)) );
|
||||
print( 'pcall(unpack,"abc")', (pcall(unpack,"abc")) );
|
||||
print( 'pcall(unpack,1)', (pcall(unpack,1)) );
|
||||
print( 'unpack({"aa"})', unpack({"aa"}) );
|
||||
print( 'unpack({"aa","bb"})', unpack({"aa","bb"}) );
|
||||
print( 'unpack({"aa","bb","cc"})', unpack({"aa","bb","cc"}) );
|
||||
local function a(...) return ... end
|
||||
print('unpack -',unpack({}))
|
||||
print('unpack a',unpack({'a'}))
|
||||
print('unpack .',unpack({nil},1,1))
|
||||
print('unpack ab',unpack({'a', 'b'}))
|
||||
print('unpack .b',unpack({nil, 'b'},1,2))
|
||||
print('unpack a.',unpack({'a', nil},1,2))
|
||||
print('unpack abc',unpack({'a', 'b', 'c'}))
|
||||
print('unpack .ab',unpack({nil, 'a', 'b'},1,3))
|
||||
print('unpack a.b',unpack({'a', nil, 'b'},1,3))
|
||||
print('unpack ab.',unpack({'a', 'b', nil},1,3))
|
||||
print('unpack ..b',unpack({nil, nil, 'b'},1,3))
|
||||
print('unpack a..',unpack({'a', nil, nil},1,3))
|
||||
print('unpack .b.',unpack({nil, 'b', nil},1,3))
|
||||
print('unpack ...',unpack({nil, nil, nil},1,3))
|
||||
print('unpack (-)',unpack({a()}))
|
||||
print('unpack (a)',unpack({a('a')}))
|
||||
print('unpack (.)',unpack({a(nil)},1,1))
|
||||
print('unpack (ab)',unpack({a('a', 'b')}))
|
||||
print('unpack (.b)',unpack({a(nil, 'b')},1,2))
|
||||
print('unpack (a.)',unpack({a('a', nil)},1,2))
|
||||
print('unpack (abc)',unpack({a('a', 'b', 'c')}))
|
||||
print('unpack (.ab)',unpack({a(nil, 'a', 'b')},1,3))
|
||||
print('unpack (a.b)',unpack({a('a', nil, 'b')},1,3))
|
||||
print('unpack (ab.)',unpack({a('a', 'b', nil)},1,3))
|
||||
print('unpack (..b)',unpack({a(nil, nil, 'b')},1,3))
|
||||
print('unpack (a..)',unpack({a('a', nil, nil)},1,3))
|
||||
print('unpack (.b.)',unpack({a(nil, 'b', nil)},1,3))
|
||||
print('unpack (...)',unpack({a(nil, nil, nil)},1,3))
|
||||
local t = {"aa","bb","cc","dd","ee","ff"}
|
||||
print( 'pcall(unpack,t)', pcall(unpack,t) );
|
||||
print( 'pcall(unpack,t,2)', pcall(unpack,t,2) );
|
||||
print( 'pcall(unpack,t,2,5)', pcall(unpack,t,2,5) );
|
||||
print( 'pcall(unpack,t,2,6)', pcall(unpack,t,2,6) );
|
||||
print( 'pcall(unpack,t,2,7)', pcall(unpack,t,2,7) );
|
||||
print( 'pcall(unpack,t,1)', pcall(unpack,t,1) );
|
||||
print( 'pcall(unpack,t,1,5)', pcall(unpack,t,1,5) );
|
||||
print( 'pcall(unpack,t,1,6)', pcall(unpack,t,1,6) );
|
||||
print( 'pcall(unpack,t,1,7)', pcall(unpack,t,1,7) );
|
||||
print( 'pcall(unpack,t,0)', pcall(unpack,t,0) );
|
||||
print( 'pcall(unpack,t,0,5)', pcall(unpack,t,0,5) );
|
||||
print( 'pcall(unpack,t,0,6)', pcall(unpack,t,0,6) );
|
||||
print( 'pcall(unpack,t,0,7)', pcall(unpack,t,0,7) );
|
||||
print( 'pcall(unpack,t,-1)', pcall(unpack,t,-1) );
|
||||
print( 'pcall(unpack,t,-1,5)', pcall(unpack,t,-1,5) );
|
||||
print( 'pcall(unpack,t,-1,6)', pcall(unpack,t,-1,6) );
|
||||
print( 'pcall(unpack,t,-1,7)', pcall(unpack,t,-1,7) );
|
||||
print( 'pcall(unpack,t,2,4)', pcall(unpack,t,2,4) );
|
||||
print( 'pcall(unpack,t,2,5)', pcall(unpack,t,2,5) );
|
||||
print( 'pcall(unpack,t,2,6)', pcall(unpack,t,2,6) );
|
||||
print( 'pcall(unpack,t,2,7)', pcall(unpack,t,2,7) );
|
||||
print( 'pcall(unpack,t,2,8)', pcall(unpack,t,2,8) );
|
||||
print( 'pcall(unpack,t,2,2)', pcall(unpack,t,2,0) );
|
||||
print( 'pcall(unpack,t,2,1)', pcall(unpack,t,2,0) );
|
||||
print( 'pcall(unpack,t,2,0)', pcall(unpack,t,2,0) );
|
||||
print( 'pcall(unpack,t,2,-1)', pcall(unpack,t,2,-1) );
|
||||
t[0] = 'zz'
|
||||
t[-1] = 'yy'
|
||||
t[-2] = 'xx'
|
||||
print( 'pcall(unpack,t,0)', pcall(unpack,t,0) );
|
||||
print( 'pcall(unpack,t,2,0)', pcall(unpack,t,2,0) );
|
||||
print( 'pcall(unpack,t,2,-1)', pcall(unpack,t,2,-1) );
|
||||
print( 'pcall(unpack,t,"3")', pcall(unpack,t,"3") );
|
||||
print( 'pcall(unpack,t,"a")', (pcall(unpack,t,"a")) );
|
||||
print( 'pcall(unpack,t,function() end)', (pcall(unpack,t,function() end)) );
|
||||
|
||||
-- misc tests
|
||||
print('----- misc table initializer tests -------')
|
||||
print( # { 'abc', 'def', 'ghi', nil } ) -- should be 3 !
|
||||
print( # { 'abc', 'def', 'ghi', false } ) -- should be 4 !
|
||||
print( # { 'abc', 'def', 'ghi', 0 } ) -- should be 4 !
|
||||
|
||||
-- basic table operation tests
|
||||
print('----- basic table operations -------')
|
||||
|
||||
local dummyfunc = function(t,...)
|
||||
print( 'metatable call args', type(t), ...)
|
||||
return 'dummy'
|
||||
end
|
||||
local makeloud = function(t)
|
||||
return setmetatable(t,{
|
||||
__index=function(t,k)
|
||||
print( '__index', type(t), k )
|
||||
return rawset(t,k)
|
||||
end,
|
||||
__newindex=function(t,k,v)
|
||||
print( '__newindex', type(t), k, v )
|
||||
rawset(t,k,v)
|
||||
end})
|
||||
end
|
||||
local tests = {
|
||||
{'basic table', {}},
|
||||
{'function metatable on __index', setmetatable({},{__index=dummyfunc})},
|
||||
{'function metatable on __newindex', setmetatable({},{__newindex=dummyfunc})},
|
||||
{'plain metatable on __index', setmetatable({},makeloud({}))},
|
||||
{'plain metatable on __newindex', setmetatable({},makeloud({}))},
|
||||
}
|
||||
local function shoulderr(s,e)
|
||||
return s,type(e)
|
||||
end
|
||||
for i,test in ipairs(tests) do
|
||||
local testname = test[1]
|
||||
local testtable = test[2]
|
||||
print( '------ basic table tests on '..testname..' '..type(testtable) )
|
||||
print( 't[1]=2', pcall( function() testtable[1]=2 end ) )
|
||||
print( 't[1]', pcall( function() return testtable[1] end ) )
|
||||
print( 't[1]=nil', pcall( function() testtable[1]=nil end ) )
|
||||
print( 't[1]', pcall( function() return testtable[1] end ) )
|
||||
print( 't["a"]="b"', pcall( function() testtable["a"]="b" end ) )
|
||||
print( 't["a"],t.a', pcall( function() return testtable["a"],testtable.a end ) )
|
||||
print( 't.a="c"', pcall( function() testtable.a="c" end ) )
|
||||
print( 't["a"],t.a', pcall( function() return testtable["a"],testtable.a end ) )
|
||||
print( 't.a=nil', pcall( function() testtable.a=nil end ) )
|
||||
print( 't["a"],t.a', pcall( function() return testtable["a"],testtable.a end ) )
|
||||
print( 't[nil]="d"', shoulderr( pcall( function() testtable[nil]="d" end ) ) )
|
||||
print( 't[nil]', pcall( function() return testtable[nil] end ) )
|
||||
print( 't[nil]=nil', shoulderr( pcall( function() testtable[nil]=nil end ) ) )
|
||||
print( 't[nil]', pcall( function() return testtable[nil] end ) )
|
||||
end
|
||||
|
||||
print( '-- sort tests' )
|
||||
local function tryall(cmp)
|
||||
local function try(t)
|
||||
print( table.concat(t,'-') )
|
||||
if pcall( table.sort, t, cmp ) then
|
||||
print( table.concat(t,'-') )
|
||||
else
|
||||
print( 'sort failed' )
|
||||
end
|
||||
end
|
||||
try{ 2, 4, 6, 8, 1, 3, 5, 7 }
|
||||
try{ 333, 222, 111 }
|
||||
try{ "www", "xxx", "yyy", "aaa", "bbb", "ccc" }
|
||||
try{ 21, 23, "25", 27, 22, "24", 26, 28 }
|
||||
end
|
||||
local function comparator(a,b)
|
||||
return tonumber(a)<tonumber(b)
|
||||
end
|
||||
print ( 'default (lexical) comparator' )
|
||||
tryall()
|
||||
print ( 'custom (numerical) comparator' )
|
||||
tryall(comparator)
|
||||
@@ -1,153 +0,0 @@
|
||||
|
||||
-- tostring replacement that assigns ids
|
||||
local ts,id,nid,types = tostring,{},0,{table='tbl',thread='thr',userdata='uda',['function']='func'}
|
||||
tostring = function(x)
|
||||
if not x or not types[type(x)] then return ts(x) end
|
||||
if not id[x] then nid=nid+1; id[x]=types[type(x)]..'.'..nid end
|
||||
return id[x]
|
||||
end
|
||||
|
||||
|
||||
function a()
|
||||
return pcall( function() end )
|
||||
end
|
||||
|
||||
function b()
|
||||
return pcall( function() print 'b' end )
|
||||
end
|
||||
|
||||
function c()
|
||||
return pcall( function() return 'c' end )
|
||||
end
|
||||
|
||||
print( pcall( a ) )
|
||||
print( pcall( b ) )
|
||||
print( pcall( c ) )
|
||||
|
||||
local function sum(...)
|
||||
local s = 0
|
||||
for i,v in ipairs({...}) do
|
||||
s = s + v
|
||||
end
|
||||
return s
|
||||
end
|
||||
|
||||
local function f1(n,a,b,c)
|
||||
local a = a or 0
|
||||
local b = b or 0
|
||||
local c = c or 0
|
||||
if n <= 0 then
|
||||
return a,a+b,a+b+c
|
||||
end
|
||||
return f1(n-1,a,a+b,a+b+c)
|
||||
end
|
||||
|
||||
local function f2(n,...)
|
||||
if n <= 0 then
|
||||
print( " --f2, n<=0, returning sum(...)", ... )
|
||||
return sum(...)
|
||||
end
|
||||
print( " --f2, n>0, returning f2(n-1,n,...)", n-1,n,... )
|
||||
return f2(n-1,n,...)
|
||||
end
|
||||
|
||||
local function f3(n,...)
|
||||
if n <= 0 then
|
||||
return sum(...)
|
||||
end
|
||||
print( " f3,n-1,n,...", f3,n-1,n,... )
|
||||
return pcall(f3,n-1,n,...)
|
||||
end
|
||||
|
||||
local function all(f)
|
||||
for n=0,3 do
|
||||
t = {}
|
||||
for m=1,5 do
|
||||
print( "--f, n, table.unpack(t)", f, n, table.unpack(t) )
|
||||
print( pcall( f, n, table.unpack(t)) )
|
||||
t[m] = m
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
all(f1)
|
||||
all(f2)
|
||||
all(f3)
|
||||
|
||||
|
||||
local function f(x)
|
||||
-- tailcall to a builtin
|
||||
return math.abs(x)
|
||||
end
|
||||
|
||||
local function factorial(i)
|
||||
local function helper(product, n)
|
||||
if n <= 0 then
|
||||
return product
|
||||
else
|
||||
-- tail call to a nested Lua function
|
||||
return helper(n * product, n - 1)
|
||||
end
|
||||
end
|
||||
return helper(1, i)
|
||||
end
|
||||
|
||||
local result1 = factorial(5)
|
||||
print(result1)
|
||||
print(factorial(5))
|
||||
|
||||
local result2 = f(-1234)
|
||||
print( result2 )
|
||||
|
||||
local function fib_bad(n)
|
||||
local function helper(i, a, b)
|
||||
if i >= n then
|
||||
return a
|
||||
else
|
||||
-- not recognized by luac as a tailcall!
|
||||
local result = helper(i + 1, b, a + b)
|
||||
return result
|
||||
end
|
||||
end
|
||||
return helper(1, 1, 1)
|
||||
end
|
||||
|
||||
local function fib_good(n)
|
||||
local function helper(i, a, b)
|
||||
if i >= n then
|
||||
return a
|
||||
else
|
||||
-- must be a tail call!
|
||||
return helper(i + 1, b, a + b)
|
||||
end
|
||||
end
|
||||
return helper(1, 1, 1)
|
||||
end
|
||||
|
||||
local aliases = {
|
||||
['1.#INF'] = 'inf',
|
||||
['-1.#INF'] = '-inf',
|
||||
['1.#IND'] = 'nan',
|
||||
['-1.#IND'] = 'nan',
|
||||
}
|
||||
|
||||
local p = function( s,e )
|
||||
print( s, e and aliases[tostring(e)] or e )
|
||||
end
|
||||
p(pcall(fib_bad, 30))
|
||||
--p((pcall(fib_bad, 25000)))
|
||||
p(pcall(fib_good, 30))
|
||||
p(pcall(fib_good, 25000))
|
||||
|
||||
local function fib_all(n, i, a, b)
|
||||
i = i or 1
|
||||
a = a or 1
|
||||
b = b or 1
|
||||
if i >= n then
|
||||
return
|
||||
else
|
||||
return a, fib_all(n, i+1, b, a+b)
|
||||
end
|
||||
end
|
||||
|
||||
print(fib_all(10))
|
||||
@@ -1,97 +0,0 @@
|
||||
|
||||
print( '-------- simple upvalues tests --------' )
|
||||
local function simpleupvalues()
|
||||
function test()
|
||||
local x = 5
|
||||
function f()
|
||||
x = x + 1
|
||||
return x
|
||||
end
|
||||
function g()
|
||||
x = x - 1
|
||||
return x
|
||||
end
|
||||
print(f())
|
||||
print(g())
|
||||
return f, g
|
||||
end
|
||||
|
||||
f1, g1 = test()
|
||||
print("f1()=", f1())
|
||||
print("g1()=", g1())
|
||||
|
||||
f2, g2 = test()
|
||||
print("f2()=", f2())
|
||||
print("g2()=", g2())
|
||||
|
||||
print("g1()=", g1())
|
||||
print("f1()=", f1())
|
||||
end
|
||||
print( 'simplevalues result:', pcall( simpleupvalues ) )
|
||||
|
||||
|
||||
-- The point of this test is that when an upvalue is created, it may
|
||||
-- need to be inserted in the middle of the list, rather than always
|
||||
-- appended at the end. Otherwise, it may not be found when it is
|
||||
-- needed by another closure.
|
||||
print( '----------- upvalued in middle ------------' )
|
||||
local function middleupvaluestest()
|
||||
local function test()
|
||||
local x = 3
|
||||
local y = 5
|
||||
local z = 7
|
||||
|
||||
local function f()
|
||||
print("y=", y)
|
||||
end
|
||||
|
||||
local function g()
|
||||
print("z=", z)
|
||||
end
|
||||
|
||||
local function h()
|
||||
print("x=", x)
|
||||
end
|
||||
|
||||
local function setter(x1, y1, z1)
|
||||
x = x1
|
||||
y = y1
|
||||
z = z1
|
||||
end
|
||||
|
||||
return f, g, h, setter
|
||||
end
|
||||
|
||||
local f, g, h, setter = test()
|
||||
|
||||
h()
|
||||
f()
|
||||
g()
|
||||
|
||||
setter("x", "y", "z")
|
||||
|
||||
h()
|
||||
f()
|
||||
g()
|
||||
end
|
||||
print( pcall( middleupvaluestest ) )
|
||||
|
||||
|
||||
print( '--------- nested upvalues ----------' )
|
||||
local function nestedupvaluestest()
|
||||
local f
|
||||
do
|
||||
local x = 10
|
||||
function g()
|
||||
print(x, f())
|
||||
end
|
||||
end
|
||||
|
||||
function f()
|
||||
return 20
|
||||
end
|
||||
|
||||
g()
|
||||
end
|
||||
print( 'nestedupvaluestest result:', pcall( nestedupvaluestest ) )
|
||||
|
||||
250
test/lua/vm.lua
250
test/lua/vm.lua
@@ -1,250 +0,0 @@
|
||||
|
||||
print( '-------- basic vm tests --------' )
|
||||
|
||||
print( '-- boolean tests' )
|
||||
local function booleantests()
|
||||
t = true
|
||||
f = false
|
||||
n = nil
|
||||
s = "Hello"
|
||||
z = 0
|
||||
one = 1
|
||||
|
||||
print(t)
|
||||
print(f)
|
||||
|
||||
print(not t)
|
||||
print(not f)
|
||||
print(not n)
|
||||
print(not z)
|
||||
print(not s)
|
||||
print(not(not(t)))
|
||||
print(not(not(z)))
|
||||
print(not(not(n)))
|
||||
|
||||
print(t and f)
|
||||
print(t or f)
|
||||
print(f and t)
|
||||
print(f or t)
|
||||
|
||||
print(f or one)
|
||||
print(f or z)
|
||||
print(f or n)
|
||||
|
||||
print(t and one)
|
||||
print(t and z)
|
||||
print(t and n)
|
||||
end
|
||||
print( 'booleantests result:', pcall( booleantests ) )
|
||||
|
||||
|
||||
print( '------------- varargs' )
|
||||
local function varargstest()
|
||||
function p(a,...)
|
||||
print("a",a)
|
||||
print("...",...)
|
||||
print("...,a",...,a)
|
||||
print("a,...",a,...)
|
||||
end
|
||||
function q(a,...)
|
||||
print("a,arg[1],arg[2],arg[3]",a,arg.n,arg[1],arg[2],arg[3])
|
||||
end
|
||||
function r(a,...)
|
||||
print("a,arg[1],arg[2],arg[3]",a,arg.n,arg[1],arg[2],arg[3])
|
||||
print("a",a)
|
||||
print("...",...)
|
||||
print("...,a",...,a)
|
||||
print("a,...",a,...)
|
||||
end
|
||||
function s(a)
|
||||
local arg = { '1', '2', '3' }
|
||||
print("a,arg[1],arg[2],arg[3]",a,arg[1],arg[2],arg[3])
|
||||
print("a",a)
|
||||
end
|
||||
function t(a,...)
|
||||
local arg = { '1', '2', '3' }
|
||||
print("a,arg[1],arg[2],arg[3]",a,arg[1],arg[2],arg[3])
|
||||
print("a",a)
|
||||
print("...",...)
|
||||
print("...,a",...,a)
|
||||
print("a,...",a,...)
|
||||
end
|
||||
function u(arg)
|
||||
print( 'arg', arg )
|
||||
end
|
||||
function v(arg,...)
|
||||
print( 'arg', arg )
|
||||
print("...",...)
|
||||
print("arg,...",arg,...)
|
||||
end
|
||||
arg = { "global-1", "global-2", "global-3" }
|
||||
function tryall(f,name)
|
||||
print( '---- function '..name..'()' )
|
||||
print( '--'..name..'():' )
|
||||
print( ' ->', pcall( f ) )
|
||||
print( '--'..name..'("q"):' )
|
||||
print( ' ->', pcall( f, "q" ) )
|
||||
print( '--'..name..'("q","r"):' )
|
||||
print( ' ->', pcall( f, "q", "r" ) )
|
||||
print( '--'..name..'("q","r","s"):' )
|
||||
print( ' ->', pcall( f, "q", "r", "s" ) )
|
||||
end
|
||||
tryall(p,'p')
|
||||
tryall(q,'q')
|
||||
tryall(r,'r')
|
||||
tryall(s,'s')
|
||||
tryall(t,'t')
|
||||
tryall(u,'u')
|
||||
tryall(v,'v')
|
||||
end
|
||||
print( 'varargstest result:', pcall( varargstest ) )
|
||||
|
||||
-- The purpose of this test case is to demonstrate that
|
||||
-- basic metatable operations on non-table types work.
|
||||
-- i.e. that s.sub(s,...) could be used in place of string.sub(s,...)
|
||||
print( '---------- metatable tests' )
|
||||
local function metatabletests()
|
||||
|
||||
-- tostring replacement that assigns ids
|
||||
local ts,id,nid,types = tostring,{},0,{table='tbl',thread='thr',userdata='uda',['function']='func'}
|
||||
tostring = function(x)
|
||||
if not x or not types[type(x)] then return ts(x) end
|
||||
if not id[x] then nid=nid+1; id[x]=types[type(x)]..'.'..nid end
|
||||
return id[x]
|
||||
end
|
||||
local results = function(s,e,...)
|
||||
if s then return e,... end
|
||||
return false,type(e)
|
||||
end
|
||||
local pcall = function(...)
|
||||
return results( pcall(...) )
|
||||
end
|
||||
|
||||
|
||||
local s = "hello"
|
||||
print(s:sub(2,4))
|
||||
|
||||
local t = {}
|
||||
function op(name,...)
|
||||
local a,b = pcall( setmetatable, t, ... )
|
||||
print( name, t, getmetatable(t), a, b )
|
||||
end
|
||||
op('set{} ',{})
|
||||
op('set-nil',nil)
|
||||
op('set{} ',{})
|
||||
op('set')
|
||||
op('set{} ',{})
|
||||
op('set{} ',{})
|
||||
op('set{}{}',{},{})
|
||||
op('set-nil',nil)
|
||||
op('set{__}',{__metatable={}})
|
||||
op('set{} ',{})
|
||||
op('set-nil',nil)
|
||||
t = {}
|
||||
op('set{} ',{})
|
||||
op('set-nil',nil)
|
||||
op('set{__}',{__metatable='abc'})
|
||||
op('set{} ',{})
|
||||
op('set-nil',nil)
|
||||
|
||||
|
||||
local i = 1234
|
||||
local t = setmetatable( {}, {
|
||||
__mode="v",
|
||||
__index=function(t,k)
|
||||
local v = i
|
||||
i = i + 1
|
||||
rawset(t,k,v)
|
||||
return v
|
||||
end,
|
||||
} )
|
||||
|
||||
local l = { 'a', 'b', 'a', 'b', 'c', 'a', 'b', 'c', 'd' }
|
||||
for i,key in ipairs(l) do
|
||||
print( 't.'..key, t[key] )
|
||||
end
|
||||
end
|
||||
print( 'metatabletests result:', pcall( metatabletests ) )
|
||||
|
||||
-- test tables with more than 50 elements
|
||||
print( '------------ huge tables' )
|
||||
local function hugetables()
|
||||
local t = { 1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,
|
||||
1,1,1,1,1,1,1,1,1,1,
|
||||
}
|
||||
print ("#t=",#t,'t[1,50,51,59]', t[1], t[50], t[51], t[59])
|
||||
print (table.concat(t,','))
|
||||
|
||||
local t2= { 0,3,4,7,9,8,12,15,23,5,
|
||||
10,13,14,17,19,18,112,115,123,15,
|
||||
20,33,24,27,29,28,212,215,223,25,
|
||||
40,43,44,47,49,48,412,415,423,45,
|
||||
50,53,54,57,59,58,512,515,523,55,
|
||||
60,63,64,67,69,68,612,615,623,65,
|
||||
70,73,74,77,79,78,72,715,723,75,
|
||||
}
|
||||
|
||||
print ("#t2=",#t2,'t[1,50,51,59]', t[1], t[50], t[51], t[59])
|
||||
print (table.concat(t2,','))
|
||||
|
||||
local t = {
|
||||
[2000]='a', [2001]='b', [2002]='c', [2003]='d', [2004]='e', [2005]='f', [2006]='g', [2007]='h', [2008]='i', [2009]='j',
|
||||
[3000]='a', [3001]='b', [3002]='c', [3003]='d', [3004]='e', [3005]='f', [3006]='g', [3007]='h', [3008]='i', [3009]='j',
|
||||
[4000]='a', [4001]='b', [4002]='c', [4003]='d', [4004]='e', [4005]='f', [4006]='g', [4007]='h', [4008]='i', [4009]='j',
|
||||
[5000]='a', [5001]='b', [5002]='c', [5003]='d', [5004]='e', [5005]='f', [5006]='g', [5007]='h', [5008]='i', [5009]='j',
|
||||
[6000]='a', [6001]='b', [6002]='c', [6003]='d', [6004]='e', [6005]='f', [6006]='g', [6007]='h', [6008]='i', [6009]='j',
|
||||
[7000]='a', [7001]='b', [7002]='c', [7003]='d', [7004]='e', [7005]='f', [7006]='g', [7007]='h', [7008]='i', [7009]='j',
|
||||
[8000]='a', [8001]='b', [8002]='c', [8003]='d', [8004]='e', [8005]='f', [8006]='g', [8007]='h', [8008]='i', [8009]='j',
|
||||
}
|
||||
|
||||
for i=2000,8000,1000 do
|
||||
for j=0,9,1 do
|
||||
print( 't['..tostring(i+j)..']', t[i+j] )
|
||||
end
|
||||
end
|
||||
end
|
||||
print( 'hugetables result:', pcall( hugetables ) )
|
||||
|
||||
print( '--------- many locals' )
|
||||
local function manylocals()
|
||||
-- test program with more than 50 non-sequential integer elements
|
||||
local t0000='a'; local t0001='b'; local t0002='c'; local t0003='d'; local t0004='e'; local t0005='f'; local t0006='g'; local t0007='h'; local t0008='i'; local t0009='j';
|
||||
local t1000='a'; local t1001='b'; local t1002='c'; local t1003='d'; local t1004='e'; local t1005='f'; local t1006='g'; local t1007='h'; local t1008='i'; local t1009='j';
|
||||
local t2000='a'; local t2001='b'; local t2002='c'; local t2003='d'; local t2004='e'; local t2005='f'; local t2006='g'; local t2007='h'; local t2008='i'; local t2009='j';
|
||||
local t3000='a'; local t3001='b'; local t3002='c'; local t3003='d'; local t3004='e'; local t3005='f'; local t3006='g'; local t3007='h'; local t3008='i'; local t3009='j';
|
||||
local t4000='a'; local t4001='b'; local t4002='c'; local t4003='d'; local t4004='e'; local t4005='f'; local t4006='g'; local t4007='h'; local t4008='i'; local t4009='j';
|
||||
local t5000='a'; local t5001='b'; local t5002='c'; local t5003='d'; local t5004='e'; local t5005='f'; local t5006='g'; local t5007='h'; local t5008='i'; local t5009='j';
|
||||
local t6000='a'; local t6001='b'; local t6002='c'; local t6003='d'; local t6004='e'; local t6005='f'; local t6006='g'; local t6007='h'; local t6008='i'; local t6009='j';
|
||||
local t7000='a'; local t7001='b'; local t7002='c'; local t7003='d'; local t7004='e'; local t7005='f'; local t7006='g'; local t7007='h'; local t7008='i'; local t7009='j';
|
||||
local t8000='a'; local t8001='b'; local t8002='c'; local t8003='d'; local t8004='e'; local t8005='f'; local t8006='g'; local t8007='h'; local t8008='i'; local t8009='j';
|
||||
local t9000='a'; local t9001='b'; local t9002='c'; local t9003='d'; local t9004='e'; local t9005='f'; local t9006='g'; local t9007='h'; local t9008='i'; local t9009='j';
|
||||
local t10000='a'; local t10001='b'; local t10002='c'; local t10003='d'; local t10004='e'; local t10005='f'; local t10006='g'; local t10007='h'; local t10008='i'; local t10009='j';
|
||||
local t11000='a'; local t11001='b'; local t11002='c'; local t11003='d'; local t11004='e'; local t11005='f'; local t11006='g'; local t11007='h'; local t11008='i'; local t11009='j';
|
||||
local t12000='a'; local t12001='b'; local t12002='c'; local t12003='d'; local t12004='e'; local t12005='f'; local t12006='g'; local t12007='h'; local t12008='i'; local t12009='j';
|
||||
local t13000='a'; local t13001='b'; local t13002='c'; local t13003='d'; local t13004='e'; local t13005='f'; local t13006='g'; local t13007='h'; local t13008='i'; local t13009='j';
|
||||
|
||||
-- print the variables
|
||||
print(t0000,'a'); print(t0001,'b'); print(t0002,'c'); print(t0003,'d'); print(t0004,'e'); print(t0005,'f'); print(t0006,'g'); print(t0007,'h'); print(t0008,'i'); print(t0009,'j');
|
||||
print(t1000,'a'); print(t1001,'b'); print(t1002,'c'); print(t1003,'d'); print(t1004,'e'); print(t1005,'f'); print(t1006,'g'); print(t1007,'h'); print(t1008,'i'); print(t1009,'j');
|
||||
print(t2000,'a'); print(t2001,'b'); print(t2002,'c'); print(t2003,'d'); print(t2004,'e'); print(t2005,'f'); print(t2006,'g'); print(t2007,'h'); print(t2008,'i'); print(t2009,'j');
|
||||
print(t3000,'a'); print(t3001,'b'); print(t3002,'c'); print(t3003,'d'); print(t3004,'e'); print(t3005,'f'); print(t3006,'g'); print(t3007,'h'); print(t3008,'i'); print(t3009,'j');
|
||||
print(t4000,'a'); print(t4001,'b'); print(t4002,'c'); print(t4003,'d'); print(t4004,'e'); print(t4005,'f'); print(t4006,'g'); print(t4007,'h'); print(t4008,'i'); print(t4009,'j');
|
||||
print(t5000,'a'); print(t5001,'b'); print(t5002,'c'); print(t5003,'d'); print(t5004,'e'); print(t5005,'f'); print(t5006,'g'); print(t5007,'h'); print(t5008,'i'); print(t5009,'j');
|
||||
print(t6000,'a'); print(t6001,'b'); print(t6002,'c'); print(t6003,'d'); print(t6004,'e'); print(t6005,'f'); print(t6006,'g'); print(t6007,'h'); print(t6008,'i'); print(t6009,'j');
|
||||
print(t7000,'a'); print(t7001,'b'); print(t7002,'c'); print(t7003,'d'); print(t7004,'e'); print(t7005,'f'); print(t7006,'g'); print(t7007,'h'); print(t7008,'i'); print(t7009,'j');
|
||||
print(t8000,'a'); print(t8001,'b'); print(t8002,'c'); print(t8003,'d'); print(t8004,'e'); print(t8005,'f'); print(t8006,'g'); print(t8007,'h'); print(t8008,'i'); print(t8009,'j');
|
||||
print(t9000,'a'); print(t9001,'b'); print(t9002,'c'); print(t9003,'d'); print(t9004,'e'); print(t9005,'f'); print(t9006,'g'); print(t9007,'h'); print(t9008,'i'); print(t9009,'j');
|
||||
print(t10000,'a'); print(t10001,'b'); print(t10002,'c'); print(t10003,'d'); print(t10004,'e'); print(t10005,'f'); print(t10006,'g'); print(t10007,'h'); print(t10008,'i'); print(t10009,'j');
|
||||
print(t11000,'a'); print(t11001,'b'); print(t11002,'c'); print(t11003,'d'); print(t11004,'e'); print(t11005,'f'); print(t11006,'g'); print(t11007,'h'); print(t11008,'i'); print(t11009,'j');
|
||||
print(t12000,'a'); print(t12001,'b'); print(t12002,'c'); print(t12003,'d'); print(t12004,'e'); print(t12005,'f'); print(t12006,'g'); print(t12007,'h'); print(t12008,'i'); print(t12009,'j');
|
||||
print(t13000,'a'); print(t13001,'b'); print(t13002,'c'); print(t13003,'d'); print(t13004,'e'); print(t13005,'f'); print(t13006,'g'); print(t13007,'h'); print(t13008,'i'); print(t13009,'j');
|
||||
end
|
||||
print( 'manylocals result:', pcall( manylocals ) )
|
||||
Reference in New Issue
Block a user