From 443df4af85ec8b1b859a85c46cbb8d3790b54aab Mon Sep 17 00:00:00 2001 From: Joni Orponen Date: Wed, 28 Dec 2022 22:59:10 +0100 Subject: [PATCH] Remove the remnants of the lua unit tests. --- utils/eris_tests/persist.lua | 509 ----------- utils/eris_tests/unpersist.lua | 102 --- utils/lua_tests/all.lua | 259 ------ utils/lua_tests/api.lua | 1009 --------------------- utils/lua_tests/attrib.lua | 421 --------- utils/lua_tests/big.lua | 79 -- utils/lua_tests/bitwise.lua | 115 --- utils/lua_tests/calls.lua | 310 ------- utils/lua_tests/checktable.lua | 77 -- utils/lua_tests/closure.lua | 244 ----- utils/lua_tests/code.lua | 182 ---- utils/lua_tests/constructs.lua | 310 ------- utils/lua_tests/coroutine.lua | 728 --------------- utils/lua_tests/db.lua | 631 ------------- utils/lua_tests/errors.lua | 422 --------- utils/lua_tests/events.lua | 388 -------- utils/lua_tests/files.lua | 615 ------------- utils/lua_tests/gc.lua | 575 ------------ utils/lua_tests/goto.lua | 173 ---- utils/lua_tests/libs/lib1.c | 49 - utils/lua_tests/libs/lib11.c | 18 - utils/lua_tests/libs/lib2.c | 29 - utils/lua_tests/libs/lib21.c | 18 - utils/lua_tests/libs/makefile | 26 - utils/lua_tests/literals.lua | 258 ------ utils/lua_tests/locals.lua | 157 ---- utils/lua_tests/ltests/ltests.c | 1506 ------------------------------- utils/lua_tests/ltests/ltests.h | 93 -- utils/lua_tests/main.lua | 260 ------ utils/lua_tests/math.lua | 287 ------ utils/lua_tests/nextvar.lua | 461 ---------- utils/lua_tests/pm.lua | 344 ------- utils/lua_tests/sort.lua | 167 ---- utils/lua_tests/strings.lua | 281 ------ utils/lua_tests/vararg.lua | 125 --- utils/lua_tests/verybig.lua | 144 --- 36 files changed, 11372 deletions(-) delete mode 100644 utils/eris_tests/persist.lua delete mode 100644 utils/eris_tests/unpersist.lua delete mode 100644 utils/lua_tests/all.lua delete mode 100644 utils/lua_tests/api.lua delete mode 100644 utils/lua_tests/attrib.lua delete mode 100644 utils/lua_tests/big.lua delete mode 100644 utils/lua_tests/bitwise.lua delete mode 100644 utils/lua_tests/calls.lua delete mode 100644 utils/lua_tests/checktable.lua delete mode 100644 utils/lua_tests/closure.lua delete mode 100644 utils/lua_tests/code.lua delete mode 100644 utils/lua_tests/constructs.lua delete mode 100644 utils/lua_tests/coroutine.lua delete mode 100644 utils/lua_tests/db.lua delete mode 100644 utils/lua_tests/errors.lua delete mode 100644 utils/lua_tests/events.lua delete mode 100644 utils/lua_tests/files.lua delete mode 100644 utils/lua_tests/gc.lua delete mode 100644 utils/lua_tests/goto.lua delete mode 100644 utils/lua_tests/libs/lib1.c delete mode 100644 utils/lua_tests/libs/lib11.c delete mode 100644 utils/lua_tests/libs/lib2.c delete mode 100644 utils/lua_tests/libs/lib21.c delete mode 100644 utils/lua_tests/libs/makefile delete mode 100644 utils/lua_tests/literals.lua delete mode 100644 utils/lua_tests/locals.lua delete mode 100644 utils/lua_tests/ltests/ltests.c delete mode 100644 utils/lua_tests/ltests/ltests.h delete mode 100644 utils/lua_tests/main.lua delete mode 100644 utils/lua_tests/math.lua delete mode 100644 utils/lua_tests/nextvar.lua delete mode 100644 utils/lua_tests/pm.lua delete mode 100644 utils/lua_tests/sort.lua delete mode 100644 utils/lua_tests/strings.lua delete mode 100644 utils/lua_tests/vararg.lua delete mode 100644 utils/lua_tests/verybig.lua diff --git a/utils/eris_tests/persist.lua b/utils/eris_tests/persist.lua deleted file mode 100644 index df4a76421..000000000 --- a/utils/eris_tests/persist.lua +++ /dev/null @@ -1,509 +0,0 @@ -local rootobj = {} - -------------------------------------------------------------------------------- --- Used by C callbacks, so let's define it first. - -function booleanpersist(udata) - local b = unboxboolean(udata) - return function() - return boxboolean(b) - end -end - -------------------------------------------------------------------------------- --- Permanent values. - -local permtable = { 1234 } - -rootobj.testperm = permtable - -------------------------------------------------------------------------------- --- Basic value types. - -rootobj.testnil = nil -rootobj.testfalse = false -rootobj.testtrue = true -rootobj.testludata = createludata() -rootobj.testseven = 7 -rootobj.testfoobar = "foobar" - -------------------------------------------------------------------------------- --- Tables. - -local testtbl = { a = 2, [2] = 4 } - -rootobj.testtbl = testtbl - -------------------------------------------------------------------------------- --- NaNs in tables (checks that this doesn't break the internal ref table). - -local nantable = {} -nantable[1] = 0/0 - -rootobj.testnan = nantable - -------------------------------------------------------------------------------- --- Cycles in tables. - -local testloopa = {} -local testloopb = { testloopa = testloopa } -testloopa.testloopb = testloopb - -rootobj.testlooptable = testloopa - -------------------------------------------------------------------------------- --- Metatables. - -local twithmt = {} -setmetatable( twithmt, { __call = function() return 21 end } ) - -rootobj.testmt = twithmt - -------------------------------------------------------------------------------- --- Yet more metatables. - -local niinmt = { a = 3 } -setmetatable(niinmt, {__newindex = function(key, val) end }) - -rootobj.testniinmt = niinmt - -------------------------------------------------------------------------------- --- Literal userdata. - -local literaludata = boxinteger(71) - -rootobj.testliteraludata = literaludata - -------------------------------------------------------------------------------- --- Functions (closures without upvalues). - -local function func() - return 4 -end - -rootobj.testfuncreturnsfour = func - -------------------------------------------------------------------------------- --- Environment. This is really redundant in 5.2 since envs are just upvalues, --- but it may still be considered somewhat special. -local testfenv = (function() - local _ENV = { abc = 456 } - return function() - return abc - end -end)() - -rootobj.testfenv = testfenv - -------------------------------------------------------------------------------- --- Closures. - -local function funcreturningclosure(n) - return function() - return n - end -end - -rootobj.testclosure = funcreturningclosure(11) -rootobj.testnilclosure = funcreturningclosure(nil) - -------------------------------------------------------------------------------- --- More closures. - -local function nestedfunc(n) - return (function(m) return m+2 end)(n+3) -end - -rootobj.testnest = nestedfunc - -------------------------------------------------------------------------------- --- Cycles in upvalues. - -local function GenerateObjects() - local Table = {} - - function Table:Func() - return { Table, self } - end - - function uvcycle() - return Table:Func() - end -end - -GenerateObjects() - -rootobj.testuvcycle = uvcycle - -------------------------------------------------------------------------------- --- Special callback for persisting tables. - -local sptable = { a = 3 } - -setmetatable(sptable, { - __persist = function(tbl) - local a = tbl.a - return function() - return { a = a+3 } - end - end -}) - -rootobj.testsptable = sptable - -------------------------------------------------------------------------------- --- Special callbacks for persisting userdata. - -rootobj.testspudata1 = boxboolean(true) -rootobj.testspudata2 = boxboolean(false) - -------------------------------------------------------------------------------- --- Reference correctness. - -local sharedref = {} -refa = {sharedref = sharedref} -refb = {sharedref = sharedref} - -rootobj.testsharedrefa = refa -rootobj.testsharedrefb = refb - -------------------------------------------------------------------------------- --- Shared upvalues (like reference correctness for upvalues). - -local function makecounter() - local a = 0 - return { - inc = function() a = a + 1 end, - cur = function() return a end - } -end - -rootobj.testsharedupval = makecounter() - -------------------------------------------------------------------------------- --- Debug info. - -local function debuginfo(foo) - foo = foo + foo - return debug.getlocal(1,1) -end - -rootobj.testdebuginfo = debuginfo - -------------------------------------------------------------------------------- --- Suspended thread. - -local function fc(i) - local ic = i + 1 - coroutine.yield() - return ic*2 -end - -local function fb(i) - local ib = i + 1 - ib = ib + fc(ib) - return ib -end - -local function fa(i) - local ia = i + 1 - return fb(ia) -end - -local thr = coroutine.create(fa) -coroutine.resume(thr, 2) - -rootobj.testthread = thr - -------------------------------------------------------------------------------- --- Not yet started thread. - -rootobj.testnthread = coroutine.create(function() return func() end) - -------------------------------------------------------------------------------- --- Dead thread. - -local deadthr = coroutine.create(function() return func() end) -coroutine.resume(deadthr) - -rootobj.testdthread = deadthr - -------------------------------------------------------------------------------- --- Open upvalues (stored in thread stack). - -local function uvinthreadfunc() - local a = 1 - local b = function() - a = a+1 - coroutine.yield(a) - a = a+1 - end - a = a+1 - b() - a = a+1 - return a -end - -local uvinthread = coroutine.create(uvinthreadfunc) -coroutine.resume(uvinthread) - -rootobj.testuvinthread = uvinthread - -------------------------------------------------------------------------------- --- Yield across pcall. - -local function protf(arg) - coroutine.yield() - error(arg, 0) -end -local function protthreadfunc() - local res, err = pcall(protf, "test") - return err -end - -local protthr = coroutine.create(protthreadfunc) -coroutine.resume(protthr) - -rootobj.testprotthr = protthr - -------------------------------------------------------------------------------- --- Yield across xpcall with message handler. - -local function xprotthreadfunc() - local function handler(msg) - return "handler:" .. msg - end - local res, err = xpcall(protf, handler, "test") - return err -end - -local xprotthr = coroutine.create(xprotthreadfunc) -coroutine.resume(xprotthr) - -rootobj.testxprotthr = xprotthr - -------------------------------------------------------------------------------- --- Yield out of metafunction. - -local function ymtf(arg) - coroutine.yield() - return true -end -function ymtthreadfunc() - local t = setmetatable({}, {__lt = ymtf}) - return t < 5 -end - -local ymtthr = coroutine.create(ymtthreadfunc) -coroutine.resume(ymtthr) - -rootobj.testymtthr = ymtthr - -------------------------------------------------------------------------------- - --- I considered supporting the hook callback from the debug library, but then --- Eris would also have to persist the registry table the debug library uses, --- and things go quickly out of hand that way, so I decided against that. ---[[ -function hookthrfunc() - local hookRan = false - local function callback() - print("hook!") - hookRan = true - end - debug.sethook(callback, "", 100000) - coroutine.yield("yielded") - for i = 1, 10000000 do - if hookRan then break end - end - return hookRan -end - -hookthr = coroutine.create(hookthrfunc) -print(coroutine.resume(hookthr)) - -rootobj.testhookthr = hookthr -]] - -------------------------------------------------------------------------------- --- Deep callstacks (100 levels). - -local function deepfunc(x) - x = x or 0 - if x == 100 then - coroutine.yield() - return x - end - local result = deepfunc(x + 1) -- no tailcall - return result -end - -local deepcall = coroutine.wrap(deepfunc) -deepcall() - -rootobj.testdeep = deepcall - -------------------------------------------------------------------------------- --- Tail calls. - -local function tailfunc() - local function tailer(x) - x = x or 0 - if x == 100 then - coroutine.yield() - return x - end - return tailer(x + 1) - end - local result = tailer() - return result -end - -function wrap(t) - local co = coroutine.create(t) - return function(...) - local res = {coroutine.resume(co, ...)} - if res[1] then return select(2, table.unpack(res)) end - error(select(2, table.unpack(res)), 0) - end -end - -local tailcall = wrap(tailfunc) -tailcall() - -rootobj.testtail = tailcall - -------------------------------------------------------------------------------- --- From the Lua test cases, as a more complex piece of code. Since this is --- easier to verify visually it spams the output quite a bit, so it's disabled --- per default. - ---[[ -local lifethr = coroutine.create(function() - local _ENV = { write = coroutine.yield } - - -- life.lua - -- original by Dave Bollinger posted to lua-l - -- modified to use ANSI terminal escape sequences - -- modified to use for instead of while - -- modified for this test - - ALIVE="Â¥" DEAD="þ" - ALIVE="O" DEAD="-" - - function ARRAY2D(w,h) - local t = {w=w,h=h} - for y=1,h do - t[y] = {} - for x=1,w do - t[y][x]=0 - end - end - return t - end - - _CELLS = {} - - -- give birth to a "shape" within the cell array - function _CELLS:spawn(shape,left,top) - for y=0,shape.h-1 do - for x=0,shape.w-1 do - self[top+y][left+x] = shape[y*shape.w+x+1] - end - end - end - - -- run the CA and produce the next generation - function _CELLS:evolve(next) - local ym1,y,yp1,yi=self.h-1,self.h,1,self.h - while yi > 0 do - local xm1,x,xp1,xi=self.w-1,self.w,1,self.w - while xi > 0 do - local sum = self[ym1][xm1] + self[ym1][x] + self[ym1][xp1] + - self[y][xm1] + self[y][xp1] + - self[yp1][xm1] + self[yp1][x] + self[yp1][xp1] - next[y][x] = ((sum==2) and self[y][x]) or ((sum==3) and 1) or 0 - xm1,x,xp1,xi = x,xp1,xp1+1,xi-1 - end - ym1,y,yp1,yi = y,yp1,yp1+1,yi-1 - end - end - - -- output the array to screen - function _CELLS:draw() - local out="" -- accumulate to reduce flicker - for y=1,self.h do - for x=1,self.w do - out=out..(((self[y][x]>0) and ALIVE) or DEAD) - end - out=out.."\n" - end - write(out) - end - - -- constructor - function CELLS(w,h) - local c = ARRAY2D(w,h) - c.spawn = _CELLS.spawn - c.evolve = _CELLS.evolve - c.draw = _CELLS.draw - return c - end - - -- - -- shapes suitable for use with spawn() above - -- - HEART = { 1,0,1,1,0,1,1,1,1; w=3,h=3 } - GLIDER = { 0,0,1,1,0,1,0,1,1; w=3,h=3 } - EXPLODE = { 0,1,0,1,1,1,1,0,1,0,1,0; w=3,h=4 } - FISH = { 0,1,1,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,1,0; w=5,h=4 } - BUTTERFLY = { 1,0,0,0,1,0,1,1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,0,0,1; w=5,h=5 } - - -- the main routine - function LIFE(w,h) - -- create two arrays - local thisgen = CELLS(w,h) - local nextgen = CELLS(w,h) - - -- create some life - -- about 1000 generations of fun, then a glider steady-state - thisgen:spawn(GLIDER,5,4) - thisgen:spawn(EXPLODE,25,10) - thisgen:spawn(FISH,4,12) - - -- run until break - local gen=1 - while 1 do - thisgen:evolve(nextgen) - thisgen,nextgen = nextgen,thisgen - thisgen:draw() - gen=gen+1 - if gen>2000 then break end - end - end - - LIFE(40,20) -end) -print(select(2, coroutine.resume(lifethr))) -print(select(2, coroutine.resume(lifethr))) - -rootobj.testlife = lifethr ---]] -------------------------------------------------------------------------------- --- Do actual persisting with some perms. - -perms = { - [_ENV] = "_ENV", - [coroutine.yield] = 1, - [permtable] = 2, - [pcall] = 3, - [xpcall] = 4, -} -buf = eris.persist(perms, rootobj) - -------------------------------------------------------------------------------- --- Write to file. - -outfile = io.open(..., "wb") -outfile:write(buf) -outfile:close() \ No newline at end of file diff --git a/utils/eris_tests/unpersist.lua b/utils/eris_tests/unpersist.lua deleted file mode 100644 index 1124f9670..000000000 --- a/utils/eris_tests/unpersist.lua +++ /dev/null @@ -1,102 +0,0 @@ -permtable = { 1234 } - -function testcounter(counter) - local a = counter.cur() - counter.inc() - return counter.cur() == a + 1 -end - -function testuvinthread(func) - local success, result = coroutine.resume(func) - return success and result == 5 -end - -function test(rootobj) - local passed = 0 - local total = 0 - local dotest = function(name, cond) - total = total + 1 - if cond then - print(name, " PASSED") - passed = passed + 1 - else - print(name, "*FAILED") - end - end - - dotest("Permanent value ", rootobj.testperm == permtable) - dotest("Nil value ", rootobj.testnil == nil) - dotest("Boolean FALSE ", rootobj.testfalse == false) - dotest("Boolean TRUE ", rootobj.testtrue == true) - dotest("Light userdata ", checkludata(rootobj.testludata)) - dotest("Number 7 ", rootobj.testseven == 7) - dotest("String 'foobar' ", rootobj.testfoobar == "foobar") - dotest("Table ", rootobj.testtbl.a == 2 and rootobj.testtbl[2] == 4) - dotest("NaN value ", rootobj.testnan[1] ~= rootobj.testnan[1]) - dotest("Looped tables ", rootobj.testlooptable.testloopb.testloopa == rootobj.testlooptable) - dotest("Table metatable ", rootobj.testmt() == 21) - dotest("__newindex metamethod ", rootobj.testniinmt.a == 3) - dotest("Udata literal persist ", unboxinteger(rootobj.testliteraludata) == 71) - dotest("Func returning 4 ", rootobj.testfuncreturnsfour() == 4) - dotest("Lua closure ", rootobj.testclosure() == 11) - dotest("Function env ", rootobj.testfenv() == 456) - dotest("Nil in closure ", rootobj.testnilclosure() == nil) - dotest("Nested func ", rootobj.testnest(1) == 6) - dotest("Upvalue cycles ", rootobj.testuvcycle()[1] == rootobj.testuvcycle()[2]) - dotest("Table special persist ", rootobj.testsptable.a == 6) - dotest("Udata special persist ", unboxboolean(rootobj.testspudata1) == true and unboxboolean(rootobj.testspudata2) == false) - dotest("Identical tables ", rootobj.testsharedrefa ~= rootobj.testsharedrefb) - dotest("Shared reference ", rootobj.testsharedrefa.sharedref == rootobj.testsharedrefb.sharedref) - dotest("Shared upvalues ", testcounter(rootobj.testsharedupval)) - dotest("Debug info ", (rootobj.testdebuginfo(2)) == "foo") - dotest("Thread start ", coroutine.resume(rootobj.testnthread) == true, 4) - dotest("Thread resume ", coroutine.resume(rootobj.testthread) == true, 14) - dotest("Thread dead ", coroutine.resume(rootobj.testdthread) == false) - dotest("Open upvalues ", testuvinthread(rootobj.testuvinthread)) - dotest("Yielded pcall ", coroutine.resume(rootobj.testprotthr) == true, "test") - dotest("Yielded xpcall ", coroutine.resume(rootobj.testxprotthr) == true, "handler:test") - dotest("Yielded metafunc ", coroutine.resume(rootobj.testymtthr) == true, true) - dotest("Deep callstack ", rootobj.testdeep() == 100) - dotest("Tail call ", rootobj.testtail() == 100) - - print() - if passed == total then - print("All tests passed.") - else - print(passed .. "/" .. total .. " tests passed.") - end - - if rootobj.testlife then - print(select(2, coroutine.resume(rootobj.testlife))) - print(select(2, coroutine.resume(rootobj.testlife))) - end -end - -------------------------------------------------------------------------------- - -infile, err = io.open(..., "rb") -if infile == nil then - error("While opening: " .. (err or "unknown error")) -end - -buf, err = infile:read("*a") -if buf == nil then - error("While reading: " .. (err or "unknown error")) -end - -infile:close() - -------------------------------------------------------------------------------- - -uperms = { - _ENV = _ENV, - [1] = coroutine.yield, - [2] = permtable, - [3] = pcall, - [4] = xpcall, -} -rootobj = eris.unpersist(uperms, buf) - -test(rootobj) - -os.remove(...) \ No newline at end of file diff --git a/utils/lua_tests/all.lua b/utils/lua_tests/all.lua deleted file mode 100644 index 3a49fd18d..000000000 --- a/utils/lua_tests/all.lua +++ /dev/null @@ -1,259 +0,0 @@ -#!../lua - -local version = "Lua 5.2" ---if _VERSION ~= version then --- io.stderr:write("\nThis test suite is for ", version, ", not for ", _VERSION, --- "\nExiting tests\n") --- return ---end - - --- next variables control the execution of some tests --- true means no test (so an undefined variable does not skip a test) --- defaults are for Linux; test everything - -_soft = false -- true to avoid long or memory consuming tests -_port = false -- true to avoid non-portable tests -_no32 = false -- true to avoid tests that assume 32 bits -_nomsg = false -- true to avoid messages about tests not performed -_noposix = false -- false assumes LUA_USE_POSIX -_nolonglong = false -- false assumes LUA_USE_LONGLONG -_noformatA = false -- false assumes LUA_USE_AFORMAT - - -local usertests = rawget(_G, "_U") - -if usertests then - -- tests for sissies ;) Avoid problems - --_soft = true - _port = true - _no32 = true - _nomsg = true - _noposix = true - _nolonglong = true - _noformatA = true; -end - --- no "internal" tests for user tests -if usertests then T = nil end - -T = rawget(_G, "T") -- avoid problems with 'strict' module - -package.path = "?;./?.lua" .. package.path - -math.randomseed(0) - -collectgarbage("setstepmul", 200) -collectgarbage("setpause", 200) - - ---[=[ - example of a long [comment], - [[spanning several [lines]]] - -]=] - -print("current path:\n****" .. package.path .. "****\n") - - -local c = os.clock() - -local collectgarbage = collectgarbage - -do -- ( - --- track messages for tests not performed -local msgs = {} -function Message (m) - if not _nomsg then - print(m) - msgs[#msgs+1] = string.sub(m, 3, -3) - end -end - -assert(os.setlocale"C") - -local T,print,format,write,assert,type,unpack,floor = - T,print,string.format,io.write,assert,type,table.unpack,math.floor - --- use K for 1000 and M for 1000000 (not 2^10 -- 2^20) -local function F (m) - local function round (m) - m = m + 0.04999 - return m - (m % 0.1) -- keep one decimal digit - end - if m < 1000 then return m - else - m = m / 1000 - if m < 1000 then return round(m).."K" - else - return round(m/1000).."M" - end - end -end - -local showmem -if not T then - local max = 0 - showmem = function () - local m = collectgarbage("count") * 1024 - max = (m > max) and m or max - print(format(" ---- total memory: %s, max memory: %s ----\n", - F(m), F(max))) - end -else - showmem = function () - T.checkmemory() - local total, numblocks, maxmem = T.totalmem() - local count = collectgarbage("count") - print(format( - "\n ---- total memory: %s (%.0fK), max use: %s, blocks: %d\n", - F(total), count, F(maxmem), numblocks)) - print(format("\t(strings: %d, tables: %d, functions: %d, ".. - "\n\tudata: %d, threads: %d)", - T.totalmem"string", T.totalmem"table", T.totalmem"function", - T.totalmem"userdata", T.totalmem"thread")) - end -end - - --- --- redefine dofile to run files through dump/undump --- -local function report (n) print("\n***** FILE '"..n.."'*****") end -local olddofile = dofile -dofile = function (n) - showmem() - report(n) - local f = assert(loadfile(n)) - local b = string.dump(f) - f = assert(load(b)) - return f() -end - -dofile('main.lua') - -do - local next, setmetatable, stderr = next, setmetatable, io.stderr - local mt = {} - -- each time a table is collected, create a new one to be - -- collected next cycle - mt.__gc = function (o) - stderr:write'.' -- mark progress - local n = setmetatable({}, mt) -- replicate object - o = nil - local a,b,c,d,e = nil -- erase 'o' from the stack - end - local n = setmetatable({}, mt) -- replicate object -end - -report"gc.lua" -local f = assert(loadfile('gc.lua')) -f() - -collectgarbage("generational") -dofile('db.lua') -assert(dofile('calls.lua') == deep and deep) -olddofile('strings.lua') -olddofile('literals.lua') -assert(dofile('attrib.lua') == 27) - -collectgarbage("incremental") -- redo some tests in incremental mode -olddofile('strings.lua') -olddofile('literals.lua') -dofile('constructs.lua') -dofile('api.lua') - -collectgarbage("generational") -- back to generational mode -collectgarbage("setpause", 200) -collectgarbage("setmajorinc", 500) -assert(dofile('locals.lua') == 5) -dofile('constructs.lua') -dofile('code.lua') -if not _G._soft then - report('big.lua') - local f = coroutine.wrap(assert(loadfile('big.lua'))) - assert(f() == 'b') - assert(f() == 'a') -end -dofile('nextvar.lua') -dofile('pm.lua') -dofile('api.lua') -assert(dofile('events.lua') == 12) -dofile('vararg.lua') -dofile('closure.lua') -dofile('coroutine.lua') -dofile('goto.lua') -dofile('errors.lua') -dofile('math.lua') -dofile('sort.lua') -dofile('bitwise.lua') -assert(dofile('verybig.lua') == 10); collectgarbage() -dofile('files.lua') - -if #msgs > 0 then - print("\ntests not performed:") - for i=1,#msgs do - print(msgs[i]) - end - print() -end - -print("final OK !!!") - -local debug = require "debug" - -debug.sethook(function (a) assert(type(a) == 'string') end, "cr") - --- to survive outside block -_G.showmem = showmem - -end --) - -local _G, showmem, print, format, clock, assert, open = - _G, showmem, print, string.format, os.clock, assert, io.open - --- file with time of last performed test -local fname = T and "time-debug.txt" or "time.txt" -local lasttime - -if not usertests then - -- open file with time of last performed test - local f = io.open(fname) - if f then - lasttime = assert(tonumber(f:read'*a')) - f:close(); - else -- no such file; assume it is recording time for first time - lasttime = nil - end -end - --- erase (almost) all globals -print('cleaning all!!!!') -for n in pairs(_G) do - if not ({___Glob = 1, tostring = 1})[n] then - _G[n] = nil - end -end - - -collectgarbage() -collectgarbage() -collectgarbage() -collectgarbage() -collectgarbage() -collectgarbage();showmem() - -local time = clock() - c - -print(format("\n\ntotal time: %.2f\n", time)) - -if not usertests then - lasttime = lasttime or time -- if there is no last time, ignore difference - -- check whether current test time differs more than 5% from last time - local diff = (time - lasttime) / time - local tolerance = 0.05 -- 5% - assert(diff < tolerance and diff > -tolerance) - assert(open(fname, "w")):write(time):close() -end - diff --git a/utils/lua_tests/api.lua b/utils/lua_tests/api.lua deleted file mode 100644 index a367fc8f0..000000000 --- a/utils/lua_tests/api.lua +++ /dev/null @@ -1,1009 +0,0 @@ - -if T==nil then - (Message or print)('\a\n >>> testC not active: skipping API tests <<<\n\a') - return -end - -local debug = require "debug" - -local pack = table.pack - - -function tcheck (t1, t2) - assert(t1.n == (t2.n or #t2) + 1) - for i = 2, t1.n do assert(t1[i] == t2[i - 1]) end -end - - -print('testing C API') - -a = T.testC("pushvalue R; return 1") -assert(a == debug.getregistry()) - - --- absindex -assert(T.testC("settop 10; absindex -1; return 1") == 10) -assert(T.testC("settop 5; absindex -5; return 1") == 1) -assert(T.testC("settop 10; absindex 1; return 1") == 1) -assert(T.testC("settop 10; absindex R; return 1") < -10) - --- testing allignment -a = T.d2s(12458954321123) -assert(string.len(a) == 8) -- sizeof(double) -assert(T.s2d(a) == 12458954321123) - -a,b,c = T.testC("pushnum 1; pushnum 2; pushnum 3; return 2") -assert(a == 2 and b == 3 and not c) - -f = T.makeCfunc("pushnum 1; pushnum 2; pushnum 3; return 2") -a,b,c = f() -assert(a == 2 and b == 3 and not c) - --- test that all trues are equal -a,b,c = T.testC("pushbool 1; pushbool 2; pushbool 0; return 3") -assert(a == b and a == true and c == false) -a,b,c = T.testC"pushbool 0; pushbool 10; pushnil;\ - tobool -3; tobool -3; tobool -3; return 3" -assert(a==false and b==true and c==false) - - -a,b,c = T.testC("gettop; return 2", 10, 20, 30, 40) -assert(a == 40 and b == 5 and not c) - -t = pack(T.testC("settop 5; gettop; return .", 2, 3)) -tcheck(t, {n=4,2,3}) - -t = pack(T.testC("settop 0; settop 15; return 10", 3, 1, 23)) -assert(t.n == 10 and t[1] == nil and t[10] == nil) - -t = pack(T.testC("remove -2; gettop; return .", 2, 3, 4)) -tcheck(t, {n=2,2,4}) - -t = pack(T.testC("insert -1; gettop; return .", 2, 3)) -tcheck(t, {n=2,2,3}) - -t = pack(T.testC("insert 3; gettop; return .", 2, 3, 4, 5)) -tcheck(t, {n=4,2,5,3,4}) - -t = pack(T.testC("replace 2; gettop; return .", 2, 3, 4, 5)) -tcheck(t, {n=3,5,3,4}) - -t = pack(T.testC("replace -2; gettop; return .", 2, 3, 4, 5)) -tcheck(t, {n=3,2,3,5}) - -t = pack(T.testC("remove 3; gettop; return .", 2, 3, 4, 5)) -tcheck(t, {n=3,2,4,5}) - -t = pack(T.testC("copy 3 4; gettop; return .", 2, 3, 4, 5)) -tcheck(t, {n=4,2,3,3,5}) - -t = pack(T.testC("copy -3 -1; gettop; return .", 2, 3, 4, 5)) -tcheck(t, {n=4,2,3,4,3}) - - - - -t = pack(T.testC("insert 3; pushvalue 3; remove 3; pushvalue 2; remove 2; \ - insert 2; pushvalue 1; remove 1; insert 1; \ - insert -2; pushvalue -2; remove -3; gettop; return .", - 2, 3, 4, 5, 10, 40, 90)) -tcheck(t, {n=7,2,3,4,5,10,40,90}) - -t = pack(T.testC("concat 5; gettop; return .", "alo", 2, 3, "joao", 12)) -tcheck(t, {n=1,"alo23joao12"}) - --- testing MULTRET -t = pack(T.testC("call 2,-1; gettop; return .", - function (a,b) return 1,2,3,4,a,b end, "alo", "joao")) -tcheck(t, {n=6,1,2,3,4,"alo", "joao"}) - -do -- test returning more results than fit in the caller stack - local a = {} - for i=1,1000 do a[i] = true end; a[999] = 10 - local b = T.testC([[pcall 1 -1; pop 1; tostring -1; return 1]], - table.unpack, a) - assert(b == "10") -end - - --- testing globals -_G.a = 14; _G.b = "a31" -local a = {T.testC[[ - getglobal a; - getglobal b; - getglobal b; - setglobal a; - gettop; - return . -]]} -assert(a[2] == 14 and a[3] == "a31" and a[4] == nil and _G.a == "a31") - - --- testing arith -assert(T.testC("pushnum 10; pushnum 20; arith /; return 1") == 0.5) -assert(T.testC("pushnum 10; pushnum 20; arith -; return 1") == -10) -assert(T.testC("pushnum 10; pushnum -20; arith *; return 1") == -200) -assert(T.testC("pushnum 10; pushnum 3; arith ^; return 1") == 1000) -assert(T.testC("pushnum 10; pushstring 20; arith /; return 1") == 0.5) -assert(T.testC("pushstring 10; pushnum 20; arith -; return 1") == -10) -assert(T.testC("pushstring 10; pushstring -20; arith *; return 1") == -200) -assert(T.testC("pushstring 10; pushstring 3; arith ^; return 1") == 1000) -a,b,c = T.testC([[pushnum 1; - pushstring 10; arith _; - pushstring 5; return 3]]) -assert(a == 1 and b == -10 and c == "5") -mt = {__add = function (a,b) return setmetatable({a[1] + b[1]}, mt) end, - __mod = function (a,b) return setmetatable({a[1] % b[1]}, mt) end, - __unm = function (a) return setmetatable({a[1]* 2}, mt) end} -a,b,c = setmetatable({4}, mt), - setmetatable({8}, mt), - setmetatable({-3}, mt) -x,y,z = T.testC("arith +; return 2", 10, a, b) -assert(x == 10 and y[1] == 12 and z == nil) -assert(T.testC("arith %; return 1", a, c)[1] == 4%-3) -assert(T.testC("arith _; arith +; arith %; return 1", b, a, c)[1] == - 8 % (4 + (-3)*2)) - - --- testing compare --- EQ = 0; LT = 1; LE = 2 - --- testing lessthan and lessequal -assert(T.testC("compare 2 5 1, return 1", 3, 2, 2, 4, 2, 2)) -assert(T.testC("compare 2 5 2, return 1", 3, 2, 2, 4, 2, 2)) -assert(not T.testC("compare 3 4 1, return 1", 3, 2, 2, 4, 2, 2)) -assert(T.testC("compare 3 4 2, return 1", 3, 2, 2, 4, 2, 2)) -assert(T.testC("compare 5 2 1, return 1", 4, 2, 2, 3, 2, 2)) -assert(not T.testC("compare 2 -3 1, return 1", "4", "2", "2", "3", "2", "2")) -assert(not T.testC("compare -3 2 1, return 1", "3", "2", "2", "4", "2", "2")) - --- non-valid indices produce false -assert(not T.testC("compare 1 4 1, return 1")) -assert(not T.testC("compare 9 1 2, return 1")) -assert(not T.testC("compare 9 9 0, return 1")) - -local b = {__lt = function (a,b) return a[1] < b[1] end} -local a1,a3,a4 = setmetatable({1}, b), - setmetatable({3}, b), - setmetatable({4}, b) -assert(T.testC("compare 2 5 1, return 1", a3, 2, 2, a4, 2, 2)) -assert(T.testC("compare 2 5 2, return 1", a3, 2, 2, a4, 2, 2)) -assert(T.testC("compare 5 -6 1, return 1", a4, 2, 2, a3, 2, 2)) -a,b = T.testC("compare 5 -6 1, return 2", a1, 2, 2, a3, 2, 20) -assert(a == 20 and b == false) -a,b = T.testC("compare 5 -6 2, return 2", a1, 2, 2, a3, 2, 20) -assert(a == 20 and b == false) -a,b = T.testC("compare 5 -6 2, return 2", a1, 2, 2, a1, 2, 20) -assert(a == 20 and b == true) - --- testing length -local t = setmetatable({x = 20}, {__len = function (t) return t.x end}) -a,b,c = T.testC([[ - len 2; - Llen 2; - objsize 2; - return 3 -]], t) -assert(a == 20 and b == 20 and c == 0) - -t.x = "234"; t[1] = 20 -a,b,c = T.testC([[ - len 2; - Llen 2; - objsize 2; - return 3 -]], t) -assert(a == "234" and b == 234 and c == 1) - -t.x = print; t[1] = 20 -a,c = T.testC([[ - len 2; - objsize 2; - return 2 -]], t) -assert(a == print and c == 1) - - --- testing __concat - -a = setmetatable({x="u"}, {__concat = function (a,b) return a.x..'.'..b.x end}) -x,y = T.testC([[ - pushnum 5 - pushvalue 2; - pushvalue 2; - concat 2; - pushvalue -2; - return 2; -]], a, a) -assert(x == a..a and y == 5) - --- concat with 0 elements -assert(T.testC("concat 0; return 1") == "") - --- concat with 1 element -assert(T.testC("concat 1; return 1", "xuxu") == "xuxu") - - - --- testing lua_is - -function B(x) return x and 1 or 0 end - -function count (x, n) - n = n or 2 - local prog = [[ - isnumber %d; - isstring %d; - isfunction %d; - iscfunction %d; - istable %d; - isuserdata %d; - isnil %d; - isnull %d; - return 8 - ]] - prog = string.format(prog, n, n, n, n, n, n, n, n) - local a,b,c,d,e,f,g,h = T.testC(prog, x) - return B(a)+B(b)+B(c)+B(d)+B(e)+B(f)+B(g)+(100*B(h)) -end - -assert(count(3) == 2) -assert(count('alo') == 1) -assert(count('32') == 2) -assert(count({}) == 1) -assert(count(print) == 2) -assert(count(function () end) == 1) -assert(count(nil) == 1) -assert(count(io.stdin) == 1) -assert(count(nil, 15) == 100) - - --- testing lua_to... - -function to (s, x, n) - n = n or 2 - return T.testC(string.format("%s %d; return 1", s, n), x) -end - -assert(to("tostring", {}) == nil) -assert(to("tostring", "alo") == "alo") -assert(to("tostring", 12) == "12") -assert(to("tostring", 12, 3) == nil) -assert(to("objsize", {}) == 0) -assert(to("objsize", {1,2,3}) == 3) -assert(to("objsize", "alo\0\0a") == 6) -assert(to("objsize", T.newuserdata(0)) == 0) -assert(to("objsize", T.newuserdata(101)) == 101) -assert(to("objsize", 124) == 0) -assert(to("objsize", true) == 0) -assert(to("tonumber", {}) == 0) -assert(to("tonumber", "12") == 12) -assert(to("tonumber", "s2") == 0) -assert(to("tonumber", 1, 20) == 0) -assert(to("topointer", 10) == 0) -assert(to("topointer", true) == 0) -assert(to("topointer", T.pushuserdata(20)) == 20) -assert(to("topointer", io.read) ~= 0) -assert(to("func2num", 20) == 0) -assert(to("func2num", T.pushuserdata(10)) == 0) -assert(to("func2num", io.read) ~= 0) -a = to("tocfunction", math.deg) -assert(a(3) == math.deg(3) and a == math.deg) - - - --- testing deep C stack -do - collectgarbage("stop") - local s, msg = pcall(T.testC, "checkstack 1000023 XXXX") -- too deep - assert(not s and string.find(msg, "XXXX")) - s = string.rep("pushnil;checkstack 1 XX;", 1000000) - s, msg = pcall(T.testC, s) - assert(not s and string.find(msg, "XX")) - collectgarbage("restart") -end - -local prog = {"checkstack 30000 msg", "newtable"} -for i = 1,12000 do - prog[#prog + 1] = "pushnum " .. i - prog[#prog + 1] = "pushnum " .. i * 10 -end - -prog[#prog + 1] = "rawgeti R 2" -- get global table in registry -prog[#prog + 1] = "insert " .. -(2*12000 + 2) - -for i = 1,12000 do - prog[#prog + 1] = "settable " .. -(2*(12000 - i + 1) + 1) -end - -prog[#prog + 1] = "return 2" - -prog = table.concat(prog, ";") -local g, t = T.testC(prog) -assert(g == _G) -for i = 1,12000 do assert(t[i] == i*10); t[i] = nil end -assert(next(t) == nil) -prog, g, t = nil - --- testing errors - -a = T.testC([[ - loadstring 2; pcall 0,1; - pushvalue 3; insert -2; pcall 1, 1; - pcall 0, 0; - return 1 -]], "x=150", function (a) assert(a==nil); return 3 end) - -assert(type(a) == 'string' and x == 150) - -function check3(p, ...) - local arg = {...} - assert(#arg == 3) - assert(string.find(arg[3], p)) -end -check3(":1:", T.testC("loadstring 2; gettop; return .", "x=")) -check3("cannot read", T.testC("loadfile 2; gettop; return .", ".")) -check3("cannot open xxxx", T.testC("loadfile 2; gettop; return .", "xxxx")) - --- test errors in non protected threads -function checkerrnopro (code, msg) - L = coroutine.create(function () end) - local stt, err = pcall(T.testC, code) - assert(not stt and string.find(err, msg)) -end - -checkerrnopro("pushnum 3; call 0 0", "attempt to call") -function f () f() end -checkerrnopro("getglobal 'f'; call 0 0;", "stack overflow") - - --- testing table access - -a = {x=0, y=12} -x, y = T.testC("gettable 2; pushvalue 4; gettable 2; return 2", - a, 3, "y", 4, "x") -assert(x == 0 and y == 12) -T.testC("settable -5", a, 3, 4, "x", 15) -assert(a.x == 15) -a[a] = print -x = T.testC("gettable 2; return 1", a) -- table and key are the same object! -assert(x == print) -T.testC("settable 2", a, "x") -- table and key are the same object! -assert(a[a] == "x") - -b = setmetatable({p = a}, {}) -getmetatable(b).__index = function (t, i) return t.p[i] end -k, x = T.testC("gettable 3, return 2", 4, b, 20, 35, "x") -assert(x == 15 and k == 35) -getmetatable(b).__index = function (t, i) return a[i] end -getmetatable(b).__newindex = function (t, i,v ) a[i] = v end -y = T.testC("insert 2; gettable -5; return 1", 2, 3, 4, "y", b) -assert(y == 12) -k = T.testC("settable -5, return 1", b, 3, 4, "x", 16) -assert(a.x == 16 and k == 4) -a[b] = 'xuxu' -y = T.testC("gettable 2, return 1", b) -assert(y == 'xuxu') -T.testC("settable 2", b, 19) -assert(a[b] == 19) - --- testing next -a = {} -t = pack(T.testC("next; gettop; return .", a, nil)) -tcheck(t, {n=1,a}) -a = {a=3} -t = pack(T.testC("next; gettop; return .", a, nil)) -tcheck(t, {n=3,a,'a',3}) -t = pack(T.testC("next; pop 1; next; gettop; return .", a, nil)) -tcheck(t, {n=1,a}) - - - --- testing upvalues - -do - local A = T.testC[[ pushnum 10; pushnum 20; pushcclosure 2; return 1]] - t, b, c = A([[pushvalue U0; pushvalue U1; pushvalue U2; return 3]]) - assert(b == 10 and c == 20 and type(t) == 'table') - a, b = A([[tostring U3; tonumber U4; return 2]]) - assert(a == nil and b == 0) - A([[pushnum 100; pushnum 200; replace U2; replace U1]]) - b, c = A([[pushvalue U1; pushvalue U2; return 2]]) - assert(b == 100 and c == 200) - A([[replace U2; replace U1]], {x=1}, {x=2}) - b, c = A([[pushvalue U1; pushvalue U2; return 2]]) - assert(b.x == 1 and c.x == 2) - T.checkmemory() -end - - --- testing absent upvalues from C-function pointers -assert(T.testC[[isnull U1; return 1]] == true) -assert(T.testC[[isnull U100; return 1]] == true) -assert(T.testC[[pushvalue U1; return 1]] == nil) - -local f = T.testC[[ pushnum 10; pushnum 20; pushcclosure 2; return 1]] -assert(T.upvalue(f, 1) == 10 and - T.upvalue(f, 2) == 20 and - T.upvalue(f, 3) == nil) -T.upvalue(f, 2, "xuxu") -assert(T.upvalue(f, 2) == "xuxu") - - --- large closures -do - local A = "checkstack 300 msg;" .. - string.rep("pushnum 10;", 255) .. - "pushcclosure 255; return 1" - A = T.testC(A) - for i=1,255 do - assert(A(("pushvalue U%d; return 1"):format(i)) == 10) - end - assert(A("isnull U256; return 1")) - assert(not A("isnil U256; return 1")) -end - - - --- bug in 5.1.2 -assert(not pcall(debug.setuservalue, 3, {})) -assert(not pcall(debug.setuservalue, nil, {})) -assert(not pcall(debug.setuservalue, T.pushuserdata(1), {})) - -local b = T.newuserdata(0) -local a = {} -assert(debug.getuservalue(b) == nil) -assert(debug.setuservalue(b, a)) -assert(debug.getuservalue(b) == a) -assert(debug.setuservalue(b, nil)) -assert(debug.getuservalue(b) == nil) - -assert(debug.getuservalue(4) == nil) - - - --- testing locks (refs) - --- reuse of references -local i = T.ref{} -T.unref(i) -assert(T.ref{} == i) - -Arr = {} -Lim = 100 -for i=1,Lim do -- lock many objects - Arr[i] = T.ref({}) -end - -assert(T.ref(nil) == -1 and T.getref(-1) == nil) -T.unref(-1); T.unref(-1) - -for i=1,Lim do -- unlock all them - T.unref(Arr[i]) -end - -function printlocks () - local f = T.makeCfunc("gettable R; return 1") - local n = f("n") - print("n", n) - for i=0,n do - print(i, f(i)) - end -end - - -for i=1,Lim do -- lock many objects - Arr[i] = T.ref({}) -end - -for i=1,Lim,2 do -- unlock half of them - T.unref(Arr[i]) -end - -assert(type(T.getref(Arr[2])) == 'table') - - -assert(T.getref(-1) == nil) - - -a = T.ref({}) - -collectgarbage() - -assert(type(T.getref(a)) == 'table') - - --- colect in cl the `val' of all collected userdata -tt = {} -cl = {n=0} -A = nil; B = nil -local F -F = function (x) - local udval = T.udataval(x) - table.insert(cl, udval) - local d = T.newuserdata(100) -- cria lixo - d = nil - assert(debug.getmetatable(x).__gc == F) - assert(load("table.insert({}, {})"))() -- cria mais lixo - collectgarbage() -- forca coleta de lixo durante coleta! - assert(debug.getmetatable(x).__gc == F) -- coleta anterior nao melou isso? - local dummy = {} -- cria lixo durante coleta - if A ~= nil then - assert(type(A) == "userdata") - assert(T.udataval(A) == B) - debug.getmetatable(A) -- just acess it - end - A = x -- ressucita userdata - B = udval - return 1,2,3 -end -tt.__gc = F - --- test whether udate collection frees memory in the right time -do - collectgarbage(); - collectgarbage(); - local x = collectgarbage("count"); - local a = T.newuserdata(5001) - assert(T.testC("objsize 2; return 1", a) == 5001) - assert(collectgarbage("count") >= x+4) - a = nil - collectgarbage(); - assert(collectgarbage("count") <= x+1) - -- udata without finalizer - x = collectgarbage("count") - collectgarbage("stop") - for i=1,1000 do T.newuserdata(0) end - assert(collectgarbage("count") > x+10) - collectgarbage() - assert(collectgarbage("count") <= x+1) - -- udata with finalizer - x = collectgarbage("count") - collectgarbage() - collectgarbage("stop") - a = {__gc = function () end} - for i=1,1000 do debug.setmetatable(T.newuserdata(0), a) end - assert(collectgarbage("count") >= x+10) - collectgarbage() -- this collection only calls TM, without freeing memory - assert(collectgarbage("count") >= x+10) - collectgarbage() -- now frees memory - assert(collectgarbage("count") <= x+1) - collectgarbage("restart") -end - - -collectgarbage("stop") - --- create 3 userdatas with tag `tt' -a = T.newuserdata(0); debug.setmetatable(a, tt); na = T.udataval(a) -b = T.newuserdata(0); debug.setmetatable(b, tt); nb = T.udataval(b) -c = T.newuserdata(0); debug.setmetatable(c, tt); nc = T.udataval(c) - --- create userdata without meta table -x = T.newuserdata(4) -y = T.newuserdata(0) - -assert(not pcall(io.input, a)) -assert(not pcall(io.input, x)) - -assert(debug.getmetatable(x) == nil and debug.getmetatable(y) == nil) - -d=T.ref(a); -e=T.ref(b); -f=T.ref(c); -t = {T.getref(d), T.getref(e), T.getref(f)} -assert(t[1] == a and t[2] == b and t[3] == c) - -t=nil; a=nil; c=nil; -T.unref(e); T.unref(f) - -collectgarbage() - --- check that unref objects have been collected -assert(#cl == 1 and cl[1] == nc) - -x = T.getref(d) -assert(type(x) == 'userdata' and debug.getmetatable(x) == tt) -x =nil -tt.b = b -- create cycle -tt=nil -- frees tt for GC -A = nil -b = nil -T.unref(d); -n5 = T.newuserdata(0) -debug.setmetatable(n5, {__gc=F}) -n5 = T.udataval(n5) -collectgarbage() -assert(#cl == 4) --- check order of collection -assert(cl[2] == n5 and cl[3] == nb and cl[4] == na) - -collectgarbage"restart" - - -a, na = {}, {} -for i=30,1,-1 do - a[i] = T.newuserdata(0) - debug.setmetatable(a[i], {__gc=F}) - na[i] = T.udataval(a[i]) -end -cl = {} -a = nil; collectgarbage() -assert(#cl == 30) -for i=1,30 do assert(cl[i] == na[i]) end -na = nil - - -for i=2,Lim,2 do -- unlock the other half - T.unref(Arr[i]) -end - -x = T.newuserdata(41); debug.setmetatable(x, {__gc=F}) -assert(T.testC("objsize 2; return 1", x) == 41) -cl = {} -a = {[x] = 1} -x = T.udataval(x) -collectgarbage() --- old `x' cannot be collected (`a' still uses it) -assert(#cl == 0) -for n in pairs(a) do a[n] = nil end -collectgarbage() -assert(#cl == 1 and cl[1] == x) -- old `x' must be collected - --- testing lua_equal -assert(T.testC("compare 2 4 0; return 1", print, 1, print, 20)) -assert(T.testC("compare 3 2 0; return 1", 'alo', "alo")) -assert(T.testC("compare 2 3 0; return 1", nil, nil)) -assert(not T.testC("compare 2 3 0; return 1", {}, {})) -assert(not T.testC("compare 2 3 0; return 1")) -assert(not T.testC("compare 2 3 0; return 1", 3)) - --- testing lua_equal with fallbacks -do - local map = {} - local t = {__eq = function (a,b) return map[a] == map[b] end} - local function f(x) - local u = T.newuserdata(0) - debug.setmetatable(u, t) - map[u] = x - return u - end - assert(f(10) == f(10)) - assert(f(10) ~= f(11)) - assert(T.testC("compare 2 3 0; return 1", f(10), f(10))) - assert(not T.testC("compare 2 3 0; return 1", f(10), f(20))) - t.__eq = nil - assert(f(10) ~= f(10)) -end - -print'+' - - - --- testing changing hooks during hooks -_G.t = {} -T.sethook([[ - # set a line hook after 3 count hooks - sethook 4 0 ' - getglobal t; - pushvalue -3; append -2 - pushvalue -2; append -2 - ']], "c", 3) -local a = 1 -- counting -a = 1 -- counting -a = 1 -- count hook (set line hook) -a = 1 -- line hook -a = 1 -- line hook -debug.sethook() -t = _G.t -assert(t[1] == "line") -line = t[2] -assert(t[3] == "line" and t[4] == line + 1) -assert(t[5] == "line" and t[6] == line + 2) -assert(t[7] == nil) - - -------------------------------------------------------------------------- -do -- testing errors during GC - local a = {} - for i=1,20 do - a[i] = T.newuserdata(i) -- creates several udata - end - for i=1,20,2 do -- mark half of them to raise errors during GC - debug.setmetatable(a[i], {__gc = function (x) error("error inside gc") end}) - end - for i=2,20,2 do -- mark the other half to count and to create more garbage - debug.setmetatable(a[i], {__gc = function (x) load("A=A+1")() end}) - end - _G.A = 0 - a = 0 - while 1 do - local stat, msg = pcall(collectgarbage) - if stat then - break -- stop when no more errors - else - a = a + 1 - assert(string.find(msg, "__gc")) - end - end - assert(a == 10) -- number of errors - - assert(A == 10) -- number of normal collections -end -------------------------------------------------------------------------- --- test for userdata vals -do - local a = {}; local lim = 30 - for i=0,lim do a[i] = T.pushuserdata(i) end - for i=0,lim do assert(T.udataval(a[i]) == i) end - for i=0,lim do assert(T.pushuserdata(i) == a[i]) end - for i=0,lim do a[a[i]] = i end - for i=0,lim do a[T.pushuserdata(i)] = i end - assert(type(tostring(a[1])) == "string") -end - - -------------------------------------------------------------------------- --- testing multiple states -T.closestate(T.newstate()); -L1 = T.newstate() -assert(L1) - -assert(T.doremote(L1, "X='a'; return 'a'") == 'a') - - -assert(#pack(T.doremote(L1, "function f () return 'alo', 3 end; f()")) == 0) - -a, b = T.doremote(L1, "return f()") -assert(a == 'alo' and b == '3') - -T.doremote(L1, "_ERRORMESSAGE = nil") --- error: `sin' is not defined -a, _, b = T.doremote(L1, "return sin(1)") -assert(a == nil and b == 2) -- 2 == run-time error - --- error: syntax error -a, b, c = T.doremote(L1, "return a+") -assert(a == nil and c == 3 and type(b) == "string") -- 3 == syntax error - -T.loadlib(L1) -a, b, c = T.doremote(L1, [[ - string = require'string' - a = require'_G'; assert(a == _G and require("_G") == a) - io = require'io'; assert(type(io.read) == "function") - assert(require("io") == io) - a = require'table'; assert(type(a.insert) == "function") - a = require'debug'; assert(type(a.getlocal) == "function") - a = require'math'; assert(type(a.sin) == "function") - return string.sub('okinama', 1, 2) -]]) -assert(a == "ok") - -T.closestate(L1); - - -L1 = T.newstate() -T.loadlib(L1) -T.doremote(L1, "a = {}") -T.testC(L1, [[getglobal "a"; pushstring "x"; pushnum 1; - settable -3]]) -assert(T.doremote(L1, "return a.x") == "1") - -T.closestate(L1) - -L1 = nil - -print('+') - -------------------------------------------------------------------------- --- testing memory limits -------------------------------------------------------------------------- -assert(not pcall(T.newuserdata, 2^32-4)) -collectgarbage() -T.totalmem(T.totalmem()+5000) -- set low memory limit (+5k) -assert(not pcall(load"local a={}; for i=1,100000 do a[i]=i end")) -T.totalmem(1000000000) -- restore high limit - --- test memory errors; increase memory limit in small steps, so that --- we get memory errors in different parts of a given task, up to there --- is enough memory to complete the task without errors -function testamem (s, f) - collectgarbage(); collectgarbage() - local M = T.totalmem() - local oldM = M - local a,b = nil - while 1 do - M = M+7 -- increase memory limit in small steps - T.totalmem(M) - a, b = pcall(f) - T.totalmem(1000000000) -- restore high limit - if a and b then break end -- stop when no more errors - collectgarbage() - if not a and not -- `real' error? - (string.find(b, "memory") or string.find(b, "overflow")) then - error(b, 0) -- propagate it - end - end - print("\nlimit for " .. s .. ": " .. M-oldM) - return b -end - - --- testing memory errors when creating a new state - -b = testamem("state creation", T.newstate) -T.closestate(b); -- close new state - - --- testing threads - --- get main thread from registry (at index LUA_RIDX_MAINTHREAD == 1) -mt = T.testC("rawgeti R 1; return 1") -assert(type(mt) == "thread" and coroutine.running() == mt) - - - -function expand (n,s) - if n==0 then return "" end - local e = string.rep("=", n) - return string.format("T.doonnewstack([%s[ %s;\n collectgarbage(); %s]%s])\n", - e, s, expand(n-1,s), e) -end - -G=0; collectgarbage(); a =collectgarbage("count") -load(expand(20,"G=G+1"))() -assert(G==20); collectgarbage(); -- assert(gcinfo() <= a+1) - -testamem("thread creation", function () - return T.doonnewstack("x=1") == 0 -- try to create thread -end) - - --- testing memory x compiler - -testamem("loadstring", function () - return load("x=1") -- try to do load a string -end) - - -local testprog = [[ -local function foo () return end -local t = {"x"} -a = "aaa" -for i = 1, #t do a=a..t[i] end -return true -]] - --- testing memory x dofile -_G.a = nil -local t =os.tmpname() -local f = assert(io.open(t, "w")) -f:write(testprog) -f:close() -testamem("dofile", function () - local a = loadfile(t) - return a and a() -end) -assert(os.remove(t)) -assert(_G.a == "aaax") - - --- other generic tests - -testamem("string creation", function () - local a, b = string.gsub("alo alo", "(a)", function (x) return x..'b' end) - return (a == 'ablo ablo') -end) - -testamem("dump/undump", function () - local a = load(testprog) - local b = a and string.dump(a) - a = b and load(b) - return a and a() -end) - -local t = os.tmpname() -testamem("file creation", function () - local f = assert(io.open(t, 'w')) - assert (not io.open"nomenaoexistente") - io.close(f); - return not loadfile'nomenaoexistente' -end) -assert(os.remove(t)) - -testamem("table creation", function () - local a, lim = {}, 10 - for i=1,lim do a[i] = i; a[i..'a'] = {} end - return (type(a[lim..'a']) == 'table' and a[lim] == lim) -end) - -testamem("constructors", function () - local a = {10, 20, 30, 40, 50; a=1, b=2, c=3, d=4, e=5} - return (type(a) == 'table' and a.e == 5) -end) - -local a = 1 -close = nil -testamem("closure creation", function () - function close (b,c) - return function (x) return a+b+c+x end - end - return (close(2,3)(4) == 10) -end) - -testamem("coroutines", function () - local a = coroutine.wrap(function () - coroutine.yield(string.rep("a", 10)) - return {} - end) - assert(string.len(a()) == 10) - return a() -end) - -print'+' - --- testing some auxlib functions -local function gsub (a, b, c) - a, b = T.testC("gsub 2 3 4; gettop; return 2", a, b, c) - assert(b == 5) - return a -end - -assert(gsub("alo.alo.uhuh.", ".", "//") == "alo//alo//uhuh//") -assert(gsub("alo.alo.uhuh.", "alo", "//") == "//.//.uhuh.") -assert(gsub("", "alo", "//") == "") -assert(gsub("...", ".", "/.") == "/././.") -assert(gsub("...", "...", "") == "") - - --- testing luaL_newmetatable -local mt_xuxu, res, top = T.testC("newmetatable xuxu; gettop; return 3") -assert(type(mt_xuxu) == "table" and res and top == 3) -local d, res, top = T.testC("newmetatable xuxu; gettop; return 3") -assert(mt_xuxu == d and not res and top == 3) -d, res, top = T.testC("newmetatable xuxu1; gettop; return 3") -assert(mt_xuxu ~= d and res and top == 3) - -x = T.newuserdata(0); -y = T.newuserdata(0); -T.testC("pushstring xuxu; gettable R; setmetatable 2", x) -assert(getmetatable(x) == mt_xuxu) - --- testing luaL_testudata --- correct metatable -local res1, res2, top = T.testC([[testudata -1 xuxu - testudata 2 xuxu - gettop - return 3]], x) -assert(res1 and res2 and top == 4) - --- wrong metatable -res1, res2, top = T.testC([[testudata -1 xuxu1 - testudata 2 xuxu1 - gettop - return 3]], x) -assert(not res1 and not res2 and top == 4) - --- non-existent type -res1, res2, top = T.testC([[testudata -1 xuxu2 - testudata 2 xuxu2 - gettop - return 3]], x) -assert(not res1 and not res2 and top == 4) - --- userdata has no metatable -res1, res2, top = T.testC([[testudata -1 xuxu - testudata 2 xuxu - gettop - return 3]], y) -assert(not res1 and not res2 and top == 4) - --- erase metatables -do - local r = debug.getregistry() - assert(r.xuxu == mt_xuxu and r.xuxu1 == d) - r.xuxu = nil; r.xuxu1 = nil -end - -print'OK' - diff --git a/utils/lua_tests/attrib.lua b/utils/lua_tests/attrib.lua deleted file mode 100644 index 2fdc0673b..000000000 --- a/utils/lua_tests/attrib.lua +++ /dev/null @@ -1,421 +0,0 @@ --- The tests for 'require' assume some specific directories and libraries; --- better to avoid them in generic machines - -if not _port then --[ - -print "testing require" - -assert(require"string" == string) -assert(require"math" == math) -assert(require"table" == table) -assert(require"io" == io) -assert(require"os" == os) -assert(require"coroutine" == coroutine) - -assert(type(package.path) == "string") -assert(type(package.cpath) == "string") -assert(type(package.loaded) == "table") -assert(type(package.preload) == "table") - -assert(type(package.config) == "string") -print("package config: "..string.gsub(package.config, "\n", "|")) - -do - -- create a path with 'max' templates, - -- each with 1-10 repetitions of '?' - local max = 2000 - local t = {} - for i = 1,max do t[i] = string.rep("?", i%10 + 1) end - t[#t + 1] = ";" -- empty template - local path = table.concat(t, ";") - -- use that path in a search - local s, err = package.searchpath("xuxu", path) - -- search fails; check that message has an occurence of - -- '??????????' with ? replaced by xuxu and at least 'max' lines - assert(not s and - string.find(err, string.rep("xuxu", 10)) and - #string.gsub(err, "[^\n]", "") >= max) - -- path with one very long template - local path = string.rep("?", max) - local s, err = package.searchpath("xuxu", path) - assert(not s and string.find(err, string.rep('xuxu', max))) -end - -do - local oldpath = package.path - package.path = {} - local s, err = pcall(require, "no-such-file") - assert(not s and string.find(err, "package.path")) - package.path = oldpath -end - -print('+') - --- auxiliary directory with C modules and temporary files -local DIR = "libs/" - --- prepend DIR to a name -local function D (x) return DIR .. x end - - -local function createfiles (files, preextras, posextras) - for n,c in pairs(files) do - io.output(D(n)) - io.write(string.format(preextras, n)) - io.write(c) - io.write(string.format(posextras, n)) - io.close(io.output()) - end -end - -function removefiles (files) - for n in pairs(files) do - os.remove(D(n)) - end -end - -local files = { - ["names.lua"] = "do return {...} end\n", - ["err.lua"] = "B = 15; a = a + 1;", - ["A.lua"] = "", - ["B.lua"] = "assert(...=='B');require 'A'", - ["A.lc"] = "", - ["A"] = "", - ["L"] = "", - ["XXxX"] = "", - ["C.lua"] = "package.loaded[...] = 25; require'C'" -} - -AA = nil -local extras = [[ -NAME = '%s' -REQUIRED = ... -return AA]] - -createfiles(files, "", extras) - --- testing explicit "dir" separator in 'searchpath' -assert(package.searchpath("C.lua", D"?", "", "") == D"C.lua") -assert(package.searchpath("C.lua", D"?", ".", ".") == D"C.lua") -assert(package.searchpath("--x-", D"?", "-", "X") == D"XXxX") -assert(package.searchpath("---xX", D"?", "---", "XX") == D"XXxX") -assert(package.searchpath(D"C.lua", "?", "/") == D"C.lua") -assert(package.searchpath(".\\C.lua", D"?", "\\") == D"./C.lua") - -local oldpath = package.path - -package.path = string.gsub("D/?.lua;D/?.lc;D/?;D/??x?;D/L", "D/", DIR) - -local try = function (p, n, r) - NAME = nil - local rr = require(p) - assert(NAME == n) - assert(REQUIRED == p) - assert(rr == r) -end - -a = require"names" -assert(a[1] == "names" and a[2] == D"names.lua") - -_G.a = nil -assert(not pcall(require, "err")) -assert(B == 15) - -assert(package.searchpath("C", package.path) == D"C.lua") -assert(require"C" == 25) -assert(require"C" == 25) -AA = nil -try('B', 'B.lua', true) -assert(package.loaded.B) -assert(require"B" == true) -assert(package.loaded.A) -assert(require"C" == 25) -package.loaded.A = nil -try('B', nil, true) -- should not reload package -try('A', 'A.lua', true) -package.loaded.A = nil -os.remove(D'A.lua') -AA = {} -try('A', 'A.lc', AA) -- now must find second option -assert(package.searchpath("A", package.path) == D"A.lc") -assert(require("A") == AA) -AA = false -try('K', 'L', false) -- default option -try('K', 'L', false) -- default option (should reload it) -assert(rawget(_G, "_REQUIREDNAME") == nil) - -AA = "x" -try("X", "XXxX", AA) - - -removefiles(files) - - --- testing require of sub-packages - -local _G = _G - -package.path = string.gsub("D/?.lua;D/?/init.lua", "D/", DIR) - -files = { - ["P1/init.lua"] = "AA = 10", - ["P1/xuxu.lua"] = "AA = 20", -} - -createfiles(files, "_ENV = {}\n", "\nreturn _ENV\n") -AA = 0 - -local m = assert(require"P1") -assert(AA == 0 and m.AA == 10) -assert(require"P1" == m) -assert(require"P1" == m) - -assert(package.searchpath("P1.xuxu", package.path) == D"P1/xuxu.lua") -m.xuxu = assert(require"P1.xuxu") -assert(AA == 0 and m.xuxu.AA == 20) -assert(require"P1.xuxu" == m.xuxu) -assert(require"P1.xuxu" == m.xuxu) -assert(require"P1" == m and m.AA == 10) - - -removefiles(files) - - -package.path = "" -assert(not pcall(require, "file_does_not_exist")) -package.path = "??\0?" -assert(not pcall(require, "file_does_not_exist1")) - -package.path = oldpath - --- check 'require' error message -local fname = "file_does_not_exist2" -local m, err = pcall(require, fname) -for t in string.gmatch(package.path..";"..package.cpath, "[^;]+") do - t = string.gsub(t, "?", fname) - assert(string.find(err, t, 1, true)) -end - - -local function import(...) - local f = {...} - return function (m) - for i=1, #f do m[f[i]] = _G[f[i]] end - end -end - --- cannot change environment of a C function -assert(not pcall(module, 'XUXU')) - - - --- testing require of C libraries - - -local p = "" -- On Mac OS X, redefine this to "_" - --- check whether loadlib works in this system -local st, err, when = package.loadlib(D"lib1.so", "*") -if not st then - local f, err, when = package.loadlib("donotexist", p.."xuxu") - assert(not f and type(err) == "string" and when == "absent") - ;(Message or print)('\a\n >>> cannot load dynamic library <<<\n\a') - print(err, when) -else - -- tests for loadlib - local f = assert(package.loadlib(D"lib1.so", p.."onefunction")) - local a, b = f(15, 25) - assert(a == 25 and b == 15) - - f = assert(package.loadlib(D"lib1.so", p.."anotherfunc")) - assert(f(10, 20) == "1020\n") - - -- check error messages - local f, err, when = package.loadlib(D"lib1.so", p.."xuxu") - assert(not f and type(err) == "string" and when == "init") - f, err, when = package.loadlib("donotexist", p.."xuxu") - assert(not f and type(err) == "string" and when == "open") - - -- symbols from 'lib1' must be visible to other libraries - f = assert(package.loadlib(D"lib11.so", p.."luaopen_lib11")) - assert(f() == "exported") - - -- test C modules with prefixes in names - package.cpath = D"?.so" - local lib2 = require"v-lib2" - -- check correct access to global environment and correct - -- parameters - assert(_ENV.x == "v-lib2" and _ENV.y == D"v-lib2.so") - assert(lib2.id("x") == "x") - - -- test C submodules - local fs = require"lib1.sub" - assert(_ENV.x == "lib1.sub" and _ENV.y == D"lib1.so") - assert(fs.id(45) == 45) -end - -_ENV = _G - - --- testing preload - -do - local p = package - package = {} - p.preload.pl = function (...) - local _ENV = {...} - function xuxu (x) return x+20 end - return _ENV - end - - local pl = require"pl" - assert(require"pl" == pl) - assert(pl.xuxu(10) == 30) - assert(pl[1] == "pl" and pl[2] == nil) - - package = p - assert(type(package.path) == "string") -end - -print('+') - -end --] - -print("testing assignments, logical operators, and constructors") - -local res, res2 = 27 - -a, b = 1, 2+3 -assert(a==1 and b==5) -a={} -function f() return 10, 11, 12 end -a.x, b, a[1] = 1, 2, f() -assert(a.x==1 and b==2 and a[1]==10) -a[f()], b, a[f()+3] = f(), a, 'x' -assert(a[10] == 10 and b == a and a[13] == 'x') - -do - local f = function (n) local x = {}; for i=1,n do x[i]=i end; - return table.unpack(x) end; - local a,b,c - a,b = 0, f(1) - assert(a == 0 and b == 1) - A,b = 0, f(1) - assert(A == 0 and b == 1) - a,b,c = 0,5,f(4) - assert(a==0 and b==5 and c==1) - a,b,c = 0,5,f(0) - assert(a==0 and b==5 and c==nil) -end - -a, b, c, d = 1 and nil, 1 or nil, (1 and (nil or 1)), 6 -assert(not a and b and c and d==6) - -d = 20 -a, b, c, d = f() -assert(a==10 and b==11 and c==12 and d==nil) -a,b = f(), 1, 2, 3, f() -assert(a==10 and b==1) - -assert(ab == true) -assert((10 and 2) == 2) -assert((10 or 2) == 10) -assert((10 or assert(nil)) == 10) -assert(not (nil and assert(nil))) -assert((nil or "alo") == "alo") -assert((nil and 10) == nil) -assert((false and 10) == false) -assert((true or 10) == true) -assert((false or 10) == 10) -assert(false ~= nil) -assert(nil ~= false) -assert(not nil == true) -assert(not not nil == false) -assert(not not 1 == true) -assert(not not a == true) -assert(not not (6 or nil) == true) -assert(not not (nil and 56) == false) -assert(not not (nil and true) == false) - -assert({} ~= {}) -print('+') - -a = {} -a[true] = 20 -a[false] = 10 -assert(a[1<2] == 20 and a[1>2] == 10) - -function f(a) return a end - -local a = {} -for i=3000,-3000,-1 do a[i] = i; end -a[10e30] = "alo"; a[true] = 10; a[false] = 20 -assert(a[10e30] == 'alo' and a[not 1] == 20 and a[10<20] == 10) -for i=3000,-3000,-1 do assert(a[i] == i); end -a[print] = assert -a[f] = print -a[a] = a -assert(a[a][a][a][a][print] == assert) -a[print](a[a[f]] == a[print]) -assert(not pcall(function () local a = {}; a[nil] = 10 end)) -assert(not pcall(function () local a = {[nil] = 10} end)) -assert(a[nil] == nil) -a = nil - -a = {10,9,8,7,6,5,4,3,2; [-3]='a', [f]=print, a='a', b='ab'} -a, a.x, a.y = a, a[-3] -assert(a[1]==10 and a[-3]==a.a and a[f]==print and a.x=='a' and not a.y) -a[1], f(a)[2], b, c = {['alo']=assert}, 10, a[1], a[f], 6, 10, 23, f(a), 2 -a[1].alo(a[2]==10 and b==10 and c==print) - -a[2^31] = 10; a[2^31+1] = 11; a[-2^31] = 12; -a[2^32] = 13; a[-2^32] = 14; a[2^32+1] = 15; a[10^33] = 16; - -assert(a[2^31] == 10 and a[2^31+1] == 11 and a[-2^31] == 12 and - a[2^32] == 13 and a[-2^32] == 14 and a[2^32+1] == 15 and - a[10^33] == 16) - -a = nil - - --- test conflicts in multiple assignment -do - local a,i,j,b - a = {'a', 'b'}; i=1; j=2; b=a - i, a[i], a, j, a[j], a[i+j] = j, i, i, b, j, i - assert(i == 2 and b[1] == 1 and a == 1 and j == b and b[2] == 2 and - b[3] == 1) -end - --- repeat test with upvalues -do - local a,i,j,b - a = {'a', 'b'}; i=1; j=2; b=a - local function foo () - i, a[i], a, j, a[j], a[i+j] = j, i, i, b, j, i - end - foo() - assert(i == 2 and b[1] == 1 and a == 1 and j == b and b[2] == 2 and - b[3] == 1) - local t = {} - (function (a) t[a], a = 10, 20 end)(1); - assert(t[1] == 10) -end - --- bug in 5.2 beta -local function foo () - local a - return function () - local b - a, b = 3, 14 -- local and upvalue have same index - return a, b - end -end - -local a, b = foo()() -assert(a == 3 and b == 14) - -print('OK') - -return res - diff --git a/utils/lua_tests/big.lua b/utils/lua_tests/big.lua deleted file mode 100644 index 0c8ab2017..000000000 --- a/utils/lua_tests/big.lua +++ /dev/null @@ -1,79 +0,0 @@ -if _soft then - return 'a' -end - -print "testing large tables" - -local debug = require"debug" - -local lim = 2^18 + 1000 -local prog = { "local y = {0" } -for i = 1, lim do prog[#prog + 1] = i end -prog[#prog + 1] = "}\n" -prog[#prog + 1] = "X = y\n" -prog[#prog + 1] = ("assert(X[%d] == %d)"):format(lim - 1, lim - 2) -prog[#prog + 1] = "return 0" -prog = table.concat(prog, ";") - -local env = {string = string, assert = assert} -local f = assert(load(prog, nil, nil, env)) - -f() -assert(env.X[lim] == lim - 1 and env.X[lim + 1] == lim) -for k in pairs(env) do env[k] = nil end - --- yields during accesses larger than K (in RK) -setmetatable(env, { - __index = function (t, n) coroutine.yield('g'); return _G[n] end, - __newindex = function (t, n, v) coroutine.yield('s'); _G[n] = v end, -}) - -X = nil -co = coroutine.wrap(f) -assert(co() == 's') -assert(co() == 'g') -assert(co() == 'g') -assert(co() == 0) - -assert(X[lim] == lim - 1 and X[lim + 1] == lim) - --- errors in accesses larger than K (in RK) -getmetatable(env).__index = function () end -getmetatable(env).__newindex = function () end -local e, m = pcall(f) -assert(not e and m:find("global 'X'")) - --- errors in metamethods -getmetatable(env).__newindex = function () error("hi") end -local e, m = xpcall(f, debug.traceback) -assert(not e and m:find("'__newindex'")) - -f, X = nil - -coroutine.yield'b' - -if not _no32 then -- { - -print "testing string length overflow" - -local repstrings = 192 -- number of strings to be concatenated -local ssize = math.ceil(2^32 / repstrings) + 1 -- size of each string - -assert(repstrings * ssize > 2^32) -- this should be larger than maximum size_t - -local longs = string.rep("\0", ssize) -- create one long string - --- create function to concatentate 'repstrings' copies of its argument -local rep = assert(load( - "local a = ...; return " .. string.rep("a", repstrings, ".."))) - -local a, b = pcall(rep, longs) -- call that function - --- it should fail without creating string (result would be too large) -assert(not a and string.find(b, "overflow")) - -end -- } - -print'OK' - -return 'a' diff --git a/utils/lua_tests/bitwise.lua b/utils/lua_tests/bitwise.lua deleted file mode 100644 index afa158ddf..000000000 --- a/utils/lua_tests/bitwise.lua +++ /dev/null @@ -1,115 +0,0 @@ -print("testing bitwise operations") - -assert(bit32.band() == bit32.bnot(0)) -assert(bit32.btest() == true) -assert(bit32.bor() == 0) -assert(bit32.bxor() == 0) - -assert(bit32.band() == bit32.band(0xffffffff)) -assert(bit32.band(1,2) == 0) - - --- out-of-range numbers -assert(bit32.band(-1) == 0xffffffff) -assert(bit32.band(2^33 - 1) == 0xffffffff) -assert(bit32.band(-2^33 - 1) == 0xffffffff) -assert(bit32.band(2^33 + 1) == 1) -assert(bit32.band(-2^33 + 1) == 1) -assert(bit32.band(-2^40) == 0) -assert(bit32.band(2^40) == 0) -assert(bit32.band(-2^40 - 2) == 0xfffffffe) -assert(bit32.band(2^40 - 4) == 0xfffffffc) - -assert(bit32.lrotate(0, -1) == 0) -assert(bit32.lrotate(0, 7) == 0) -assert(bit32.lrotate(0x12345678, 4) == 0x23456781) -assert(bit32.rrotate(0x12345678, -4) == 0x23456781) -assert(bit32.lrotate(0x12345678, -8) == 0x78123456) -assert(bit32.rrotate(0x12345678, 8) == 0x78123456) -assert(bit32.lrotate(0xaaaaaaaa, 2) == 0xaaaaaaaa) -assert(bit32.lrotate(0xaaaaaaaa, -2) == 0xaaaaaaaa) -for i = -50, 50 do - assert(bit32.lrotate(0x89abcdef, i) == bit32.lrotate(0x89abcdef, i%32)) -end - -assert(bit32.lshift(0x12345678, 4) == 0x23456780) -assert(bit32.lshift(0x12345678, 8) == 0x34567800) -assert(bit32.lshift(0x12345678, -4) == 0x01234567) -assert(bit32.lshift(0x12345678, -8) == 0x00123456) -assert(bit32.lshift(0x12345678, 32) == 0) -assert(bit32.lshift(0x12345678, -32) == 0) -assert(bit32.rshift(0x12345678, 4) == 0x01234567) -assert(bit32.rshift(0x12345678, 8) == 0x00123456) -assert(bit32.rshift(0x12345678, 32) == 0) -assert(bit32.rshift(0x12345678, -32) == 0) -assert(bit32.arshift(0x12345678, 0) == 0x12345678) -assert(bit32.arshift(0x12345678, 1) == 0x12345678 / 2) -assert(bit32.arshift(0x12345678, -1) == 0x12345678 * 2) -assert(bit32.arshift(-1, 1) == 0xffffffff) -assert(bit32.arshift(-1, 24) == 0xffffffff) -assert(bit32.arshift(-1, 32) == 0xffffffff) -assert(bit32.arshift(-1, -1) == (-1 * 2) % 2^32) - -print("+") --- some special cases -local c = {0, 1, 2, 3, 10, 0x80000000, 0xaaaaaaaa, 0x55555555, - 0xffffffff, 0x7fffffff} - -for _, b in pairs(c) do - assert(bit32.band(b) == b) - assert(bit32.band(b, b) == b) - assert(bit32.btest(b, b) == (b ~= 0)) - assert(bit32.band(b, b, b) == b) - assert(bit32.btest(b, b, b) == (b ~= 0)) - assert(bit32.band(b, bit32.bnot(b)) == 0) - assert(bit32.bor(b, bit32.bnot(b)) == bit32.bnot(0)) - assert(bit32.bor(b) == b) - assert(bit32.bor(b, b) == b) - assert(bit32.bor(b, b, b) == b) - assert(bit32.bxor(b) == b) - assert(bit32.bxor(b, b) == 0) - assert(bit32.bxor(b, 0) == b) - assert(bit32.bnot(b) ~= b) - assert(bit32.bnot(bit32.bnot(b)) == b) - assert(bit32.bnot(b) == 2^32 - 1 - b) - assert(bit32.lrotate(b, 32) == b) - assert(bit32.rrotate(b, 32) == b) - assert(bit32.lshift(bit32.lshift(b, -4), 4) == bit32.band(b, bit32.bnot(0xf))) - assert(bit32.rshift(bit32.rshift(b, 4), -4) == bit32.band(b, bit32.bnot(0xf))) - for i = -40, 40 do - assert(bit32.lshift(b, i) == math.floor((b * 2^i) % 2^32)) - end -end - -assert(not pcall(bit32.band, {})) -assert(not pcall(bit32.bnot, "a")) -assert(not pcall(bit32.lshift, 45)) -assert(not pcall(bit32.lshift, 45, print)) -assert(not pcall(bit32.rshift, 45, print)) - -print("+") - - --- testing extract/replace - -assert(bit32.extract(0x12345678, 0, 4) == 8) -assert(bit32.extract(0x12345678, 4, 4) == 7) -assert(bit32.extract(0xa0001111, 28, 4) == 0xa) -assert(bit32.extract(0xa0001111, 31, 1) == 1) -assert(bit32.extract(0x50000111, 31, 1) == 0) -assert(bit32.extract(0xf2345679, 0, 32) == 0xf2345679) - -assert(not pcall(bit32.extract, 0, -1)) -assert(not pcall(bit32.extract, 0, 32)) -assert(not pcall(bit32.extract, 0, 0, 33)) -assert(not pcall(bit32.extract, 0, 31, 2)) - -assert(bit32.replace(0x12345678, 5, 28, 4) == 0x52345678) -assert(bit32.replace(0x12345678, 0x87654321, 0, 32) == 0x87654321) -assert(bit32.replace(0, 1, 2) == 2^2) -assert(bit32.replace(0, -1, 4) == 2^4) -assert(bit32.replace(-1, 0, 31) == 2^31 - 1) -assert(bit32.replace(-1, 0, 1, 2) == 2^32 - 7) - - -print'OK' diff --git a/utils/lua_tests/calls.lua b/utils/lua_tests/calls.lua deleted file mode 100644 index 77afa746b..000000000 --- a/utils/lua_tests/calls.lua +++ /dev/null @@ -1,310 +0,0 @@ -print("testing functions and calls") - -local debug = require "debug" - --- get the opportunity to test 'type' too ;) - -assert(type(1<2) == 'boolean') -assert(type(true) == 'boolean' and type(false) == 'boolean') -assert(type(nil) == 'nil' and type(-3) == 'number' and type'x' == 'string' and - type{} == 'table' and type(type) == 'function') - -assert(type(assert) == type(print)) -f = nil -function f (x) return a:x (x) end -assert(type(f) == 'function') - - --- testing local-function recursion -fact = false -do - local res = 1 - local function fact (n) - if n==0 then return res - else return n*fact(n-1) - end - end - assert(fact(5) == 120) -end -assert(fact == false) - --- testing declarations -a = {i = 10} -self = 20 -function a:x (x) return x+self.i end -function a.y (x) return x+self end - -assert(a:x(1)+10 == a.y(1)) - -a.t = {i=-100} -a["t"].x = function (self, a,b) return self.i+a+b end - -assert(a.t:x(2,3) == -95) - -do - local a = {x=0} - function a:add (x) self.x, a.y = self.x+x, 20; return self end - assert(a:add(10):add(20):add(30).x == 60 and a.y == 20) -end - -local a = {b={c={}}} - -function a.b.c.f1 (x) return x+1 end -function a.b.c:f2 (x,y) self[x] = y end -assert(a.b.c.f1(4) == 5) -a.b.c:f2('k', 12); assert(a.b.c.k == 12) - -print('+') - -t = nil -- 'declare' t -function f(a,b,c) local d = 'a'; t={a,b,c,d} end - -f( -- this line change must be valid - 1,2) -assert(t[1] == 1 and t[2] == 2 and t[3] == nil and t[4] == 'a') -f(1,2, -- this one too - 3,4) -assert(t[1] == 1 and t[2] == 2 and t[3] == 3 and t[4] == 'a') - -function fat(x) - if x <= 1 then return 1 - else return x*load("return fat(" .. x-1 .. ")")() - end -end - -assert(load "load 'assert(fat(6)==720)' () ")() -a = load('return fat(5), 3') -a,b = a() -assert(a == 120 and b == 3) -print('+') - -function err_on_n (n) - if n==0 then error(); exit(1); - else err_on_n (n-1); exit(1); - end -end - -do - function dummy (n) - if n > 0 then - assert(not pcall(err_on_n, n)) - dummy(n-1) - end - end -end - -dummy(10) - -function deep (n) - if n>0 then deep(n-1) end -end -deep(10) -deep(200) - --- testing tail call -function deep (n) if n>0 then return deep(n-1) else return 101 end end -assert(deep(30000) == 101) -a = {} -function a:deep (n) if n>0 then return self:deep(n-1) else return 101 end end -assert(a:deep(30000) == 101) - -print('+') - - -a = nil -(function (x) a=x end)(23) -assert(a == 23 and (function (x) return x*2 end)(20) == 40) - - --- testing closures - --- fixed-point operator -Z = function (le) - local function a (f) - return le(function (x) return f(f)(x) end) - end - return a(a) - end - - --- non-recursive factorial - -F = function (f) - return function (n) - if n == 0 then return 1 - else return n*f(n-1) end - end - end - -fat = Z(F) - -assert(fat(0) == 1 and fat(4) == 24 and Z(F)(5)==5*Z(F)(4)) - -local function g (z) - local function f (a,b,c,d) - return function (x,y) return a+b+c+d+a+x+y+z end - end - return f(z,z+1,z+2,z+3) -end - -f = g(10) -assert(f(9, 16) == 10+11+12+13+10+9+16+10) - -Z, F, f = nil -print('+') - --- testing multiple returns - -function unlpack (t, i) - i = i or 1 - if (i <= #t) then - return t[i], unlpack(t, i+1) - end -end - -function equaltab (t1, t2) - assert(#t1 == #t2) - for i = 1, #t1 do - assert(t1[i] == t2[i]) - end -end - -local pack = function (...) return (table.pack(...)) end - -function f() return 1,2,30,4 end -function ret2 (a,b) return a,b end - -local a,b,c,d = unlpack{1,2,3} -assert(a==1 and b==2 and c==3 and d==nil) -a = {1,2,3,4,false,10,'alo',false,assert} -equaltab(pack(unlpack(a)), a) -equaltab(pack(unlpack(a), -1), {1,-1}) -a,b,c,d = ret2(f()), ret2(f()) -assert(a==1 and b==1 and c==2 and d==nil) -a,b,c,d = unlpack(pack(ret2(f()), ret2(f()))) -assert(a==1 and b==1 and c==2 and d==nil) -a,b,c,d = unlpack(pack(ret2(f()), (ret2(f())))) -assert(a==1 and b==1 and c==nil and d==nil) - -a = ret2{ unlpack{1,2,3}, unlpack{3,2,1}, unlpack{"a", "b"}} -assert(a[1] == 1 and a[2] == 3 and a[3] == "a" and a[4] == "b") - - --- testing calls with 'incorrect' arguments -rawget({}, "x", 1) -rawset({}, "x", 1, 2) -assert(math.sin(1,2) == math.sin(1)) -table.sort({10,9,8,4,19,23,0,0}, function (a,b) return a" then - assert(val==nil) - else - assert(t[key] == val) - local mp = T.hash(key, t) - if l[i] then - assert(l[i] == mp) - elseif mp ~= i then - l[i] = mp - else -- list head - l[mp] = {mp} -- first element - while next do - assert(ff <= next and next < hsize) - if l[next] then assert(l[next] == mp) else l[next] = mp end - table.insert(l[mp], next) - key,val,next = T.querytab(t, next) - assert(key) - end - end - end - end - l.asize = asize; l.hsize = hsize; l.ff = ff - return l -end - -function mostra (t) - local asize, hsize, ff = T.querytab(t) - print(asize, hsize, ff) - print'------' - for i=0,asize-1 do - local _, v = T.querytab(t, i) - print(string.format("[%d] -", i), v) - end - print'------' - for i=0,hsize-1 do - print(i, T.querytab(t, i+asize)) - end - print'-------------' -end - -function stat (t) - t = checktable(t) - local nelem, nlist = 0, 0 - local maxlist = {} - for i=0,t.hsize-1 do - if type(t[i]) == 'table' then - local n = table.getn(t[i]) - nlist = nlist+1 - nelem = nelem + n - if not maxlist[n] then maxlist[n] = 0 end - maxlist[n] = maxlist[n]+1 - end - end - print(string.format("hsize=%d elements=%d load=%.2f med.len=%.2f (asize=%d)", - t.hsize, nelem, nelem/t.hsize, nelem/nlist, t.asize)) - for i=1,table.getn(maxlist) do - local n = maxlist[i] or 0 - print(string.format("%5d %10d %.2f%%", i, n, n*100/nlist)) - end -end - diff --git a/utils/lua_tests/closure.lua b/utils/lua_tests/closure.lua deleted file mode 100644 index 738002d2a..000000000 --- a/utils/lua_tests/closure.lua +++ /dev/null @@ -1,244 +0,0 @@ -print "testing closures" - -local A,B = 0,{g=10} -function f(x) - local a = {} - for i=1,1000 do - local y = 0 - do - a[i] = function () B.g = B.g+1; y = y+x; return y+A end - end - end - local dummy = function () return a[A] end - collectgarbage() - A = 1; assert(dummy() == a[1]); A = 0; - assert(a[1]() == x) - assert(a[3]() == x) - collectgarbage() - assert(B.g == 12) - return a -end - -local a = f(10) --- force a GC in this level -local x = {[1] = {}} -- to detect a GC -setmetatable(x, {__mode = 'kv'}) -while x[1] do -- repeat until GC - local a = A..A..A..A -- create garbage - A = A+1 -end -assert(a[1]() == 20+A) -assert(a[1]() == 30+A) -assert(a[2]() == 10+A) -collectgarbage() -assert(a[2]() == 20+A) -assert(a[2]() == 30+A) -assert(a[3]() == 20+A) -assert(a[8]() == 10+A) -assert(getmetatable(x).__mode == 'kv') -assert(B.g == 19) - - --- testing equality -a = {} -for i = 1, 5 do a[i] = function (x) return x + a + _ENV end end -assert(a[3] == a[4] and a[4] == a[5]) - -for i = 1, 5 do a[i] = function (x) return i + a + _ENV end end -assert(a[3] ~= a[4] and a[4] ~= a[5]) - -local function f() - return function (x) return math.sin(_ENV[x]) end -end -assert(f() == f()) - - --- testing closures with 'for' control variable -a = {} -for i=1,10 do - a[i] = {set = function(x) i=x end, get = function () return i end} - if i == 3 then break end -end -assert(a[4] == nil) -a[1].set(10) -assert(a[2].get() == 2) -a[2].set('a') -assert(a[3].get() == 3) -assert(a[2].get() == 'a') - -a = {} -local t = {"a", "b"} -for i = 1, #t do - local k = t[i] - a[i] = {set = function(x, y) i=x; k=y end, - get = function () return i, k end} - if i == 2 then break end -end -a[1].set(10, 20) -local r,s = a[2].get() -assert(r == 2 and s == 'b') -r,s = a[1].get() -assert(r == 10 and s == 20) -a[2].set('a', 'b') -r,s = a[2].get() -assert(r == "a" and s == "b") - - --- testing closures with 'for' control variable x break -for i=1,3 do - f = function () return i end - break -end -assert(f() == 1) - -for k = 1, #t do - local v = t[k] - f = function () return k, v end - break -end -assert(({f()})[1] == 1) -assert(({f()})[2] == "a") - - --- testing closure x break x return x errors - -local b -function f(x) - local first = 1 - while 1 do - if x == 3 and not first then return end - local a = 'xuxu' - b = function (op, y) - if op == 'set' then - a = x+y - else - return a - end - end - if x == 1 then do break end - elseif x == 2 then return - else if x ~= 3 then error() end - end - first = nil - end -end - -for i=1,3 do - f(i) - assert(b('get') == 'xuxu') - b('set', 10); assert(b('get') == 10+i) - b = nil -end - -pcall(f, 4); -assert(b('get') == 'xuxu') -b('set', 10); assert(b('get') == 14) - - -local w --- testing multi-level closure -function f(x) - return function (y) - return function (z) return w+x+y+z end - end -end - -y = f(10) -w = 1.345 -assert(y(20)(30) == 60+w) - --- testing closures x repeat-until - -local a = {} -local i = 1 -repeat - local x = i - a[i] = function () i = x+1; return x end -until i > 10 or a[i]() ~= x -assert(i == 11 and a[1]() == 1 and a[3]() == 3 and i == 4) - - --- testing closures created in 'then' and 'else' parts of 'if's -a = {} -for i = 1, 10 do - if i % 3 == 0 then - local y = 0 - a[i] = function (x) local t = y; y = x; return t end - elseif i % 3 == 1 then - goto L1 - error'not here' - ::L1:: - local y = 1 - a[i] = function (x) local t = y; y = x; return t end - elseif i % 3 == 2 then - local t - goto l4 - ::l4a:: a[i] = t; goto l4b - error("should never be here!") - ::l4:: - local y = 2 - t = function (x) local t = y; y = x; return t end - goto l4a - error("should never be here!") - ::l4b:: - end -end - -for i = 1, 10 do - assert(a[i](i * 10) == i % 3 and a[i]() == i * 10) -end - -print'+' - - --- test for correctly closing upvalues in tail calls of vararg functions -local function t () - local function c(a,b) assert(a=="test" and b=="OK") end - local function v(f, ...) c("test", f() ~= 1 and "FAILED" or "OK") end - local x = 1 - return v(function() return x end) -end -t() - - --- test for debug manipulation of upvalues -local debug = require'debug' - -do - local a , b, c = 3, 5, 7 - foo1 = function () return a+b end; - foo2 = function () return b+a end; - do - local a = 10 - foo3 = function () return a+b end; - end -end - -assert(debug.upvalueid(foo1, 1)) -assert(debug.upvalueid(foo1, 2)) -assert(not pcall(debug.upvalueid, foo1, 3)) -assert(debug.upvalueid(foo1, 1) == debug.upvalueid(foo2, 2)) -assert(debug.upvalueid(foo1, 2) == debug.upvalueid(foo2, 1)) -assert(debug.upvalueid(foo3, 1)) -assert(debug.upvalueid(foo1, 1) ~= debug.upvalueid(foo3, 1)) -assert(debug.upvalueid(foo1, 2) == debug.upvalueid(foo3, 2)) - -assert(debug.upvalueid(string.gmatch("x", "x"), 1) ~= nil) - -assert(foo1() == 3 + 5 and foo2() == 5 + 3) -debug.upvaluejoin(foo1, 2, foo2, 2) -assert(foo1() == 3 + 3 and foo2() == 5 + 3) -assert(foo3() == 10 + 5) -debug.upvaluejoin(foo3, 2, foo2, 1) -assert(foo3() == 10 + 5) -debug.upvaluejoin(foo3, 2, foo2, 2) -assert(foo3() == 10 + 3) - -assert(not pcall(debug.upvaluejoin, foo1, 3, foo2, 1)) -assert(not pcall(debug.upvaluejoin, foo1, 1, foo2, 3)) -assert(not pcall(debug.upvaluejoin, foo1, 0, foo2, 1)) -assert(not pcall(debug.upvaluejoin, print, 1, foo2, 1)) -assert(not pcall(debug.upvaluejoin, {}, 1, foo2, 1)) -assert(not pcall(debug.upvaluejoin, foo1, 1, print, 1)) - -print'OK' diff --git a/utils/lua_tests/code.lua b/utils/lua_tests/code.lua deleted file mode 100644 index a0317c552..000000000 --- a/utils/lua_tests/code.lua +++ /dev/null @@ -1,182 +0,0 @@ -if T==nil then - (Message or print)('\a\n >>> testC not active: skipping opcode tests <<<\n\a') - return -end -print "testing code generation and optimizations" - - --- this code gave an error for the code checker -do - local function f (a) - for k,v,w in a do end - end -end - - -function check (f, ...) - local arg = {...} - local c = T.listcode(f) - for i=1, #arg do - -- print(arg[i], c[i]) - assert(string.find(c[i], '- '..arg[i]..' *%d')) - end - assert(c[#arg+2] == nil) -end - - -function checkequal (a, b) - a = T.listcode(a) - b = T.listcode(b) - for i = 1, #a do - a[i] = string.gsub(a[i], '%b()', '') -- remove line number - b[i] = string.gsub(b[i], '%b()', '') -- remove line number - assert(a[i] == b[i]) - end -end - - --- some basic instructions -check(function () - (function () end){f()} -end, 'CLOSURE', 'NEWTABLE', 'GETTABUP', 'CALL', 'SETLIST', 'CALL', 'RETURN') - - --- sequence of LOADNILs -check(function () - local a,b,c - local d; local e; - local f,g,h; - d = nil; d=nil; b=nil; a=nil; c=nil; -end, 'LOADNIL', 'RETURN') - -check(function () - local a,b,c,d = 1,1,1,1 - d=nil;c=nil;b=nil;a=nil -end, 'LOADK', 'LOADK', 'LOADK', 'LOADK', 'LOADNIL', 'RETURN') - -do - local a,b,c,d = 1,1,1,1 - d=nil;c=nil;b=nil;a=nil - assert(a == nil and b == nil and c == nil and d == nil) -end - - --- single return -check (function (a,b,c) return a end, 'RETURN') - - --- infinite loops -check(function () while true do local a = -1 end end, -'LOADK', 'JMP', 'RETURN') - -check(function () while 1 do local a = -1 end end, -'LOADK', 'JMP', 'RETURN') - -check(function () repeat local x = 1 until true end, -'LOADK', 'RETURN') - - --- concat optimization -check(function (a,b,c,d) return a..b..c..d end, - 'MOVE', 'MOVE', 'MOVE', 'MOVE', 'CONCAT', 'RETURN') - --- not -check(function () return not not nil end, 'LOADBOOL', 'RETURN') -check(function () return not not false end, 'LOADBOOL', 'RETURN') -check(function () return not not true end, 'LOADBOOL', 'RETURN') -check(function () return not not 1 end, 'LOADBOOL', 'RETURN') - --- direct access to locals -check(function () - local a,b,c,d - a = b*2 - c[4], a[b] = -((a + d/-20.5 - a[b]) ^ a.x), b -end, - 'LOADNIL', - 'MUL', - 'DIV', 'ADD', 'GETTABLE', 'SUB', 'GETTABLE', 'POW', - 'UNM', 'SETTABLE', 'SETTABLE', 'RETURN') - - --- direct access to constants -check(function () - local a,b - a.x = 0 - a.x = b - a[b] = 'y' - a = 1 - a - b = 1/a - b = 5+4 - a[true] = false -end, - 'LOADNIL', - 'SETTABLE', 'SETTABLE', 'SETTABLE', 'SUB', 'DIV', 'LOADK', - 'SETTABLE', 'RETURN') - --- constant folding -local function f () return -((2^8 + -(-1)) % 8)/2 * 4 - 3 end - -check(f, 'LOADK', 'RETURN') -assert(f() == -5) - - --- bug in constant folding for 5.1 -check(function () return -nil end, - 'LOADNIL', 'UNM', 'RETURN') - - -check(function () - local a,b,c - b[c], a = c, b - b[a], a = c, b - a, b = c, a - a = a -end, - 'LOADNIL', - 'MOVE', 'MOVE', 'SETTABLE', - 'MOVE', 'MOVE', 'MOVE', 'SETTABLE', - 'MOVE', 'MOVE', 'MOVE', - -- no code for a = a - 'RETURN') - - --- x == nil , x ~= nil -checkequal(function () if (a==nil) then a=1 end; if a~=nil then a=1 end end, - function () if (a==9) then a=1 end; if a~=9 then a=1 end end) - -check(function () if a==nil then a=1 end end, -'GETTABUP', 'EQ', 'JMP', 'SETTABUP', 'RETURN') - --- de morgan -checkequal(function () local a; if not (a or b) then b=a end end, - function () local a; if (not a and not b) then b=a end end) - -checkequal(function (l) local a; return 0 <= a and a <= l end, - function (l) local a; return not (not(a >= 0) or not(a <= l)) end) - - --- if-goto optimizations -check(function (a) - if a == 1 then goto l1 - elseif a == 2 then goto l2 - elseif a == 3 then goto l2 - else if a == 4 then goto l3 - else goto l3 - end - end - ::l1:: ::l2:: ::l3:: ::l4:: -end, 'EQ', 'JMP', 'EQ', 'JMP', 'EQ', 'JMP', 'EQ', 'JMP', 'JMP', 'RETURN') - -checkequal( -function (a) while a < 10 do a = a + 1 end end, -function (a) ::L2:: if not(a < 10) then goto L1 end; a = a + 1; - goto L2; ::L1:: end -) - -checkequal( -function (a) while a < 10 do a = a + 1 end end, -function (a) while true do if not(a < 10) then break end; a = a + 1; end end -) - -print 'OK' - diff --git a/utils/lua_tests/constructs.lua b/utils/lua_tests/constructs.lua deleted file mode 100644 index 6dd77fe29..000000000 --- a/utils/lua_tests/constructs.lua +++ /dev/null @@ -1,310 +0,0 @@ -;;print "testing syntax";; - -local debug = require "debug" - --- testing semicollons -do ;;; end -; do ; a = 3; assert(a == 3) end; -; - - --- testing priorities - -assert(2^3^2 == 2^(3^2)); -assert(2^3*4 == (2^3)*4); -assert(2^-2 == 1/4 and -2^- -2 == - - -4); -assert(not nil and 2 and not(2>3 or 3<2)); -assert(-3-1-5 == 0+0-9); -assert(-2^2 == -4 and (-2)^2 == 4 and 2*2-3-1 == 0); -assert(2*1+3/3 == 3 and 1+2 .. 3*1 == "33"); -assert(not(2+1 > 3*1) and "a".."b" > "a"); - -assert(not ((true or false) and nil)) -assert( true or false and nil) - --- old bug -assert((((1 or false) and true) or false) == true) -assert((((nil and true) or false) and true) == false) - -local a,b = 1,nil; -assert(-(1 or 2) == -1 and (1 and 2)+(-1.25 or -4) == 0.75); -x = ((b or a)+1 == 2 and (10 or a)+1 == 11); assert(x); -x = (((2<3) or 1) == true and (2<3 and 4) == 4); assert(x); - -x,y=1,2; -assert((x>y) and x or y == 2); -x,y=2,1; -assert((x>y) and x or y == 2); - -assert(1234567890 == tonumber('1234567890') and 1234567890+1 == 1234567891) - - --- silly loops -repeat until 1; repeat until true; -while false do end; while nil do end; - -do -- test old bug (first name could not be an `upvalue') - local a; function f(x) x={a=1}; x={x=1}; x={G=1} end -end - -function f (i) - if type(i) ~= 'number' then return i,'jojo'; end; - if i > 0 then return i, f(i-1); end; -end - -x = {f(3), f(5), f(10);}; -assert(x[1] == 3 and x[2] == 5 and x[3] == 10 and x[4] == 9 and x[12] == 1); -assert(x[nil] == nil) -x = {f'alo', f'xixi', nil}; -assert(x[1] == 'alo' and x[2] == 'xixi' and x[3] == nil); -x = {f'alo'..'xixi'}; -assert(x[1] == 'aloxixi') -x = {f{}} -assert(x[2] == 'jojo' and type(x[1]) == 'table') - - -local f = function (i) - if i < 10 then return 'a'; - elseif i < 20 then return 'b'; - elseif i < 30 then return 'c'; - end; -end - -assert(f(3) == 'a' and f(12) == 'b' and f(26) == 'c' and f(100) == nil) - -for i=1,1000 do break; end; -n=100; -i=3; -t = {}; -a=nil -while not a do - a=0; for i=1,n do for i=i,1,-1 do a=a+1; t[i]=1; end; end; -end -assert(a == n*(n+1)/2 and i==3); -assert(t[1] and t[n] and not t[0] and not t[n+1]) - -function f(b) - local x = 1; - repeat - local a; - if b==1 then local b=1; x=10; break - elseif b==2 then x=20; break; - elseif b==3 then x=30; - else local a,b,c,d=math.sin(1); x=x+1; - end - until x>=12; - return x; -end; - -assert(f(1) == 10 and f(2) == 20 and f(3) == 30 and f(4)==12) - - -local f = function (i) - if i < 10 then return 'a' - elseif i < 20 then return 'b' - elseif i < 30 then return 'c' - else return 8 - end -end - -assert(f(3) == 'a' and f(12) == 'b' and f(26) == 'c' and f(100) == 8) - -local a, b = nil, 23 -x = {f(100)*2+3 or a, a or b+2} -assert(x[1] == 19 and x[2] == 25) -x = {f=2+3 or a, a = b+2} -assert(x.f == 5 and x.a == 25) - -a={y=1} -x = {a.y} -assert(x[1] == 1) - -function f(i) - while 1 do - if i>0 then i=i-1; - else return; end; - end; -end; - -function g(i) - while 1 do - if i>0 then i=i-1 - else return end - end -end - -f(10); g(10); - -do - function f () return 1,2,3; end - local a, b, c = f(); - assert(a==1 and b==2 and c==3) - a, b, c = (f()); - assert(a==1 and b==nil and c==nil) -end - -local a,b = 3 and f(); -assert(a==1 and b==nil) - -function g() f(); return; end; -assert(g() == nil) -function g() return nil or f() end -a,b = g() -assert(a==1 and b==nil) - -print'+'; - - -f = [[ -return function ( a , b , c , d , e ) - local x = a >= b or c or ( d and e ) or nil - return x -end , { a = 1 , b = 2 >= 1 , } or { 1 }; -]] -f = string.gsub(f, "%s+", "\n"); -- force a SETLINE between opcodes -f,a = load(f)(); -assert(a.a == 1 and a.b) - -function g (a,b,c,d,e) - if not (a>=b or c or d and e or nil) then return 0; else return 1; end; -end - -function h (a,b,c,d,e) - while (a>=b or c or (d and e) or nil) do return 1; end; - return 0; -end; - -assert(f(2,1) == true and g(2,1) == 1 and h(2,1) == 1) -assert(f(1,2,'a') == 'a' and g(1,2,'a') == 1 and h(1,2,'a') == 1) -assert(f(1,2,'a') -~= -- force SETLINE before nil -nil, "") -assert(f(1,2,'a') == 'a' and g(1,2,'a') == 1 and h(1,2,'a') == 1) -assert(f(1,2,nil,1,'x') == 'x' and g(1,2,nil,1,'x') == 1 and - h(1,2,nil,1,'x') == 1) -assert(f(1,2,nil,nil,'x') == nil and g(1,2,nil,nil,'x') == 0 and - h(1,2,nil,nil,'x') == 0) -assert(f(1,2,nil,1,nil) == nil and g(1,2,nil,1,nil) == 0 and - h(1,2,nil,1,nil) == 0) - -assert(1 and 2<3 == true and 2<3 and 'a'<'b' == true) -x = 2<3 and not 3; assert(x==false) -x = 2<1 or (2>1 and 'a'); assert(x=='a') - - -do - local a; if nil then a=1; else a=2; end; -- this nil comes as PUSHNIL 2 - assert(a==2) -end - -function F(a) - assert(debug.getinfo(1, "n").name == 'F') - return a,2,3 -end - -a,b = F(1)~=nil; assert(a == true and b == nil); -a,b = F(nil)==nil; assert(a == true and b == nil) - ----------------------------------------------------------------- --- creates all combinations of --- [not] ([not] arg op [not] (arg op [not] arg )) --- and tests each one - -function ID(x) return x end - -function f(t, i) - local b = t.n - local res = math.fmod(math.floor(i/c), b)+1 - c = c*b - return t[res] -end - -local arg = {" ( 1 < 2 ) ", " ( 1 >= 2 ) ", " F ( ) ", " nil "; n=4} - -local op = {" and ", " or ", " == ", " ~= "; n=4} - -local neg = {" ", " not "; n=2} - -local i = 0 -repeat - c = 1 - local s = f(neg, i)..'ID('..f(neg, i)..f(arg, i)..f(op, i).. - f(neg, i)..'ID('..f(arg, i)..f(op, i)..f(neg, i)..f(arg, i)..'))' - local s1 = string.gsub(s, 'ID', '') - K,X,NX,WX1,WX2 = nil - s = string.format([[ - local a = %s - local b = not %s - K = b - local xxx; - if %s then X = a else X = b end - if %s then NX = b else NX = a end - while %s do WX1 = a; break end - while %s do WX2 = a; break end - repeat if (%s) then break end; assert(b) until not(%s) - ]], s1, s, s1, s, s1, s, s1, s, s) - assert(load(s))() - assert(X and not NX and not WX1 == K and not WX2 == K) - if math.fmod(i,4000) == 0 then print('+') end - i = i+1 -until i==c - -print '+' - ------------------------------------------------------------------- -print 'testing short-circuit optimizations' - -_ENV.GLOB1 = 1 -_ENV.GLOB2 = 2 - -local basiccases = { - {"nil", nil}, - {"false", false}, - {"true", true}, - {"10", 10}, - {"(_ENV.GLOB1 < _ENV.GLOB2)", true}, - {"(_ENV.GLOB2 < _ENV.GLOB1)", false}, -} - - -local binops = { - {" and ", function (a,b) if not a then return a else return b end end}, - {" or ", function (a,b) if a then return a else return b end end}, -} - -local mem = {basiccases} -- for memoization - -local function allcases (n) - if mem[n] then return mem[n] end - local res = {} - -- include all smaller cases - for _, v in ipairs(allcases(n - 1)) do - res[#res + 1] = v - end - for i = 1, n - 1 do - for _, v1 in ipairs(allcases(i)) do - for _, v2 in ipairs(allcases(n - i)) do - for _, op in ipairs(binops) do - res[#res + 1] = { - "(" .. v1[1] .. op[1] .. v2[1] .. ")", - op[2](v1[2], v2[2]) - } - end - end - end - print('+') - end - mem[n] = res -- memoize - return res -end - --- do not do too many combinations for soft tests -local level = _soft and 3 or 4 - -for _, v in pairs(allcases(level)) do - local res = load("return " .. v[1])() - assert(res == v[2]) -end ------------------------------------------------------------------- - -print'OK' diff --git a/utils/lua_tests/coroutine.lua b/utils/lua_tests/coroutine.lua deleted file mode 100644 index 85086e583..000000000 --- a/utils/lua_tests/coroutine.lua +++ /dev/null @@ -1,728 +0,0 @@ -print "testing coroutines" - -local debug = require'debug' - -local f - -local main, ismain = coroutine.running() -assert(type(main) == "thread" and ismain) -assert(not coroutine.resume(main)) -assert(not pcall(coroutine.yield)) - - - --- tests for multiple yield/resume arguments - -local function eqtab (t1, t2) - assert(#t1 == #t2) - for i = 1, #t1 do - local v = t1[i] - assert(t2[i] == v) - end -end - -_G.x = nil -- declare x -function foo (a, ...) - local x, y = coroutine.running() - assert(x == f and y == false) - assert(coroutine.status(f) == "running") - local arg = {...} - for i=1,#arg do - _G.x = {coroutine.yield(table.unpack(arg[i]))} - end - return table.unpack(a) -end - -f = coroutine.create(foo) -assert(type(f) == "thread" and coroutine.status(f) == "suspended") -assert(string.find(tostring(f), "thread")) -local s,a,b,c,d -s,a,b,c,d = coroutine.resume(f, {1,2,3}, {}, {1}, {'a', 'b', 'c'}) -assert(s and a == nil and coroutine.status(f) == "suspended") -s,a,b,c,d = coroutine.resume(f) -eqtab(_G.x, {}) -assert(s and a == 1 and b == nil) -s,a,b,c,d = coroutine.resume(f, 1, 2, 3) -eqtab(_G.x, {1, 2, 3}) -assert(s and a == 'a' and b == 'b' and c == 'c' and d == nil) -s,a,b,c,d = coroutine.resume(f, "xuxu") -eqtab(_G.x, {"xuxu"}) -assert(s and a == 1 and b == 2 and c == 3 and d == nil) -assert(coroutine.status(f) == "dead") -s, a = coroutine.resume(f, "xuxu") -assert(not s and string.find(a, "dead") and coroutine.status(f) == "dead") - - --- yields in tail calls -local function foo (i) return coroutine.yield(i) end -f = coroutine.wrap(function () - for i=1,10 do - assert(foo(i) == _G.x) - end - return 'a' -end) -for i=1,10 do _G.x = i; assert(f(i) == i) end -_G.x = 'xuxu'; assert(f('xuxu') == 'a') - --- recursive -function pf (n, i) - coroutine.yield(n) - pf(n*i, i+1) -end - -f = coroutine.wrap(pf) -local s=1 -for i=1,10 do - assert(f(1, 1) == s) - s = s*i -end - --- sieve -function gen (n) - return coroutine.wrap(function () - for i=2,n do coroutine.yield(i) end - end) -end - - -function filter (p, g) - return coroutine.wrap(function () - while 1 do - local n = g() - if n == nil then return end - if math.fmod(n, p) ~= 0 then coroutine.yield(n) end - end - end) -end - -local x = gen(100) -local a = {} -while 1 do - local n = x() - if n == nil then break end - table.insert(a, n) - x = filter(n, x) -end - -assert(#a == 25 and a[#a] == 97) - - --- yielding across C boundaries - -co = coroutine.wrap(function() - assert(not pcall(table.sort,{1,2,3}, coroutine.yield)) - coroutine.yield(20) - return 30 - end) - -assert(co() == 20) -assert(co() == 30) - - -local f = function (s, i) return coroutine.yield(i) end - -local f1 = coroutine.wrap(function () - return xpcall(pcall, function (...) return ... end, - function () - local s = 0 - for i in f, nil, 1 do pcall(function () s = s + i end) end - error({s}) - end) - end) - -f1() -for i = 1, 10 do assert(f1(i) == i) end -local r1, r2, v = f1(nil) -assert(r1 and not r2 and v[1] == (10 + 1)*10/2) - - -function f (a, b) a = coroutine.yield(a); error{a + b} end -function g(x) return x[1]*2 end - -co = coroutine.wrap(function () - coroutine.yield(xpcall(f, g, 10, 20)) - end) - -assert(co() == 10) -r, msg = co(100) -assert(not r and msg == 240) - - --- errors in coroutines -function foo () - assert(debug.getinfo(1).currentline == debug.getinfo(foo).linedefined + 1) - assert(debug.getinfo(2).currentline == debug.getinfo(goo).linedefined) - coroutine.yield(3) - error(foo) -end - -function goo() foo() end -x = coroutine.wrap(goo) -assert(x() == 3) -local a,b = pcall(x) -assert(not a and b == foo) - -x = coroutine.create(goo) -a,b = coroutine.resume(x) -assert(a and b == 3) -a,b = coroutine.resume(x) -assert(not a and b == foo and coroutine.status(x) == "dead") -a,b = coroutine.resume(x) -assert(not a and string.find(b, "dead") and coroutine.status(x) == "dead") - - --- co-routines x for loop -function all (a, n, k) - if k == 0 then coroutine.yield(a) - else - for i=1,n do - a[k] = i - all(a, n, k-1) - end - end -end - -local a = 0 -for t in coroutine.wrap(function () all({}, 5, 4) end) do - a = a+1 -end -assert(a == 5^4) - - --- access to locals of collected corroutines -local C = {}; setmetatable(C, {__mode = "kv"}) -local x = coroutine.wrap (function () - local a = 10 - local function f () a = a+10; return a end - while true do - a = a+1 - coroutine.yield(f) - end - end) - -C[1] = x; - -local f = x() -assert(f() == 21 and x()() == 32 and x() == f) -x = nil -collectgarbage() -assert(C[1] == nil) -assert(f() == 43 and f() == 53) - - --- old bug: attempt to resume itself - -function co_func (current_co) - assert(coroutine.running() == current_co) - assert(coroutine.resume(current_co) == false) - assert(coroutine.resume(current_co) == false) - return 10 -end - -local co = coroutine.create(co_func) -local a,b = coroutine.resume(co, co) -assert(a == true and b == 10) -assert(coroutine.resume(co, co) == false) -assert(coroutine.resume(co, co) == false) - - --- attempt to resume 'normal' coroutine -co1 = coroutine.create(function () return co2() end) -co2 = coroutine.wrap(function () - assert(coroutine.status(co1) == 'normal') - assert(not coroutine.resume(co1)) - coroutine.yield(3) - end) - -a,b = coroutine.resume(co1) -assert(a and b == 3) -assert(coroutine.status(co1) == 'dead') - --- infinite recursion of coroutines -a = function(a) coroutine.wrap(a)(a) end -assert(not pcall(a, a)) - - --- access to locals of erroneous coroutines -local x = coroutine.create (function () - local a = 10 - _G.f = function () a=a+1; return a end - error('x') - end) - -assert(not coroutine.resume(x)) --- overwrite previous position of local `a' -assert(not coroutine.resume(x, 1, 1, 1, 1, 1, 1, 1)) -assert(_G.f() == 11) -assert(_G.f() == 12) - - -if not T then - (Message or print)('\a\n >>> testC not active: skipping yield/hook tests <<<\n\a') -else - print "testing yields inside hooks" - - local turn - - function fact (t, x) - assert(turn == t) - if x == 0 then return 1 - else return x*fact(t, x-1) - end - end - - local A,B,a,b = 0,0,0,0 - - local x = coroutine.create(function () - T.sethook("yield 0", "", 2) - A = fact("A", 10) - end) - - local y = coroutine.create(function () - T.sethook("yield 0", "", 3) - B = fact("B", 11) - end) - - while A==0 or B==0 do - if A==0 then turn = "A"; assert(T.resume(x)) end - if B==0 then turn = "B"; assert(T.resume(y)) end - end - - assert(B/A == 11) - - local line = debug.getinfo(1, "l").currentline + 2 -- get line number - local function foo () - local x = 10 --<< this line is 'line' - x = x + 10 - _G.XX = x - end - - -- testing yields in line hook - local co = coroutine.wrap(function () - T.sethook("setglobal X; yield 0", "l", 0); foo(); return 10 end) - - _G.XX = nil; - _G.X = nil; co(); assert(_G.X == line) - _G.X = nil; co(); assert(_G.X == line + 1) - _G.X = nil; co(); assert(_G.X == line + 2 and _G.XX == nil) - _G.X = nil; co(); assert(_G.X == line + 3 and _G.XX == 20) - assert(co() == 10) - - -- testing yields in count hook - co = coroutine.wrap(function () - T.sethook("yield 0", "", 1); foo(); return 10 end) - - _G.XX = nil; - local c = 0 - repeat c = c + 1; local a = co() until a == 10 - assert(_G.XX == 20 and c == 10) - - co = coroutine.wrap(function () - T.sethook("yield 0", "", 2); foo(); return 10 end) - - _G.XX = nil; - local c = 0 - repeat c = c + 1; local a = co() until a == 10 - assert(_G.XX == 20 and c == 5) - _G.X = nil; _G.XX = nil - - - print "testing coroutine API" - - -- reusing a thread - assert(T.testC([[ - newthread # create thread - pushvalue 2 # push body - pushstring 'a a a' # push argument - xmove 0 3 2 # move values to new thread - resume -1, 1 # call it first time - pushstatus - xmove 3 0 0 # move results back to stack - setglobal X # result - setglobal Y # status - pushvalue 2 # push body (to call it again) - pushstring 'b b b' - xmove 0 3 2 - resume -1, 1 # call it again - pushstatus - xmove 3 0 0 - return 1 # return result - ]], function (...) return ... end) == 'b b b') - - assert(X == 'a a a' and Y == 'OK') - - - -- resuming running coroutine - C = coroutine.create(function () - return T.testC([[ - pushnum 10; - pushnum 20; - resume -3 2; - pushstatus - gettop; - return 3]], C) - end) - local a, b, c, d = coroutine.resume(C) - assert(a == true and string.find(b, "non%-suspended") and - c == "ERRRUN" and d == 4) - - a, b, c, d = T.testC([[ - rawgeti R 1 # get main thread - pushnum 10; - pushnum 20; - resume -3 2; - pushstatus - gettop; - return 4]]) - assert(a == coroutine.running() and string.find(b, "non%-suspended") and - c == "ERRRUN" and d == 4) - - - -- using a main thread as a coroutine - local state = T.newstate() - T.loadlib(state) - - assert(T.doremote(state, [[ - coroutine = require'coroutine'; - X = function (x) coroutine.yield(x, 'BB'); return 'CC' end; - return 'ok']])) - - t = table.pack(T.testC(state, [[ - rawgeti R 1 # get main thread - pushstring 'XX' - getglobal X # get function for body - pushstring AA # arg - resume 1 1 # 'resume' shadows previous stack! - gettop - setglobal T # top - setglobal B # second yielded value - setglobal A # fist yielded value - rawgeti R 1 # get main thread - pushnum 5 # arg (noise) - resume 1 1 # after coroutine ends, previous stack is back - pushstatus - gettop - return . - ]])) - assert(t.n == 4 and t[2] == 'XX' and t[3] == 'CC' and t[4] == 'OK') - assert(T.doremote(state, "return T") == '2') - assert(T.doremote(state, "return A") == 'AA') - assert(T.doremote(state, "return B") == 'BB') - - T.closestate(state) - - print'+' - -end - - --- leaving a pending coroutine open -_X = coroutine.wrap(function () - local a = 10 - local x = function () a = a+1 end - coroutine.yield() - end) - -_X() - - -if not _soft then - -- bug (stack overflow) - local j = 2^9 - local lim = 1000000 -- (C stack limit; assume 32-bit machine) - local t = {lim - 10, lim - 5, lim - 1, lim, lim + 1} - for i = 1, #t do - local j = t[i] - co = coroutine.create(function() - local t = {} - for i = 1, j do t[i] = i end - return table.unpack(t) - end) - local r, msg = coroutine.resume(co) - assert(not r) - end -end - - -assert(coroutine.running() == main) - -print"+" - - -print"testing yields inside metamethods" - -local mt = { - __eq = function(a,b) coroutine.yield(nil, "eq"); return a.x == b.x end, - __lt = function(a,b) coroutine.yield(nil, "lt"); return a.x < b.x end, - __le = function(a,b) coroutine.yield(nil, "le"); return a - b <= 0 end, - __add = function(a,b) coroutine.yield(nil, "add"); return a.x + b.x end, - __sub = function(a,b) coroutine.yield(nil, "sub"); return a.x - b.x end, - __concat = function(a,b) - coroutine.yield(nil, "concat"); - a = type(a) == "table" and a.x or a - b = type(b) == "table" and b.x or b - return a .. b - end, - __index = function (t,k) coroutine.yield(nil, "idx"); return t.k[k] end, - __newindex = function (t,k,v) coroutine.yield(nil, "nidx"); t.k[k] = v end, -} - - -local function new (x) - return setmetatable({x = x, k = {}}, mt) -end - - -local a = new(10) -local b = new(12) -local c = new"hello" - -local function run (f, t) - local i = 1 - local c = coroutine.wrap(f) - while true do - local res, stat = c() - if res then assert(t[i] == nil); return res, t end - assert(stat == t[i]) - i = i + 1 - end -end - - -assert(run(function () if (a>=b) then return '>=' else return '<' end end, - {"le", "sub"}) == "<") --- '<=' using '<' -mt.__le = nil -assert(run(function () if (a<=b) then return '<=' else return '>' end end, - {"lt"}) == "<=") -assert(run(function () if (a==b) then return '==' else return '~=' end end, - {"eq"}) == "~=") - -assert(run(function () return a..b end, {"concat"}) == "1012") - -assert(run(function() return a .. b .. c .. a end, - {"concat", "concat", "concat"}) == "1012hello10") - -assert(run(function() return "a" .. "b" .. a .. "c" .. c .. b .. "x" end, - {"concat", "concat", "concat"}) == "ab10chello12x") - -assert(run(function () - a.BB = print - return a.BB - end, {"nidx", "idx"}) == print) - --- getuptable & setuptable -do local _ENV = _ENV - f = function () AAA = BBB + 1; return AAA end -end -g = new(10); g.k.BBB = 10; -debug.setupvalue(f, 1, g) -assert(run(f, {"idx", "nidx", "idx"}) == 11) -assert(g.k.AAA == 11) - -print"+" - -print"testing yields inside 'for' iterators" - -local f = function (s, i) - if i%2 == 0 then coroutine.yield(nil, "for") end - if i < s then return i + 1 end - end - -assert(run(function () - local s = 0 - for i in f, 4, 0 do s = s + i end - return s - end, {"for", "for", "for"}) == 10) - - - --- tests for coroutine API -if T==nil then - (Message or print)('\a\n >>> testC not active: skipping coroutine API tests <<<\n\a') - return -end - -print('testing coroutine API') - -local function apico (...) - local x = {...} - return coroutine.wrap(function () - return T.testC(table.unpack(x)) - end) -end - -local a = {apico( -[[ - pushstring errorcode - pcallk 1 0 2; - invalid command (should not arrive here) -]], -[[getctx; gettop; return .]], -"stackmark", -error -)()} -assert(#a == 6 and - a[3] == "stackmark" and - a[4] == "errorcode" and - a[5] == "ERRRUN" and - a[6] == 2) -- 'ctx' to pcallk - -local co = apico( - "pushvalue 2; pushnum 10; pcallk 1 2 3; invalid command;", - coroutine.yield, - "getctx; pushvalue 2; pushstring a; pcallk 1 0 4; invalid command", - "getctx; gettop; return .") - -assert(co() == 10) -assert(co(20, 30) == 'a') -a = {co()} -assert(#a == 10 and - a[2] == coroutine.yield and - a[5] == 20 and a[6] == 30 and - a[7] == "YIELD" and a[8] == 3 and - a[9] == "YIELD" and a[10] == 4) -assert(not pcall(co)) -- coroutine is dead now - - -f = T.makeCfunc("pushnum 3; pushnum 5; yield 1;") -co = coroutine.wrap(function () - assert(f() == 23); assert(f() == 23); return 10 -end) -assert(co(23,16) == 5) -assert(co(23,16) == 5) -assert(co(23,16) == 10) - - --- testing coroutines with C bodies -f = T.makeCfunc([[ - pushnum 102 - yieldk 1 U2 - return 2 -]], -[[ - pushnum 23 # continuation - gettop - return . -]]) - -x = coroutine.wrap(f) -assert(x() == 102) -assert(x() == 23) - - -f = T.makeCfunc[[pushstring 'a'; pushnum 102; yield 2; ]] - -a, b, c, d = T.testC([[newthread; pushvalue 2; xmove 0 3 1; resume 3 0; - pushstatus; xmove 3 0 0; resume 3 0; pushstatus; - return 4; ]], f) - -assert(a == 'YIELD' and b == 'a' and c == 102 and d == 'OK') - - --- testing chain of suspendable C calls - -local count = 3 -- number of levels - -f = T.makeCfunc([[ - remove 1; # remove argument - pushvalue U3; # get selection function - call 0 1; # call it (result is 'f' or 'yield') - pushstring hello # single argument for selected function - pushupvalueindex 2; # index of continuation program - callk 1 -1 .; # call selected function - errorerror # should never arrive here -]], -[[ - # continuation program - pushnum 34 # return value - gettop - return . # return all results -]], -function () -- selection function - count = count - 1 - if count == 0 then return coroutine.yield - else return f - end -end -) - -co = coroutine.wrap(function () return f(nil) end) -assert(co() == "hello") -- argument to 'yield' -a = {co()} --- three '34's (one from each pending C call) -assert(#a == 3 and a[1] == a[2] and a[2] == a[3] and a[3] == 34) - - --- testing yields with continuations - -co = coroutine.wrap(function (...) return - T.testC([[ - getctx - yieldk 3 2 - nonexec error - ]], - [[ # continuation - getctx - yieldk 2 3 - ]], - [[ # continuation - getctx - yieldk 2 4 - ]], - [[ # continuation - pushvalue 6; pushnum 10; pushnum 20; - pcall 2 0 # call should throw an error and execution continues - pop 1 # remove error message - pushvalue 6 - getctx - pcallk 2 2 5 # call should throw an error and jump to continuation - cannot be here! - ]], - [[ # continuation - gettop - return . - ]], - function (a,b) x=a; y=b; error("errmsg") end, - ... -) -end) - -local a = {co(3,4,6)}; assert(a[1] == 6 and a[2] == "OK" and a[3] == 0) -a = {co()}; assert(a[1] == "YIELD" and a[2] == 2) -a = {co()}; assert(a[1] == "YIELD" and a[2] == 3) -a = {co(7,8)}; --- original arguments -assert(type(a[1]) == 'string' and type(a[2]) == 'string' and - type(a[3]) == 'string' and type(a[4]) == 'string' and - type(a[5]) == 'string' and type(a[6]) == 'function') --- arguments left from fist resume -assert(a[7] == 3 and a[8] == 4) --- arguments to last resume -assert(a[9] == 7 and a[10] == 8) --- error message and nothing more -assert(a[11]:find("errmsg") and #a == 11) --- check arguments to pcallk -assert(x == "YIELD" and y == 4) - -assert(not pcall(co)) -- coroutine should be dead - --- testing ctx - -a,b = T.testC( - [[ pushstring print; pcallk 0 0 12 # error - getctx; return 2 ]]) -assert(a == "OK" and b == 0) -- no ctx outside continuations - - --- bug in nCcalls -local co = coroutine.wrap(function () - local a = {pcall(pcall,pcall,pcall,pcall,pcall,pcall,pcall,error,"hi")} - return pcall(assert, table.unpack(a)) -end) - -local a = {co()} -assert(a[10] == "hi") - - -print'OK' diff --git a/utils/lua_tests/db.lua b/utils/lua_tests/db.lua deleted file mode 100644 index d3d8c25bb..000000000 --- a/utils/lua_tests/db.lua +++ /dev/null @@ -1,631 +0,0 @@ --- testing debug library - -debug = require "debug" - -local function dostring(s) return assert(load(s))() end - -print"testing debug library and debug information" - -do -local a=1 -end - -function test (s, l, p) - collectgarbage() -- avoid gc during trace - local function f (event, line) - assert(event == 'line') - local l = table.remove(l, 1) - if p then print(l, line) end - assert(l == line, "wrong trace!!") - end - debug.sethook(f,"l"); load(s)(); debug.sethook() - assert(#l == 0) -end - - -do - assert(not pcall(debug.getinfo, print, "X")) -- invalid option - assert(debug.getinfo(1000) == nil) -- out of range level - assert(debug.getinfo(-1) == nil) -- out of range level - local a = debug.getinfo(print) - assert(a.what == "C" and a.short_src == "[C]") - a = debug.getinfo(print, "L") - assert(a.activelines == nil) - local b = debug.getinfo(test, "SfL") - assert(b.name == nil and b.what == "Lua" and b.linedefined == 13 and - b.lastlinedefined == b.linedefined + 10 and - b.func == test and not string.find(b.short_src, "%[")) - assert(b.activelines[b.linedefined + 1] and - b.activelines[b.lastlinedefined]) - assert(not b.activelines[b.linedefined] and - not b.activelines[b.lastlinedefined + 1]) -end - - --- test file and string names truncation -a = "function f () end" -local function dostring (s, x) return load(s, x)() end -dostring(a) -assert(debug.getinfo(f).short_src == string.format('[string "%s"]', a)) -dostring(a..string.format("; %s\n=1", string.rep('p', 400))) -assert(string.find(debug.getinfo(f).short_src, '^%[string [^\n]*%.%.%."%]$')) -dostring(a..string.format("; %s=1", string.rep('p', 400))) -assert(string.find(debug.getinfo(f).short_src, '^%[string [^\n]*%.%.%."%]$')) -dostring("\n"..a) -assert(debug.getinfo(f).short_src == '[string "..."]') -dostring(a, "") -assert(debug.getinfo(f).short_src == '[string ""]') -dostring(a, "@xuxu") -assert(debug.getinfo(f).short_src == "xuxu") -dostring(a, "@"..string.rep('p', 1000)..'t') -assert(string.find(debug.getinfo(f).short_src, "^%.%.%.p*t$")) -dostring(a, "=xuxu") -assert(debug.getinfo(f).short_src == "xuxu") -dostring(a, string.format("=%s", string.rep('x', 500))) -assert(string.find(debug.getinfo(f).short_src, "^x*$")) -dostring(a, "=") -assert(debug.getinfo(f).short_src == "") -a = nil; f = nil; - - -repeat - local g = {x = function () - local a = debug.getinfo(2) - assert(a.name == 'f' and a.namewhat == 'local') - a = debug.getinfo(1) - assert(a.name == 'x' and a.namewhat == 'field') - return 'xixi' - end} - local f = function () return 1+1 and (not 1 or g.x()) end - assert(f() == 'xixi') - g = debug.getinfo(f) - assert(g.what == "Lua" and g.func == f and g.namewhat == "" and not g.name) - - function f (x, name) -- local! - name = name or 'f' - local a = debug.getinfo(1) - assert(a.name == name and a.namewhat == 'local') - return x - end - - -- breaks in different conditions - if 3>4 then break end; f() - if 3<4 then a=1 else break end; f() - while 1 do local x=10; break end; f() - local b = 1 - if 3>4 then return math.sin(1) end; f() - a = 3<4; f() - a = 3<4 or 1; f() - repeat local x=20; if 4>3 then f() else break end; f() until 1 - g = {} - f(g).x = f(2) and f(10)+f(9) - assert(g.x == f(19)) - function g(x) if not x then return 3 end return (x('a', 'x')) end - assert(g(f) == 'a') -until 1 - -test([[if -math.sin(1) -then - a=1 -else - a=2 -end -]], {2,3,4,7}) - -test([[-- -if nil then - a=1 -else - a=2 -end -]], {2,5,6}) - -test([[a=1 -repeat - a=a+1 -until a==3 -]], {1,3,4,3,4}) - -test([[ do - return -end -]], {2}) - -test([[local a -a=1 -while a<=3 do - a=a+1 -end -]], {1,2,3,4,3,4,3,4,3,5}) - -test([[while math.sin(1) do - if math.sin(1) - then break - end -end -a=1]], {1,2,3,6}) - -test([[for i=1,3 do - a=i -end -]], {1,2,1,2,1,2,1,3}) - -test([[for i,v in pairs{'a','b'} do - a=i..v -end -]], {1,2,1,2,1,3}) - -test([[for i=1,4 do a=1 end]], {1,1,1,1,1}) - - - -print'+' - --- invalid levels in [gs]etlocal -assert(not pcall(debug.getlocal, 20, 1)) -assert(not pcall(debug.setlocal, -1, 1, 10)) - - --- parameter names -local function foo (a,b,...) local d, e end -local co = coroutine.create(foo) - -assert(debug.getlocal(foo, 1) == 'a') -assert(debug.getlocal(foo, 2) == 'b') -assert(debug.getlocal(foo, 3) == nil) -assert(debug.getlocal(co, foo, 1) == 'a') -assert(debug.getlocal(co, foo, 2) == 'b') -assert(debug.getlocal(co, foo, 3) == nil) - -assert(debug.getlocal(print, 1) == nil) - - --- varargs -local function foo (a, ...) - local t = table.pack(...) - for i = 1, t.n do - local n, v = debug.getlocal(1, -i) - assert(n == "(*vararg)" and v == t[i]) - end - assert(not debug.getlocal(1, -(t.n + 1))) - assert(not debug.setlocal(1, -(t.n + 1), 30)) - if t.n > 0 then - (function (x) - assert(debug.setlocal(2, -1, x) == "(*vararg)") - assert(debug.setlocal(2, -t.n, x) == "(*vararg)") - end)(430) - assert(... == 430) - end -end - -foo() -foo(print) -foo(200, 3, 4) -local a = {} -for i = 1,1000 do a[i] = i end -foo(table.unpack(a)) -a = nil - --- access to vararg in non-vararg function -local function foo () return debug.getlocal(1, -1) end -assert(foo(10) == nil) - - -a = {}; L = nil -local glob = 1 -local oldglob = glob -debug.sethook(function (e,l) - collectgarbage() -- force GC during a hook - local f, m, c = debug.gethook() - assert(m == 'crl' and c == 0) - if e == "line" then - if glob ~= oldglob then - L = l-1 -- get the first line where "glob" has changed - oldglob = glob - end - elseif e == "call" then - local f = debug.getinfo(2, "f").func - a[f] = 1 - else assert(e == "return") - end -end, "crl") - - -function f(a,b) - collectgarbage() - local _, x = debug.getlocal(1, 1) - local _, y = debug.getlocal(1, 2) - assert(x == a and y == b) - assert(debug.setlocal(2, 3, "pera") == "AA".."AA") - assert(debug.setlocal(2, 4, "maçã") == "B") - x = debug.getinfo(2) - assert(x.func == g and x.what == "Lua" and x.name == 'g' and - x.nups == 1 and string.find(x.source, "^@.*db%.lua$")) - glob = glob+1 - assert(debug.getinfo(1, "l").currentline == L+1) - assert(debug.getinfo(1, "l").currentline == L+2) -end - -function foo() - glob = glob+1 - assert(debug.getinfo(1, "l").currentline == L+1) -end; foo() -- set L --- check line counting inside strings and empty lines - -_ = 'alo\ -alo' .. [[ - -]] ---[[ -]] -assert(debug.getinfo(1, "l").currentline == L+11) -- check count of lines - - -function g(...) - local arg = {...} - do local a,b,c; a=math.sin(40); end - local feijao - local AAAA,B = "xuxu", "mamão" - f(AAAA,B) - assert(AAAA == "pera" and B == "maçã") - do - local B = 13 - local x,y = debug.getlocal(1,5) - assert(x == 'B' and y == 13) - end -end - -g() - - -assert(a[f] and a[g] and a[assert] and a[debug.getlocal] and not a[print]) - - --- tests for manipulating non-registered locals (C and Lua temporaries) - -local n, v = debug.getlocal(0, 1) -assert(v == 0 and n == "(*temporary)") -local n, v = debug.getlocal(0, 2) -assert(v == 2 and n == "(*temporary)") -assert(not debug.getlocal(0, 3)) -assert(not debug.getlocal(0, 0)) - -function f() - assert(select(2, debug.getlocal(2,3)) == 1) - assert(not debug.getlocal(2,4)) - debug.setlocal(2, 3, 10) - return 20 -end - -function g(a,b) return (a+1) + f() end - -assert(g(0,0) == 30) - - -debug.sethook(nil); -assert(debug.gethook() == nil) - - --- testing access to function arguments - -X = nil -a = {} -function a:f (a, b, ...) local arg = {...}; local c = 13 end -debug.sethook(function (e) - assert(e == "call") - dostring("XX = 12") -- test dostring inside hooks - -- testing errors inside hooks - assert(not pcall(load("a='joao'+1"))) - debug.sethook(function (e, l) - assert(debug.getinfo(2, "l").currentline == l) - local f,m,c = debug.gethook() - assert(e == "line") - assert(m == 'l' and c == 0) - debug.sethook(nil) -- hook is called only once - assert(not X) -- check that - X = {}; local i = 1 - local x,y - while 1 do - x,y = debug.getlocal(2, i) - if x==nil then break end - X[x] = y - i = i+1 - end - end, "l") -end, "c") - -a:f(1,2,3,4,5) -assert(X.self == a and X.a == 1 and X.b == 2 and X.c == nil) -assert(XX == 12) -assert(debug.gethook() == nil) - - --- testing upvalue access -local function getupvalues (f) - local t = {} - local i = 1 - while true do - local name, value = debug.getupvalue(f, i) - if not name then break end - assert(not t[name]) - t[name] = value - i = i + 1 - end - return t -end - -local a,b,c = 1,2,3 -local function foo1 (a) b = a; return c end -local function foo2 (x) a = x; return c+b end -assert(debug.getupvalue(foo1, 3) == nil) -assert(debug.getupvalue(foo1, 0) == nil) -assert(debug.setupvalue(foo1, 3, "xuxu") == nil) -local t = getupvalues(foo1) -assert(t.a == nil and t.b == 2 and t.c == 3) -t = getupvalues(foo2) -assert(t.a == 1 and t.b == 2 and t.c == 3) -assert(debug.setupvalue(foo1, 1, "xuxu") == "b") -assert(({debug.getupvalue(foo2, 3)})[2] == "xuxu") --- upvalues of C functions are allways "called" "" (the empty string) -assert(debug.getupvalue(string.gmatch("x", "x"), 1) == "") - - --- testing count hooks -local a=0 -debug.sethook(function (e) a=a+1 end, "", 1) -a=0; for i=1,1000 do end; assert(1000 < a and a < 1012) -debug.sethook(function (e) a=a+1 end, "", 4) -a=0; for i=1,1000 do end; assert(250 < a and a < 255) -local f,m,c = debug.gethook() -assert(m == "" and c == 4) -debug.sethook(function (e) a=a+1 end, "", 4000) -a=0; for i=1,1000 do end; assert(a == 0) - -if not _no32 then - debug.sethook(print, "", 2^24 - 1) -- count upperbound - local f,m,c = debug.gethook() - assert(({debug.gethook()})[3] == 2^24 - 1) -end - -debug.sethook() - - --- tests for tail calls -local function f (x) - if x then - assert(debug.getinfo(1, "S").what == "Lua") - assert(debug.getinfo(1, "t").istailcall == true) - local tail = debug.getinfo(2) - assert(tail.func == g1 and tail.istailcall == true) - assert(debug.getinfo(3, "S").what == "main") - print"+" - end -end - -function g(x) return f(x) end - -function g1(x) g(x) end - -local function h (x) local f=g1; return f(x) end - -h(true) - -local b = {} -debug.sethook(function (e) table.insert(b, e) end, "cr") -h(false) -debug.sethook() -local res = {"return", -- first return (from sethook) - "call", "tail call", "call", "tail call", - "return", "return", - "call", -- last call (to sethook) -} -for i = 1, #res do assert(res[i] == table.remove(b, 1)) end - -b = 0 -debug.sethook(function (e) - if e == "tail call" then - b = b + 1 - assert(debug.getinfo(2, "t").istailcall == true) - else - assert(debug.getinfo(2, "t").istailcall == false) - end - end, "c") -h(false) -debug.sethook() -assert(b == 2) -- two tail calls - -lim = 30000 -if _soft then limit = 3000 end -local function foo (x) - if x==0 then - assert(debug.getinfo(2).what == "main") - local info = debug.getinfo(1) - assert(info.istailcall == true and info.func == foo) - else return foo(x-1) - end -end - -foo(lim) - - -print"+" - - --- testing local function information -co = load[[ - local A = function () - return x - end - return -]] - -local a = 0 --- 'A' should be visible to debugger only after its complete definition -debug.sethook(function (e, l) - if l == 3 then a = a + 1; assert(debug.getlocal(2, 1) == "(*temporary)") - elseif l == 4 then a = a + 1; assert(debug.getlocal(2, 1) == "A") - end -end, "l") -co() -- run local function definition -debug.sethook() -- turn off hook -assert(a == 2) -- ensure all two lines where hooked - --- testing traceback - -assert(debug.traceback(print) == print) -assert(debug.traceback(print, 4) == print) -assert(string.find(debug.traceback("hi", 4), "^hi\n")) -assert(string.find(debug.traceback("hi"), "^hi\n")) -assert(not string.find(debug.traceback("hi"), "'traceback'")) -assert(string.find(debug.traceback("hi", 0), "'traceback'")) -assert(string.find(debug.traceback(), "^stack traceback:\n")) - - --- testing nparams, nups e isvararg -local t = debug.getinfo(print, "u") -assert(t.isvararg == true and t.nparams == 0 and t.nups == 0) - -t = debug.getinfo(function (a,b,c) end, "u") -assert(t.isvararg == false and t.nparams == 3 and t.nups == 0) - -t = debug.getinfo(function (a,b,...) return t[a] end, "u") -assert(t.isvararg == true and t.nparams == 2 and t.nups == 1) - -t = debug.getinfo(1) -- main -assert(t.isvararg == true and t.nparams == 0 and t.nups == 1 and - debug.getupvalue(t.func, 1) == "_ENV") - - --- testing debugging of coroutines - -local function checktraceback (co, p, level) - local tb = debug.traceback(co, nil, level) - local i = 0 - for l in string.gmatch(tb, "[^\n]+\n?") do - assert(i == 0 or string.find(l, p[i])) - i = i+1 - end - assert(p[i] == nil) -end - - -local function f (n) - if n > 0 then f(n-1) - else coroutine.yield() end -end - -local co = coroutine.create(f) -coroutine.resume(co, 3) -checktraceback(co, {"yield", "db.lua", "db.lua", "db.lua", "db.lua"}) -checktraceback(co, {"db.lua", "db.lua", "db.lua", "db.lua"}, 1) -checktraceback(co, {"db.lua", "db.lua", "db.lua"}, 2) -checktraceback(co, {"db.lua"}, 4) -checktraceback(co, {}, 40) - - -co = coroutine.create(function (x) - local a = 1 - coroutine.yield(debug.getinfo(1, "l")) - coroutine.yield(debug.getinfo(1, "l").currentline) - return a - end) - -local tr = {} -local foo = function (e, l) if l then table.insert(tr, l) end end -debug.sethook(co, foo, "lcr") - -local _, l = coroutine.resume(co, 10) -local x = debug.getinfo(co, 1, "lfLS") -assert(x.currentline == l.currentline and x.activelines[x.currentline]) -assert(type(x.func) == "function") -for i=x.linedefined + 1, x.lastlinedefined do - assert(x.activelines[i]) - x.activelines[i] = nil -end -assert(next(x.activelines) == nil) -- no 'extra' elements -assert(debug.getinfo(co, 2) == nil) -local a,b = debug.getlocal(co, 1, 1) -assert(a == "x" and b == 10) -a,b = debug.getlocal(co, 1, 2) -assert(a == "a" and b == 1) -debug.setlocal(co, 1, 2, "hi") -assert(debug.gethook(co) == foo) -assert(#tr == 2 and - tr[1] == l.currentline-1 and tr[2] == l.currentline) - -a,b,c = pcall(coroutine.resume, co) -assert(a and b and c == l.currentline+1) -checktraceback(co, {"yield", "in function <"}) - -a,b = coroutine.resume(co) -assert(a and b == "hi") -assert(#tr == 4 and tr[4] == l.currentline+2) -assert(debug.gethook(co) == foo) -assert(debug.gethook() == nil) -checktraceback(co, {}) - - --- check traceback of suspended (or dead with error) coroutines - -function f(i) if i==0 then error(i) else coroutine.yield(); f(i-1) end end - -co = coroutine.create(function (x) f(x) end) -a, b = coroutine.resume(co, 3) -t = {"'yield'", "'f'", "in function <"} -while coroutine.status(co) == "suspended" do - checktraceback(co, t) - a, b = coroutine.resume(co) - table.insert(t, 2, "'f'") -- one more recursive call to 'f' -end -t[1] = "'error'" -checktraceback(co, t) - - --- test acessing line numbers of a coroutine from a resume inside --- a C function (this is a known bug in Lua 5.0) - -local function g(x) - coroutine.yield(x) -end - -local function f (i) - debug.sethook(function () end, "l") - for j=1,1000 do - g(i+j) - end -end - -local co = coroutine.wrap(f) -co(10) -pcall(co) -pcall(co) - - -assert(type(debug.getregistry()) == "table") - - --- test tagmethod information -local a = {} -local function f (t) - local info = debug.getinfo(1); - assert(info.namewhat == "metamethod") - a.op = info.name - return info.name -end -setmetatable(a, { - __index = f; __add = f; __div = f; __mod = f; __concat = f; __pow = f; - __eq = f; __le = f; __lt = f; -}) - -local b = setmetatable({}, getmetatable(a)) - -assert(a[3] == "__index" and a^3 == "__pow" and a..a == "__concat") -assert(a/3 == "__div" and 3%a == "__mod") -assert (a==b and a.op == "__eq") -assert (a>=b and a.op == "__le") -assert (a>b and a.op == "__lt") - - -print"OK" - diff --git a/utils/lua_tests/errors.lua b/utils/lua_tests/errors.lua deleted file mode 100644 index 6d91bdc0b..000000000 --- a/utils/lua_tests/errors.lua +++ /dev/null @@ -1,422 +0,0 @@ -print("testing errors") - -local debug = require"debug" - --- avoid problems with 'strict' module (which may generate other error messages) -local mt = getmetatable(_G) or {} -local oldmm = mt.__index -mt.__index = nil - -function doit (s) - local f, msg = load(s) - if f == nil then return msg end - local cond, msg = pcall(f) - return (not cond) and msg -end - - -function checkmessage (prog, msg) - local m = doit(prog) - assert(string.find(m, msg, 1, true)) -end - -function checksyntax (prog, extra, token, line) - local msg = doit(prog) - if not string.find(token, "^<%a") and not string.find(token, "^char%(") - then token = "'"..token.."'" end - token = string.gsub(token, "(%p)", "%%%1") - local pt = string.format([[^%%[string ".*"%%]:%d: .- near %s$]], - line, token) - assert(string.find(msg, pt)) - assert(string.find(msg, msg, 1, true)) -end - - --- test error message with no extra info -assert(doit("error('hi', 0)") == 'hi') - --- test error message with no info -assert(doit("error()") == nil) - - --- test common errors/errors that crashed in the past -if not _no32 then - assert(doit("table.unpack({}, 1, n=2^30)")) -end -assert(doit("a=math.sin()")) -assert(not doit("tostring(1)") and doit("tostring()")) -assert(doit"tonumber()") -assert(doit"repeat until 1; a") -assert(doit"return;;") -assert(doit"assert(false)") -assert(doit"assert(nil)") -assert(doit("function a (... , ...) end")) -assert(doit("function a (, ...) end")) -assert(doit("local t={}; t = t[#t] + 1")) - -checksyntax([[ - local a = {4 - -]], "'}' expected (to close '{' at line 1)", "", 3) - - --- tests for better error messages - -checkmessage("a=1; bbbb=2; a=math.sin(3)+bbbb(3)", "global 'bbbb'") -checkmessage("a=1; local a,bbbb=2,3; a = math.sin(1) and bbbb(3)", - "local 'bbbb'") -checkmessage("a={}; do local a=1 end a:bbbb(3)", "method 'bbbb'") -checkmessage("local a={}; a.bbbb(3)", "field 'bbbb'") -assert(not string.find(doit"a={13}; local bbbb=1; a[bbbb](3)", "'bbbb'")) -checkmessage("a={13}; local bbbb=1; a[bbbb](3)", "number") -checkmessage("a=(1)..{}", "a table value") - -aaa = nil -checkmessage("aaa.bbb:ddd(9)", "global 'aaa'") -checkmessage("local aaa={bbb=1}; aaa.bbb:ddd(9)", "field 'bbb'") -checkmessage("local aaa={bbb={}}; aaa.bbb:ddd(9)", "method 'ddd'") -checkmessage("local a,b,c; (function () a = b+1 end)()", "upvalue 'b'") -assert(not doit"local aaa={bbb={ddd=next}}; aaa.bbb:ddd(nil)") - -checkmessage("local _ENV = {x={}}; a = a + 1", "global 'a'") - -checkmessage("b=1; local aaa='a'; x=aaa+b", "local 'aaa'") -checkmessage("aaa={}; x=3/aaa", "global 'aaa'") -checkmessage("aaa='2'; b=nil;x=aaa*b", "global 'b'") -checkmessage("aaa={}; x=-aaa", "global 'aaa'") -assert(not string.find(doit"aaa={}; x=(aaa or aaa)+(aaa and aaa)", "'aaa'")) -assert(not string.find(doit"aaa={}; (aaa or aaa)()", "'aaa'")) - -checkmessage("print(print < 10)", "function") -checkmessage("print(print < print)", "two function") - - --- passing light userdata instead of full userdata -_G.D = debug -checkmessage([[ - -- create light udata - local x = D.upvalueid(function () return debug end, 1) - D.setuservalue(x, {}) -]], "light userdata") -_G.D = nil - - --- global functions -checkmessage("(io.write or print){}", "io.write") -checkmessage("(collectgarbage or print){}", "collectgarbage") - --- tests for field accesses after RK limit -local t = {} -for i = 1, 1000 do - t[i] = "a = x" .. i -end -local s = table.concat(t, "; ") -t = nil -checkmessage(s.."; a = bbb + 1", "global 'bbb'") -checkmessage("local _ENV=_ENV;"..s.."; a = bbb + 1", "global 'bbb'") -checkmessage(s.."; local t = {}; a = t.bbb + 1", "field 'bbb'") -checkmessage(s.."; local t = {}; t:bbb()", "method 'bbb'") - -checkmessage([[aaa=9 -repeat until 3==3 -local x=math.sin(math.cos(3)) -if math.sin(1) == x then return math.sin(1) end -- tail call -local a,b = 1, { - {x='a'..'b'..'c', y='b', z=x}, - {1,2,3,4,5} or 3+3<=3+3, - 3+1>3+1, - {d = x and aaa[x or y]}} -]], "global 'aaa'") - -checkmessage([[ -local x,y = {},1 -if math.sin(1) == 0 then return 3 end -- return -x.a()]], "field 'a'") - -checkmessage([[ -prefix = nil -insert = nil -while 1 do - local a - if nil then break end - insert(prefix, a) -end]], "global 'insert'") - -checkmessage([[ -- tail call - return math.sin("a") -]], "'sin'") - -checkmessage([[collectgarbage("nooption")]], "invalid option") - -checkmessage([[x = print .. "a"]], "concatenate") - -checkmessage("getmetatable(io.stdin).__gc()", "no value") - -checkmessage([[ -local Var -local function main() - NoSuchName (function() Var=0 end) -end -main() -]], "global 'NoSuchName'") -print'+' - -a = {}; setmetatable(a, {__index = string}) -checkmessage("a:sub()", "bad self") -checkmessage("string.sub('a', {})", "#2") -checkmessage("('a'):sub{}", "#1") - -checkmessage("table.sort({1,2,3}, table.sort)", "'table.sort'") --- next message may be 'setmetatable' or '_G.setmetatable' -checkmessage("string.gsub('s', 's', setmetatable)", "setmetatable'") - --- tests for errors in coroutines - -function f (n) - local c = coroutine.create(f) - local a,b = coroutine.resume(c) - return b -end -assert(string.find(f(), "C stack overflow")) - -checkmessage("coroutine.yield()", "outside a coroutine") - -f1 = function () table.sort({1,2,3}, coroutine.yield) end -f = coroutine.wrap(function () return pcall(f1) end) -assert(string.find(select(2, f()), "yield across")) - - --- testing size of 'source' info; size of buffer for that info is --- LUA_IDSIZE, declared as 60 in luaconf. Get one position for '\0'. -idsize = 60 - 1 -local function checksize (source) - -- syntax error - local _, msg = load("x", source) - msg = string.match(msg, "^([^:]*):") -- get source (1st part before ':') - assert(msg:len() <= idsize) -end - -for i = 60 - 10, 60 + 10 do -- check border cases around 60 - checksize("@" .. string.rep("x", i)) -- file names - checksize(string.rep("x", i - 10)) -- string sources - checksize("=" .. string.rep("x", i)) -- exact sources -end - - --- testing line error - -local function lineerror (s, l) - local err,msg = pcall(load(s)) - local line = string.match(msg, ":(%d+):") - assert((line and line+0) == l) -end - -lineerror("local a\n for i=1,'a' do \n print(i) \n end", 2) -lineerror("\n local a \n for k,v in 3 \n do \n print(k) \n end", 3) -lineerror("\n\n for k,v in \n 3 \n do \n print(k) \n end", 4) -lineerror("function a.x.y ()\na=a+1\nend", 1) - -lineerror("a = \na\n+\n{}", 3) -lineerror("a = \n3\n+\n(\n4\n/\nprint)", 6) -lineerror("a = \nprint\n+\n(\n4\n/\n7)", 3) - -lineerror("a\n=\n-\n\nprint\n;", 3) - -lineerror([[ -a -( -23) -]], 1) - -lineerror([[ -local a = {x = 13} -a -. -x -( -23 -) -]], 2) - -lineerror([[ -local a = {x = 13} -a -. -x -( -23 + a -) -]], 6) - -local p = [[ -function g() f() end -function f(x) error('a', X) end -g() -]] -X=3;lineerror((p), 3) -X=0;lineerror((p), nil) -X=1;lineerror((p), 2) -X=2;lineerror((p), 1) - - -if not _soft then - -- several tests that exaust the Lua stack - C = 0 - local l = debug.getinfo(1, "l").currentline; function y () C=C+1; y() end - - local function checkstackmessage (m) - return (string.find(m, "^.-:%d+: stack overflow")) - end - -- repeated stack overflows (to check stack recovery) - assert(checkstackmessage(doit('y()'))) - print('+') - assert(checkstackmessage(doit('y()'))) - print('+') - assert(checkstackmessage(doit('y()'))) - print('+') - - - -- error lines in stack overflow - C = 0 - local l1 - local function g(x) - l1 = debug.getinfo(x, "l").currentline; y() - end - local _, stackmsg = xpcall(g, debug.traceback, 1) - print('+') - local stack = {} - for line in string.gmatch(stackmsg, "[^\n]*") do - local curr = string.match(line, ":(%d+):") - if curr then table.insert(stack, tonumber(curr)) end - end - local i=1 - while stack[i] ~= l1 do - assert(stack[i] == l) - i = i+1 - end - assert(i > 15) - - - -- error in error handling - local res, msg = xpcall(error, error) - assert(not res and type(msg) == 'string') - print('+') - - local function f (x) - if x==0 then error('a\n') - else - local aux = function () return f(x-1) end - local a,b = xpcall(aux, aux) - return a,b - end - end - f(3) - - local function loop (x,y,z) return 1 + loop(x, y, z) end - - local res, msg = xpcall(loop, function (m) - assert(string.find(m, "stack overflow")) - local res, msg = pcall(loop) - assert(string.find(msg, "error handling")) - assert(math.sin(0) == 0) - return 15 - end) - assert(msg == 15) - - res, msg = pcall(function () - for i = 999900, 1000000, 1 do table.unpack({}, 1, i) end - end) - assert(string.find(msg, "too many results")) - -end - - --- non string messages -function f() error{msg='x'} end -res, msg = xpcall(f, function (r) return {msg=r.msg..'y'} end) -assert(msg.msg == 'xy') - --- xpcall with arguments -a, b, c = xpcall(string.find, error, "alo", "al") -assert(a and b == 1 and c == 2) -a, b, c = xpcall(string.find, function (x) return {} end, true, "al") -assert(not a and type(b) == "table" and c == nil) - -print('+') -checksyntax("syntax error", "", "error", 1) -checksyntax("1.000", "", "1.000", 1) -checksyntax("[[a]]", "", "[[a]]", 1) -checksyntax("'aa'", "", "'aa'", 1) - --- test 255 as first char in a chunk -checksyntax("\255a = 1", "", "char(255)", 1) - -doit('I = load("a=9+"); a=3') -assert(a==3 and I == nil) -print('+') - -lim = 1000 -if _soft then lim = 100 end -for i=1,lim do - doit('a = ') - doit('a = 4+nil') -end - - --- testing syntax limits -local function testrep (init, rep) - local s = "local a; "..init .. string.rep(rep, 400) - local a,b = load(s) - assert(not a and string.find(b, "levels")) -end -testrep("a=", "{") -testrep("a=", "(") -testrep("", "a(") -testrep("", "do ") -testrep("", "while a do ") -testrep("", "if a then else ") -testrep("", "function foo () ") -testrep("a=", "a..") -testrep("a=", "a^") - -local s = ("a,"):rep(200).."a=nil" -local a,b = load(s) -assert(not a and string.find(b, "levels")) - - --- testing other limits --- upvalues -local lim = 127 -local s = "local function fooA ()\n local " -for j = 1,lim do - s = s.."a"..j..", " -end -s = s.."b,c\n" -s = s.."local function fooB ()\n local " -for j = 1,lim do - s = s.."b"..j..", " -end -s = s.."b\n" -s = s.."function fooC () return b+c" -local c = 1+2 -for j = 1,lim do - s = s.."+a"..j.."+b"..j - c = c + 2 -end -s = s.."\nend end end" -local a,b = load(s) -assert(c > 255 and string.find(b, "too many upvalues") and - string.find(b, "line 5")) - --- local variables -s = "\nfunction foo ()\n local " -for j = 1,300 do - s = s.."a"..j..", " -end -s = s.."b\n" -local a,b = load(s) -assert(string.find(b, "line 2")) - -mt.__index = oldmm - -print('OK') diff --git a/utils/lua_tests/events.lua b/utils/lua_tests/events.lua deleted file mode 100644 index b3e5c4124..000000000 --- a/utils/lua_tests/events.lua +++ /dev/null @@ -1,388 +0,0 @@ -print('testing metatables') - -X = 20; B = 30 - -_ENV = setmetatable({}, {__index=_G}) - -collectgarbage() - -X = X+10 -assert(X == 30 and _G.X == 20) -B = false -assert(B == false) -B = nil -assert(B == 30) - -assert(getmetatable{} == nil) -assert(getmetatable(4) == nil) -assert(getmetatable(nil) == nil) -a={}; setmetatable(a, {__metatable = "xuxu", - __tostring=function(x) return x.name end}) -assert(getmetatable(a) == "xuxu") -assert(tostring(a) == nil) --- cannot change a protected metatable -assert(pcall(setmetatable, a, {}) == false) -a.name = "gororoba" -assert(tostring(a) == "gororoba") - -local a, t = {10,20,30; x="10", y="20"}, {} -assert(setmetatable(a,t) == a) -assert(getmetatable(a) == t) -assert(setmetatable(a,nil) == a) -assert(getmetatable(a) == nil) -assert(setmetatable(a,t) == a) - - -function f (t, i, e) - assert(not e) - local p = rawget(t, "parent") - return (p and p[i]+3), "dummy return" -end - -t.__index = f - -a.parent = {z=25, x=12, [4] = 24} -assert(a[1] == 10 and a.z == 28 and a[4] == 27 and a.x == "10") - -collectgarbage() - -a = setmetatable({}, t) -function f(t, i, v) rawset(t, i, v-3) end -setmetatable(t, t) -- causes a bug in 5.1 ! -t.__newindex = f -a[1] = 30; a.x = "101"; a[5] = 200 -assert(a[1] == 27 and a.x == 98 and a[5] == 197) - - -local c = {} -a = setmetatable({}, t) -t.__newindex = c -a[1] = 10; a[2] = 20; a[3] = 90 -assert(c[1] == 10 and c[2] == 20 and c[3] == 90) - - -do - local a; - a = setmetatable({}, {__index = setmetatable({}, - {__index = setmetatable({}, - {__index = function (_,n) return a[n-3]+4, "lixo" end})})}) - a[0] = 20 - for i=0,10 do - assert(a[i*3] == 20 + i*4) - end -end - - -do -- newindex - local foi - local a = {} - for i=1,10 do a[i] = 0; a['a'..i] = 0; end - setmetatable(a, {__newindex = function (t,k,v) foi=true; rawset(t,k,v) end}) - foi = false; a[1]=0; assert(not foi) - foi = false; a['a1']=0; assert(not foi) - foi = false; a['a11']=0; assert(foi) - foi = false; a[11]=0; assert(foi) - foi = false; a[1]=nil; assert(not foi) - foi = false; a[1]=nil; assert(foi) -end - - -setmetatable(t, nil) -function f (t, ...) return t, {...} end -t.__call = f - -do - local x,y = a(table.unpack{'a', 1}) - assert(x==a and y[1]=='a' and y[2]==1 and y[3]==nil) - x,y = a() - assert(x==a and y[1]==nil) -end - - -local b = setmetatable({}, t) -setmetatable(b,t) - -function f(op) - return function (...) cap = {[0] = op, ...} ; return (...) end -end -t.__add = f("add") -t.__sub = f("sub") -t.__mul = f("mul") -t.__div = f("div") -t.__mod = f("mod") -t.__unm = f("unm") -t.__pow = f("pow") -t.__len = f("len") - -assert(b+5 == b) -assert(cap[0] == "add" and cap[1] == b and cap[2] == 5 and cap[3]==nil) -assert(b+'5' == b) -assert(cap[0] == "add" and cap[1] == b and cap[2] == '5' and cap[3]==nil) -assert(5+b == 5) -assert(cap[0] == "add" and cap[1] == 5 and cap[2] == b and cap[3]==nil) -assert('5'+b == '5') -assert(cap[0] == "add" and cap[1] == '5' and cap[2] == b and cap[3]==nil) -b=b-3; assert(getmetatable(b) == t) -assert(5-a == 5) -assert(cap[0] == "sub" and cap[1] == 5 and cap[2] == a and cap[3]==nil) -assert('5'-a == '5') -assert(cap[0] == "sub" and cap[1] == '5' and cap[2] == a and cap[3]==nil) -assert(a*a == a) -assert(cap[0] == "mul" and cap[1] == a and cap[2] == a and cap[3]==nil) -assert(a/0 == a) -assert(cap[0] == "div" and cap[1] == a and cap[2] == 0 and cap[3]==nil) -assert(a%2 == a) -assert(cap[0] == "mod" and cap[1] == a and cap[2] == 2 and cap[3]==nil) -assert(-a == a) -assert(cap[0] == "unm" and cap[1] == a) -assert(a^4 == a) -assert(cap[0] == "pow" and cap[1] == a and cap[2] == 4 and cap[3]==nil) -assert(a^'4' == a) -assert(cap[0] == "pow" and cap[1] == a and cap[2] == '4' and cap[3]==nil) -assert(4^a == 4) -assert(cap[0] == "pow" and cap[1] == 4 and cap[2] == a and cap[3]==nil) -assert('4'^a == '4') -assert(cap[0] == "pow" and cap[1] == '4' and cap[2] == a and cap[3]==nil) -assert(#a == a) -assert(cap[0] == "len" and cap[1] == a) - - --- test for rawlen -t = setmetatable({1,2,3}, {__len = function () return 10 end}) -assert(#t == 10 and rawlen(t) == 3) -assert(rawlen"abc" == 3) -assert(not pcall(rawlen, io.stdin)) -assert(not pcall(rawlen, 34)) -assert(not pcall(rawlen)) - -t = {} -t.__lt = function (a,b,c) - collectgarbage() - assert(c == nil) - if type(a) == 'table' then a = a.x end - if type(b) == 'table' then b = b.x end - return aOp(1)) and not(Op(1)>Op(2)) and (Op(2)>Op(1))) - assert(not(Op('a')>Op('a')) and not(Op('a')>Op('b')) and (Op('b')>Op('a'))) - assert((Op(1)>=Op(1)) and not(Op(1)>=Op(2)) and (Op(2)>=Op(1))) - assert((1 >= Op(1)) and not(1 >= Op(2)) and (Op(2) >= 1)) - assert((Op('a')>=Op('a')) and not(Op('a')>=Op('b')) and (Op('b')>=Op('a'))) - assert(('a' >= Op('a')) and not(Op('a') >= 'b') and (Op('b') >= Op('a'))) -end - -test() - -t.__le = function (a,b,c) - assert(c == nil) - if type(a) == 'table' then a = a.x end - if type(b) == 'table' then b = b.x end - return a<=b, "dummy" -end - -test() -- retest comparisons, now using both `lt' and `le' - - --- test `partial order' - -local function Set(x) - local y = {} - for _,k in pairs(x) do y[k] = 1 end - return setmetatable(y, t) -end - -t.__lt = function (a,b) - for k in pairs(a) do - if not b[k] then return false end - b[k] = nil - end - return next(b) ~= nil -end - -t.__le = nil - -assert(Set{1,2,3} < Set{1,2,3,4}) -assert(not(Set{1,2,3,4} < Set{1,2,3,4})) -assert((Set{1,2,3,4} <= Set{1,2,3,4})) -assert((Set{1,2,3,4} >= Set{1,2,3,4})) -assert((Set{1,3} <= Set{3,5})) -- wrong!! model needs a `le' method ;-) - -t.__le = function (a,b) - for k in pairs(a) do - if not b[k] then return false end - end - return true -end - -assert(not (Set{1,3} <= Set{3,5})) -- now its OK! -assert(not(Set{1,3} <= Set{3,5})) -assert(not(Set{1,3} >= Set{3,5})) - -t.__eq = function (a,b) - for k in pairs(a) do - if not b[k] then return false end - b[k] = nil - end - return next(b) == nil -end - -local s = Set{1,3,5} -assert(s == Set{3,5,1}) -assert(not rawequal(s, Set{3,5,1})) -assert(rawequal(s, s)) -assert(Set{1,3,5,1} == Set{3,5,1}) -assert(Set{1,3,5} ~= Set{3,5,1,6}) -t[Set{1,3,5}] = 1 -assert(t[Set{1,3,5}] == nil) -- `__eq' is not valid for table accesses - - -t.__concat = function (a,b,c) - assert(c == nil) - if type(a) == 'table' then a = a.val end - if type(b) == 'table' then b = b.val end - if A then return a..b - else - return setmetatable({val=a..b}, t) - end -end - -c = {val="c"}; setmetatable(c, t) -d = {val="d"}; setmetatable(d, t) - -A = true -assert(c..d == 'cd') -assert(0 .."a".."b"..c..d.."e".."f"..(5+3).."g" == "0abcdef8g") - -A = false -assert((c..d..c..d).val == 'cdcd') -x = c..d -assert(getmetatable(x) == t and x.val == 'cd') -x = 0 .."a".."b"..c..d.."e".."f".."g" -assert(x.val == "0abcdefg") - - --- concat metamethod x numbers (bug in 5.1.1) -c = {} -local x -setmetatable(c, {__concat = function (a,b) - assert(type(a) == "number" and b == c or type(b) == "number" and a == c) - return c -end}) -assert(c..5 == c and 5 .. c == c) -assert(4 .. c .. 5 == c and 4 .. 5 .. 6 .. 7 .. c == c) - - --- test comparison compatibilities -local t1, t2, c, d -t1 = {}; c = {}; setmetatable(c, t1) -d = {} -t1.__eq = function () return true end -t1.__lt = function () return true end -setmetatable(d, t1) -assert(c == d and c < d and not(d <= c)) -t2 = {} -t2.__eq = t1.__eq -t2.__lt = t1.__lt -setmetatable(d, t2) -assert(c == d and c < d and not(d <= c)) - - - --- test for several levels of calls -local i -local tt = { - __call = function (t, ...) - i = i+1 - if t.f then return t.f(...) - else return {...} - end - end -} - -local a = setmetatable({}, tt) -local b = setmetatable({f=a}, tt) -local c = setmetatable({f=b}, tt) - -i = 0 -x = c(3,4,5) -assert(i == 3 and x[1] == 3 and x[3] == 5) - - -assert(_G.X == 20) - -print'+' - -local _g = _G -_ENV = setmetatable({}, {__index=function (_,k) return _g[k] end}) - - -a = {} -rawset(a, "x", 1, 2, 3) -assert(a.x == 1 and rawget(a, "x", 3) == 1) - -print '+' - --- testing metatables for basic types -local debug = require'debug' -mt = {} -debug.setmetatable(10, mt) -assert(getmetatable(-2) == mt) -mt.__index = function (a,b) return a+b end -assert((10)[3] == 13) -assert((10)["3"] == 13) -debug.setmetatable(23, nil) -assert(getmetatable(-2) == nil) - -debug.setmetatable(true, mt) -assert(getmetatable(false) == mt) -mt.__index = function (a,b) return a or b end -assert((true)[false] == true) -assert((false)[false] == false) -debug.setmetatable(false, nil) -assert(getmetatable(true) == nil) - -debug.setmetatable(nil, mt) -assert(getmetatable(nil) == mt) -mt.__add = function (a,b) return (a or 0) + (b or 0) end -assert(10 + nil == 10) -assert(nil + 23 == 23) -assert(nil + nil == 0) -debug.setmetatable(nil, nil) -assert(getmetatable(nil) == nil) - -debug.setmetatable(nil, {}) - - --- loops in delegation -a = {}; setmetatable(a, a); a.__index = a; a.__newindex = a -assert(not pcall(function (a,b) return a[b] end, a, 10)) -assert(not pcall(function (a,b,c) a[b] = c end, a, 10, true)) - --- bug in 5.1 -T, K, V = nil -grandparent = {} -grandparent.__newindex = function(t,k,v) T=t; K=k; V=v end - -parent = {} -parent.__newindex = parent -setmetatable(parent, grandparent) - -child = setmetatable({}, parent) -child.foo = 10 --> CRASH (on some machines) -assert(T == parent and K == "foo" and V == 10) - -print 'OK' - -return 12 - - diff --git a/utils/lua_tests/files.lua b/utils/lua_tests/files.lua deleted file mode 100644 index db7e24550..000000000 --- a/utils/lua_tests/files.lua +++ /dev/null @@ -1,615 +0,0 @@ -debug = require "debug" - -assert(type(os.getenv"PATH") == "string") - -assert(io.input(io.stdin) == io.stdin) -assert(not pcall(io.input, "non-existent-file")) -assert(io.output(io.stdout) == io.stdout) - --- cannot close standard files -assert(not io.close(io.stdin) and - not io.stdout:close() and - not io.stderr:close()) - - -assert(type(io.input()) == "userdata" and io.type(io.output()) == "file") -assert(type(io.stdin) == "userdata" and io.type(io.stderr) == "file") -assert(io.type(8) == nil) -local a = {}; setmetatable(a, {}) -assert(io.type(a) == nil) - -local a,b,c = io.open('xuxu_nao_existe') -assert(not a and type(b) == "string" and type(c) == "number") - -a,b,c = io.open('/a/b/c/d', 'w') -assert(not a and type(b) == "string" and type(c) == "number") - -local file = os.tmpname() -local f, msg = io.open(file, "w") -if not f then - (Message or print)("'os.tmpname' file cannot be open; skipping file tests") - -else --{ most tests here need tmpname -f:close() - -print('testing i/o') - -local otherfile = os.tmpname() - -assert(not pcall(io.open, file, "rw")) -- invalid mode -assert(not pcall(io.open, file, "rb+")) -- invalid mode -assert(not pcall(io.open, file, "r+bk")) -- invalid mode -assert(not pcall(io.open, file, "")) -- invalid mode -assert(not pcall(io.open, file, "+")) -- invalid mode -assert(not pcall(io.open, file, "b")) -- invalid mode -assert(io.open(file, "r+b")):close() -assert(io.open(file, "r+")):close() -assert(io.open(file, "rb")):close() - -assert(os.setlocale('C', 'all')) - -io.input(io.stdin); io.output(io.stdout); - -os.remove(file) -assert(loadfile(file) == nil) -assert(io.open(file) == nil) -io.output(file) -assert(io.output() ~= io.stdout) - -assert(io.output():seek() == 0) -assert(io.write("alo alo"):seek() == string.len("alo alo")) -assert(io.output():seek("cur", -3) == string.len("alo alo")-3) -assert(io.write("joao")) -assert(io.output():seek("end") == string.len("alo joao")) - -assert(io.output():seek("set") == 0) - -assert(io.write('"álo"', "{a}\n", "second line\n", "third line \n")) -assert(io.write('çfourth_line')) -io.output(io.stdout) -collectgarbage() -- file should be closed by GC -assert(io.input() == io.stdin and rawequal(io.output(), io.stdout)) -print('+') - --- test GC for files -collectgarbage() -for i=1,120 do - for i=1,5 do - io.input(file) - assert(io.open(file, 'r')) - io.lines(file) - end - collectgarbage() -end - -io.input():close() -io.close() - -assert(os.rename(file, otherfile)) -assert(os.rename(file, otherfile) == nil) - -io.output(io.open(otherfile, "ab")) -assert(io.write("\n\n\t\t 3450\n")); -io.close() - --- test line generators -assert(not pcall(io.lines, "non-existent-file")) -assert(os.rename(otherfile, file)) -io.output(otherfile) -local f = io.lines(file) -while f() do end; -assert(not pcall(f)) -- read lines after EOF -assert(not pcall(f)) -- read lines after EOF --- copy from file to otherfile -for l in io.lines(file) do io.write(l, "\n") end -io.close() --- copy from otherfile back to file -local f = assert(io.open(otherfile)) -assert(io.type(f) == "file") -io.output(file) -assert(io.output():read() == nil) -for l in f:lines() do io.write(l, "\n") end -assert(tostring(f):sub(1, 5) == "file ") -assert(f:close()); io.close() -assert(not pcall(io.close, f)) -- error trying to close again -assert(tostring(f) == "file (closed)") -assert(io.type(f) == "closed file") -io.input(file) -f = io.open(otherfile):lines() -for l in io.lines() do assert(l == f()) end -f = nil; collectgarbage() -assert(os.remove(otherfile)) - -io.input(file) -do -- test error returns - local a,b,c = io.input():write("xuxu") - assert(not a and type(b) == "string" and type(c) == "number") -end -assert(io.read(0) == "") -- not eof -assert(io.read(5, '*l') == '"álo"') -assert(io.read(0) == "") -assert(io.read() == "second line") -local x = io.input():seek() -assert(io.read() == "third line ") -assert(io.input():seek("set", x)) -assert(io.read('*L') == "third line \n") -assert(io.read(1) == "ç") -assert(io.read(string.len"fourth_line") == "fourth_line") -assert(io.input():seek("cur", -string.len"fourth_line")) -assert(io.read() == "fourth_line") -assert(io.read() == "") -- empty line -assert(io.read('*n') == 3450) -assert(io.read(1) == '\n') -assert(io.read(0) == nil) -- end of file -assert(io.read(1) == nil) -- end of file -assert(io.read(30000) == nil) -- end of file -assert(({io.read(1)})[2] == nil) -assert(io.read() == nil) -- end of file -assert(({io.read()})[2] == nil) -assert(io.read('*n') == nil) -- end of file -assert(({io.read('*n')})[2] == nil) -assert(io.read('*a') == '') -- end of file (OK for `*a') -assert(io.read('*a') == '') -- end of file (OK for `*a') -collectgarbage() -print('+') -io.close(io.input()) -assert(not pcall(io.read)) - -assert(os.remove(file)) - -local t = '0123456789' -for i=1,12 do t = t..t; end -assert(string.len(t) == 10*2^12) - -io.output(file) -io.write("alo"):write("\n") -io.close() -assert(not pcall(io.write)) -local f = io.open(file, "a+b") -io.output(f) -collectgarbage() - -assert(io.write(' ' .. t .. ' ')) -assert(io.write(';', 'end of file\n')) -f:flush(); io.flush() -f:close() -print('+') - -io.input(file) -assert(io.read() == "alo") -assert(io.read(1) == ' ') -assert(io.read(string.len(t)) == t) -assert(io.read(1) == ' ') -assert(io.read(0)) -assert(io.read('*a') == ';end of file\n') -assert(io.read(0) == nil) -assert(io.close(io.input())) - - --- test errors in read/write -do - local function ismsg (m) - -- error message is not a code number - return (type(m) == "string" and tonumber(m) == nil) - end - - -- read - local f = io.open(file, "w") - local r, m, c = f:read() - assert(r == nil and ismsg(m) and type(c) == "number") - assert(f:close()) - -- write - f = io.open(file, "r") - r, m, c = f:write("whatever") - assert(r == nil and ismsg(m) and type(c) == "number") - assert(f:close()) - -- lines - f = io.open(file, "w") - r, m = pcall(f:lines()) - assert(r == false and ismsg(m)) - assert(f:close()) -end - -assert(os.remove(file)) - --- test for *L format -io.output(file); io.write"\n\nline\nother":close() -io.input(file) -assert(io.read"*L" == "\n") -assert(io.read"*L" == "\n") -assert(io.read"*L" == "line\n") -assert(io.read"*L" == "other") -assert(io.read"*L" == nil) -io.input():close() - -local f = assert(io.open(file)) -local s = "" -for l in f:lines("*L") do s = s .. l end -assert(s == "\n\nline\nother") -f:close() - -io.input(file) -s = "" -for l in io.lines(nil, "*L") do s = s .. l end -assert(s == "\n\nline\nother") -io.input():close() - -s = "" -for l in io.lines(file, "*L") do s = s .. l end -assert(s == "\n\nline\nother") - -s = "" -for l in io.lines(file, "*l") do s = s .. l end -assert(s == "lineother") - -io.output(file); io.write"a = 10 + 34\na = 2*a\na = -a\n":close() -local t = {} -load(io.lines(file, "*L"), nil, nil, t)() -assert(t.a == -((10 + 34) * 2)) - - --- test for multipe arguments in 'lines' -io.output(file); io.write"0123456789\n":close() -for a,b in io.lines(file, 1, 1) do - if a == "\n" then assert(b == nil) - else assert(tonumber(a) == b - 1) - end -end - -for a,b,c in io.lines(file, 1, 2, "*a") do - assert(a == "0" and b == "12" and c == "3456789\n") -end - -for a,b,c in io.lines(file, "*a", 0, 1) do - if a == "" then break end - assert(a == "0123456789\n" and b == nil and c == nil) -end -collectgarbage() -- to close file in previous iteration - -io.output(file); io.write"00\n10\n20\n30\n40\n":close() -for a, b in io.lines(file, "*n", "*n") do - if a == 40 then assert(b == nil) - else assert(a == b - 10) - end -end - - --- test load x lines -io.output(file); -io.write[[ -local y -= X -X = -X * -2 + -X; -X = -X -- y; -]]:close() -_G.X = 1 -assert(not load(io.lines(file))) -collectgarbage() -- to close file in previous iteration -load(io.lines(file, "*L"))() -assert(_G.X == 2) -load(io.lines(file, 1))() -assert(_G.X == 4) -load(io.lines(file, 3))() -assert(_G.X == 8) - -print('+') - -local x1 = "string\n\n\\com \"\"''coisas [[estranhas]] ]]'" -io.output(file) -assert(io.write(string.format("x2 = %q\n-- comment without ending EOS", x1))) -io.close() -assert(loadfile(file))() -assert(x1 == x2) -print('+') -assert(os.remove(file)) -assert(os.remove(file) == nil) -assert(os.remove(otherfile) == nil) - --- testing loadfile -local function testloadfile (s, expres) - io.output(file) - if s then io.write(s) end - io.close() - local res = assert(loadfile(file))() - assert(os.remove(file)) - assert(res == expres) -end - --- loading empty file -testloadfile(nil, nil) - --- loading file with initial comment without end of line -testloadfile("# a non-ending comment", nil) - - --- checking Unicode BOM in files -testloadfile("\xEF\xBB\xBF# some comment\nreturn 234", 234) -testloadfile("\xEF\xBB\xBFreturn 239", 239) -testloadfile("\xEF\xBB\xBF", nil) -- empty file with a BOM - - --- checking line numbers in files with initial comments -testloadfile("# a comment\nreturn debug.getinfo(1).currentline", 2) - - --- loading binary file -io.output(io.open(file, "wb")) -assert(io.write(string.dump(function () return 10, '\0alo\255', 'hi' end))) -io.close() -a, b, c = assert(loadfile(file))() -assert(a == 10 and b == "\0alo\255" and c == "hi") -assert(os.remove(file)) - --- bug in 5.2.1 -do - io.output(io.open(file, "wb")) - -- save function with no upvalues - assert(io.write(string.dump(function () return 1 end))) - io.close() - f = assert(loadfile(file, "b", {})) - assert(type(f) == "function" and f() == 1) - assert(os.remove(file)) -end - --- loading binary file with initial comment -io.output(io.open(file, "wb")) -assert(io.write("#this is a comment for a binary file\0\n", - string.dump(function () return 20, '\0\0\0' end))) -io.close() -a, b, c = assert(loadfile(file))() -assert(a == 20 and b == "\0\0\0" and c == nil) -assert(os.remove(file)) - - --- 'loadfile' with 'env' -do - local f = io.open(file, 'w') - f:write[[ - if (...) then a = 15; return b, c, d - else return _ENV - end - ]] - f:close() - local t = {b = 12, c = "xuxu", d = print} - local f = assert(loadfile(file, 't', t)) - local b, c, d = f(1) - assert(t.a == 15 and b == 12 and c == t.c and d == print) - assert(f() == t) - f = assert(loadfile(file, 't', nil)) - assert(f() == nil) - f = assert(loadfile(file)) - assert(f() == _G) - assert(os.remove(file)) -end - - --- 'loadfile' x modes -do - io.open(file, 'w'):write("return 10"):close() - local s, m = loadfile(file, 'b') - assert(not s and string.find(m, "a text chunk")) - io.open(file, 'w'):write("\27 return 10"):close() - local s, m = loadfile(file, 't') - assert(not s and string.find(m, "a binary chunk")) - assert(os.remove(file)) -end - - -io.output(file) -assert(io.write("qualquer coisa\n")) -assert(io.write("mais qualquer coisa")) -io.close() -assert(io.output(assert(io.open(otherfile, 'wb'))) - :write("outra coisa\0\1\3\0\0\0\0\255\0") - :close()) - -local filehandle = assert(io.open(file, 'r+')) -local otherfilehandle = assert(io.open(otherfile, 'rb')) -assert(filehandle ~= otherfilehandle) -assert(type(filehandle) == "userdata") -assert(filehandle:read('*l') == "qualquer coisa") -io.input(otherfilehandle) -assert(io.read(string.len"outra coisa") == "outra coisa") -assert(filehandle:read('*l') == "mais qualquer coisa") -filehandle:close(); -assert(type(filehandle) == "userdata") -io.input(otherfilehandle) -assert(io.read(4) == "\0\1\3\0") -assert(io.read(3) == "\0\0\0") -assert(io.read(0) == "") -- 255 is not eof -assert(io.read(1) == "\255") -assert(io.read('*a') == "\0") -assert(not io.read(0)) -assert(otherfilehandle == io.input()) -otherfilehandle:close() -assert(os.remove(file)) -assert(os.remove(otherfile)) -collectgarbage() - -io.output(file) - :write[[ - 123.4 -56e-2 not a number -second line -third line - -and the rest of the file -]] - :close() -io.input(file) -local _,a,b,c,d,e,h,__ = io.read(1, '*n', '*n', '*l', '*l', '*l', '*a', 10) -assert(io.close(io.input())) -assert(_ == ' ' and __ == nil) -assert(type(a) == 'number' and a==123.4 and b==-56e-2) -assert(d=='second line' and e=='third line') -assert(h==[[ - -and the rest of the file -]]) -assert(os.remove(file)) -collectgarbage() - --- testing buffers -do - local f = assert(io.open(file, "w")) - local fr = assert(io.open(file, "r")) - assert(f:setvbuf("full", 2000)) - f:write("x") - assert(fr:read("*all") == "") -- full buffer; output not written yet - f:close() - fr:seek("set") - assert(fr:read("*all") == "x") -- `close' flushes it - f = assert(io.open(file), "w") - assert(f:setvbuf("no")) - f:write("x") - fr:seek("set") - assert(fr:read("*all") == "x") -- no buffer; output is ready - f:close() - f = assert(io.open(file, "a")) - assert(f:setvbuf("line")) - f:write("x") - fr:seek("set", 1) - assert(fr:read("*all") == "") -- line buffer; no output without `\n' - f:write("a\n"):seek("set", 1) - assert(fr:read("*all") == "xa\n") -- now we have a whole line - f:close(); fr:close() - assert(os.remove(file)) -end - - -if not _soft then - print("testing large files (> BUFSIZ)") - io.output(file) - for i=1,5001 do io.write('0123456789123') end - io.write('\n12346'):close() - io.input(file) - local x = io.read('*a') - io.input():seek('set', 0) - local y = io.read(30001)..io.read(1005)..io.read(0).. - io.read(1)..io.read(100003) - assert(x == y and string.len(x) == 5001*13 + 6) - io.input():seek('set', 0) - y = io.read() -- huge line - assert(x == y..'\n'..io.read()) - assert(io.read() == nil) - io.close(io.input()) - assert(os.remove(file)) - x = nil; y = nil -end - -if not _noposix then - print("testing popen/pclose and execute") - local tests = { - -- command, what, code - {"ls > /dev/null", "ok"}, - {"not-to-be-found-command", "exit"}, - {"exit 3", "exit", 3}, - {"exit 129", "exit", 129}, - {"kill -s HUP $$", "signal", 1}, - {"kill -s KILL $$", "signal", 9}, - {"sh -c 'kill -s HUP $$'", "exit"}, - {'lua -e "os.exit(20, true)"', "exit", 20}, - } - print("\n(some error messages are expected now)") - for _, v in ipairs(tests) do - local x, y, z = io.popen(v[1]):close() - local x1, y1, z1 = os.execute(v[1]) - assert(x == x1 and y == y1 and z == z1) - if v[2] == "ok" then - assert(x == true and y == 'exit' and z == 0) - else - assert(x == nil and y == v[2]) -- correct status and 'what' - -- correct code if known (but always different from 0) - assert((v[3] == nil and z > 0) or v[3] == z) - end - end -end - - --- testing tmpfile -f = io.tmpfile() -assert(io.type(f) == "file") -f:write("alo") -f:seek("set") -assert(f:read"*a" == "alo") - -end --} - -print'+' - - -assert(os.date("") == "") -assert(os.date("!") == "") -local x = string.rep("a", 10000) -assert(os.date(x) == x) -local t = os.time() -D = os.date("*t", t) -assert(os.date(string.rep("%d", 1000), t) == - string.rep(os.date("%d", t), 1000)) -assert(os.date(string.rep("%", 200)) == string.rep("%", 100)) - -local t = os.time() -D = os.date("*t", t) -load(os.date([[assert(D.year==%Y and D.month==%m and D.day==%d and - D.hour==%H and D.min==%M and D.sec==%S and - D.wday==%w+1 and D.yday==%j and type(D.isdst) == 'boolean')]], t))() - -assert(not pcall(os.date, "%9")) -- invalid conversion specifier -assert(not pcall(os.date, "%")) -- invalid conversion specifier -assert(not pcall(os.date, "%O")) -- invalid conversion specifier -assert(not pcall(os.date, "%E")) -- invalid conversion specifier -assert(not pcall(os.date, "%Ea")) -- invalid conversion specifier - -if not _noposix then - assert(type(os.date("%Ex")) == 'string') - assert(type(os.date("%Oy")) == 'string') -end - -assert(os.time(D) == t) -assert(not pcall(os.time, {hour = 12})) - -D = os.date("!*t", t) -load(os.date([[!assert(D.year==%Y and D.month==%m and D.day==%d and - D.hour==%H and D.min==%M and D.sec==%S and - D.wday==%w+1 and D.yday==%j and type(D.isdst) == 'boolean')]], t))() - -do - local D = os.date("*t") - local t = os.time(D) - assert(type(D.isdst) == 'boolean') - D.isdst = nil - local t1 = os.time(D) - assert(t == t1) -- if isdst is absent uses correct default -end - -t = os.time(D) -D.year = D.year-1; -local t1 = os.time(D) --- allow for leap years -assert(math.abs(os.difftime(t,t1)/(24*3600) - 365) < 2) - -t = os.time() -t1 = os.time(os.date("*t")) -assert(os.difftime(t1,t) <= 2) - -local t1 = os.time{year=2000, month=10, day=1, hour=23, min=12} -local t2 = os.time{year=2000, month=10, day=1, hour=23, min=10, sec=19} -assert(os.difftime(t1,t2) == 60*2-19) - -io.output(io.stdout) -local d = os.date('%d') -local m = os.date('%m') -local a = os.date('%Y') -local ds = os.date('%w') + 1 -local h = os.date('%H') -local min = os.date('%M') -local s = os.date('%S') -io.write(string.format('test done on %2.2d/%2.2d/%d', d, m, a)) -io.write(string.format(', at %2.2d:%2.2d:%2.2d\n', h, min, s)) -io.write(string.format('%s\n', _VERSION)) - - diff --git a/utils/lua_tests/gc.lua b/utils/lua_tests/gc.lua deleted file mode 100644 index 828a829d8..000000000 --- a/utils/lua_tests/gc.lua +++ /dev/null @@ -1,575 +0,0 @@ -print('testing garbage collection') - -collectgarbage() - -assert(collectgarbage("isrunning")) - -local function gcinfo () return collectgarbage"count" * 1024 end - - --- test weird parameters -do - -- save original parameters - local a = collectgarbage("setpause", 200) - local b = collectgarbage("setstepmul", 200) - local t = {0, 2, 10, 90, 500, 5000, 30000, 2^31 - 2} - for i = 1, #t do - local p = t[i] - for j = 1, #t do - local m = t[j] - collectgarbage("setpause", p) - collectgarbage("setstepmul", m) - collectgarbage("step", 0) - collectgarbage("step", 10000) - end - end - -- restore original parameters - collectgarbage("setpause", a) - collectgarbage("setstepmul", b) - collectgarbage() -end - - -_G["while"] = 234 - -limit = 5000 - - -local function GC1 () - local u - local b -- must be declared after 'u' (to be above it in the stack) - local finish = false - u = setmetatable({}, {__gc = function () finish = true end}) - b = {34} - repeat u = {} until finish - assert(b[1] == 34) -- 'u' was collected, but 'b' was not - - finish = false; local i = 1 - u = setmetatable({}, {__gc = function () finish = true end}) - repeat i = i + 1; u = i .. i until finish - assert(b[1] == 34) -- 'u' was collected, but 'b' was not - - finish = false - u = setmetatable({}, {__gc = function () finish = true end}) - repeat local i; u = function () return i end until finish - assert(b[1] == 34) -- 'u' was collected, but 'b' was not -end - -local function GC() GC1(); GC1() end - - -contCreate = 0 - -print('tables') -while contCreate <= limit do - local a = {}; a = nil - contCreate = contCreate+1 -end - -a = "a" - -contCreate = 0 -print('strings') -while contCreate <= limit do - a = contCreate .. "b"; - a = string.gsub(a, '(%d%d*)', string.upper) - a = "a" - contCreate = contCreate+1 -end - - -contCreate = 0 - -a = {} - -print('functions') -function a:test () - while contCreate <= limit do - load(string.format("function temp(a) return 'a%d' end", contCreate))() - assert(temp() == string.format('a%d', contCreate)) - contCreate = contCreate+1 - end -end - -a:test() - --- collection of functions without locals, globals, etc. -do local f = function () end end - - -print("functions with errors") -prog = [[ -do - a = 10; - function foo(x,y) - a = sin(a+0.456-0.23e-12); - return function (z) return sin(%x+z) end - end - local x = function (w) a=a+w; end -end -]] -do - local step = 1 - if _soft then step = 13 end - for i=1, string.len(prog), step do - for j=i, string.len(prog), step do - pcall(load(string.sub(prog, i, j))) - end - end -end - -foo = nil -print('long strings') -x = "01234567890123456789012345678901234567890123456789012345678901234567890123456789" -assert(string.len(x)==80) -s = '' -n = 0 -k = 300 -while n < k do s = s..x; n=n+1; j=tostring(n) end -assert(string.len(s) == k*80) -s = string.sub(s, 1, 20000) -s, i = string.gsub(s, '(%d%d%d%d)', math.sin) -assert(i==20000/4) -s = nil -x = nil - -assert(_G["while"] == 234) - -local k,b = collectgarbage("count") -assert(k*1024 == math.floor(k)*1024 + b) - -print("steps") - -local bytes = gcinfo() -while 1 do - local nbytes = gcinfo() - if nbytes < bytes then break end -- run until gc - bytes = nbytes - a = {} -end - -print("steps (2)") - -local function dosteps (siz) - assert(not collectgarbage("isrunning")) - collectgarbage() - assert(not collectgarbage("isrunning")) - local a = {} - for i=1,100 do a[i] = {{}}; local b = {} end - local x = gcinfo() - local i = 0 - repeat -- do steps until it completes a collection cycle - i = i+1 - until collectgarbage("step", siz) - assert(gcinfo() < x) - return i -end - -collectgarbage"stop" - -if not _port then - -- test the "size" of basic GC steps (whatever they mean...) - assert(dosteps(0) > 10) - assert(dosteps(10) < dosteps(2)) -end - --- collector should do a full collection with so many steps -assert(dosteps(100000) == 1) -assert(collectgarbage("step", 1000000) == true) -assert(collectgarbage("step", 1000000) == true) - -assert(not collectgarbage("isrunning")) -collectgarbage"restart" -assert(collectgarbage("isrunning")) - - -if not _port then - -- test the pace of the collector - collectgarbage(); collectgarbage() - local x = gcinfo() - collectgarbage"stop" - assert(not collectgarbage("isrunning")) - repeat - local a = {} - until gcinfo() > 3 * x - collectgarbage"restart" - assert(collectgarbage("isrunning")) - repeat - local a = {} - until gcinfo() <= x * 2 -end - - -print("clearing tables") -lim = 15 -a = {} --- fill a with `collectable' indices -for i=1,lim do a[{}] = i end -b = {} -for k,v in pairs(a) do b[k]=v end --- remove all indices and collect them -for n in pairs(b) do - a[n] = nil - assert(type(n) == 'table' and next(n) == nil) - collectgarbage() -end -b = nil -collectgarbage() -for n in pairs(a) do error'cannot be here' end -for i=1,lim do a[i] = i end -for i=1,lim do assert(a[i] == i) end - - -print('weak tables') -a = {}; setmetatable(a, {__mode = 'k'}); --- fill a with some `collectable' indices -for i=1,lim do a[{}] = i end --- and some non-collectable ones -for i=1,lim do a[i] = i end -for i=1,lim do local s=string.rep('@', i); a[s] = s..'#' end -collectgarbage() -local i = 0 -for k,v in pairs(a) do assert(k==v or k..'#'==v); i=i+1 end -assert(i == 2*lim) - -a = {}; setmetatable(a, {__mode = 'v'}); -a[1] = string.rep('b', 21) -collectgarbage() -assert(a[1]) -- strings are *values* -a[1] = nil --- fill a with some `collectable' values (in both parts of the table) -for i=1,lim do a[i] = {} end -for i=1,lim do a[i..'x'] = {} end --- and some non-collectable ones -for i=1,lim do local t={}; a[t]=t end -for i=1,lim do a[i+lim]=i..'x' end -collectgarbage() -local i = 0 -for k,v in pairs(a) do assert(k==v or k-lim..'x' == v); i=i+1 end -assert(i == 2*lim) - -a = {}; setmetatable(a, {__mode = 'vk'}); -local x, y, z = {}, {}, {} --- keep only some items -a[1], a[2], a[3] = x, y, z -a[string.rep('$', 11)] = string.rep('$', 11) --- fill a with some `collectable' values -for i=4,lim do a[i] = {} end -for i=1,lim do a[{}] = i end -for i=1,lim do local t={}; a[t]=t end -collectgarbage() -assert(next(a) ~= nil) -local i = 0 -for k,v in pairs(a) do - assert((k == 1 and v == x) or - (k == 2 and v == y) or - (k == 3 and v == z) or k==v); - i = i+1 -end -assert(i == 4) -x,y,z=nil -collectgarbage() -assert(next(a) == string.rep('$', 11)) - - --- 'bug' in 5.1 -a = {} -local t = {x = 10} -local C = setmetatable({key = t}, {__mode = 'v'}) -local C1 = setmetatable({[t] = 1}, {__mode = 'k'}) -a.x = t -- this should not prevent 't' from being removed from - -- weak table 'C' by the time 'a' is finalized - -setmetatable(a, {__gc = function (u) - assert(C.key == nil) - assert(type(next(C1)) == 'table') - end}) - -a, t = nil -collectgarbage() -collectgarbage() -assert(next(C) == nil and next(C1) == nil) -C, C1 = nil - - --- ephemerons -local mt = {__mode = 'k'} -a = {10,20,30,40}; setmetatable(a, mt) -x = nil -for i = 1, 100 do local n = {}; a[n] = {k = {x}}; x = n end -GC() -local n = x -local i = 0 -while n do n = a[n].k[1]; i = i + 1 end -assert(i == 100) -x = nil -GC() -for i = 1, 4 do assert(a[i] == i * 10); a[i] = nil end -assert(next(a) == nil) - -local K = {} -a[K] = {} -for i=1,10 do a[K][i] = {}; a[a[K][i]] = setmetatable({}, mt) end -x = nil -local k = 1 -for j = 1,100 do - local n = {}; local nk = k%10 + 1 - a[a[K][nk]][n] = {x, k = k}; x = n; k = nk -end -GC() -local n = x -local i = 0 -while n do local t = a[a[K][k]][n]; n = t[1]; k = t.k; i = i + 1 end -assert(i == 100) -K = nil -GC() -assert(next(a) == nil) - - --- testing errors during GC -do -collectgarbage("stop") -- stop collection -local u = {} -local s = {}; setmetatable(s, {__mode = 'k'}) -setmetatable(u, {__gc = function (o) - local i = s[o] - s[i] = true - assert(not s[i - 1]) -- check proper finalization order - if i == 8 then error("here") end -- error during GC -end}) - -for i = 6, 10 do - local n = setmetatable({}, getmetatable(u)) - s[n] = i -end - -assert(not pcall(collectgarbage)) -for i = 8, 10 do assert(s[i]) end - -for i = 1, 5 do - local n = setmetatable({}, getmetatable(u)) - s[n] = i -end - -collectgarbage() -for i = 1, 10 do assert(s[i]) end - -getmetatable(u).__gc = false - - --- __gc errors with non-string messages -setmetatable({}, {__gc = function () error{} end}) -local a, b = pcall(collectgarbage) -assert(not a and type(b) == "string" and string.find(b, "error in __gc")) - -end -print '+' - - --- testing userdata -if T==nil then - (Message or print)('\a\n >>> testC not active: skipping userdata GC tests <<<\n\a') - -else - - local function newproxy(u) - return debug.setmetatable(T.newuserdata(0), debug.getmetatable(u)) - end - - collectgarbage("stop") -- stop collection - local u = newproxy(nil) - debug.setmetatable(u, {__gc = true}) - local s = 0 - local a = {[u] = 0}; setmetatable(a, {__mode = 'vk'}) - for i=1,10 do a[newproxy(u)] = i end - for k in pairs(a) do assert(getmetatable(k) == getmetatable(u)) end - local a1 = {}; for k,v in pairs(a) do a1[k] = v end - for k,v in pairs(a1) do a[v] = k end - for i =1,10 do assert(a[i]) end - getmetatable(u).a = a1 - getmetatable(u).u = u - do - local u = u - getmetatable(u).__gc = function (o) - assert(a[o] == 10-s) - assert(a[10-s] == nil) -- udata already removed from weak table - assert(getmetatable(o) == getmetatable(u)) - assert(getmetatable(o).a[o] == 10-s) - s=s+1 - end - end - a1, u = nil - assert(next(a) ~= nil) - collectgarbage() - assert(s==11) - collectgarbage() - assert(next(a) == nil) -- finalized keys are removed in two cycles -end - - --- __gc x weak tables -local u = setmetatable({}, {__gc = true}) --- __gc metamethod should be collected before running -setmetatable(getmetatable(u), {__mode = "v"}) -getmetatable(u).__gc = function (o) os.exit(1) end -- cannot happen -u = nil -collectgarbage() - -local u = setmetatable({}, {__gc = true}) -local m = getmetatable(u) -m.x = {[{0}] = 1; [0] = {1}}; setmetatable(m.x, {__mode = "kv"}); -m.__gc = function (o) - assert(next(getmetatable(o).x) == nil) - m = 10 -end -u, m = nil -collectgarbage() -assert(m==10) - - --- errors during collection -u = setmetatable({}, {__gc = function () error "!!!" end}) -u = nil -assert(not pcall(collectgarbage)) - - -if not _soft then - print("deep structures") - local a = {} - for i = 1,200000 do - a = {next = a} - end - collectgarbage() -end - --- create many threads with self-references and open upvalues -local thread_id = 0 -local threads = {} - -local function fn (thread) - local x = {} - threads[thread_id] = function() - thread = x - end - coroutine.yield() -end - -while thread_id < 1000 do - local thread = coroutine.create(fn) - coroutine.resume(thread, thread) - thread_id = thread_id + 1 -end - -do - collectgarbage() - collectgarbage"stop" - local x = gcinfo() - repeat - for i=1,1000 do _ENV.a = {} end - collectgarbage("step", 1) -- steps should not unblock the collector - until gcinfo() > 2 * x - collectgarbage"restart" -end - - -if T then -- tests for weird cases collecting upvalues - local a = 1200 - local f = function () return a end -- create upvalue for 'a' - assert(f() == 1200) - - -- erase reference to upvalue 'a', mark it as dead, but does not collect it - T.gcstate("pause"); collectgarbage("stop") - f = nil - T.gcstate("sweepstring") - - -- this function will reuse that dead upvalue... - f = function () return a end - assert(f() == 1200) - - -- create coroutine with local variable 'b' - local co = coroutine.wrap(function() - local b = 150 - coroutine.yield(function () return b end) - end) - - T.gcstate("pause") - assert(co()() == 150) -- create upvalue for 'b' - - -- mark upvalue 'b' as dead, but does not collect it - T.gcstate("sweepstring") - - co() -- finish coroutine, "closing" that dead upvalue - - assert(f() == 1200) - collectgarbage("restart") - - print"+" -end - - -if T then - local debug = require "debug" - collectgarbage("generational"); collectgarbage("stop") - x = T.newuserdata(0) - T.gcstate("propagate") -- ensure 'x' is old - T.gcstate("sweepstring") - T.gcstate("propagate") - assert(string.find(T.gccolor(x), "/old")) - local y = T.newuserdata(0) - debug.setmetatable(y, {__gc = true}) -- bless the new udata before... - debug.setmetatable(x, {__gc = true}) -- ...the old one - assert(string.find(T.gccolor(y), "white")) - T.checkmemory() - collectgarbage("incremental"); collectgarbage("restart") -end - - -if T then - print("emergency collections") - collectgarbage() - collectgarbage() - T.totalmem(T.totalmem() + 200) - for i=1,200 do local a = {} end - T.totalmem(1000000000) - collectgarbage() - local t = T.totalmem("table") - local a = {{}, {}, {}} -- create 4 new tables - assert(T.totalmem("table") == t + 4) - t = T.totalmem("function") - a = function () end -- create 1 new closure - assert(T.totalmem("function") == t + 1) - t = T.totalmem("thread") - a = coroutine.create(function () end) -- create 1 new coroutine - assert(T.totalmem("thread") == t + 1) -end - --- create an object to be collected when state is closed -do - local setmetatable,assert,type,print,getmetatable = - setmetatable,assert,type,print,getmetatable - local tt = {} - tt.__gc = function (o) - assert(getmetatable(o) == tt) - -- create new objects during GC - local a = 'xuxu'..(10+3)..'joao', {} - ___Glob = o -- ressurect object! - setmetatable({}, tt) -- creates a new one with same metatable - print(">>> closing state " .. "<<<\n") - end - local u = setmetatable({}, tt) - ___Glob = {u} -- avoid object being collected before program end -end - --- create several objects to raise errors when collected while closing state -do - local mt = {__gc = function (o) return o + 1 end} - for i = 1,10 do - -- create object and preserve it until the end - table.insert(___Glob, setmetatable({}, mt)) - end -end - --- just to make sure -assert(collectgarbage'isrunning') - -print('OK') diff --git a/utils/lua_tests/goto.lua b/utils/lua_tests/goto.lua deleted file mode 100644 index d88171564..000000000 --- a/utils/lua_tests/goto.lua +++ /dev/null @@ -1,173 +0,0 @@ -local function errmsg (code, m) - local st, msg = load(code) - assert(not st and string.find(msg, m)) -end - --- cannot see label inside block -errmsg([[ goto l1; do ::l1:: end ]], "label 'l1'") -errmsg([[ do ::l1:: end goto l1; ]], "label 'l1'") - --- repeated label -errmsg([[ ::l1:: ::l1:: ]], "label 'l1'") - - --- undefined label -errmsg([[ goto l1; local aa ::l1:: ::l2:: print(3) ]], "local 'aa'") - --- jumping over variable definition -errmsg([[ -do local bb, cc; goto l1; end -local aa -::l1:: print(3) -]], "local 'aa'") - --- jumping into a block -errmsg([[ do ::l1:: end goto l1 ]], "label 'l1'") -errmsg([[ goto l1 do ::l1:: end ]], "label 'l1'") - --- cannot continue a repeat-until with variables -errmsg([[ - repeat - if x then goto cont end - local xuxu = 10 - ::cont:: - until xuxu < x -]], "local 'xuxu'") - --- simple gotos -local x -do - local y = 12 - goto l1 - ::l2:: x = x + 1; goto l3 - ::l1:: x = y; goto l2 -end -::l3:: ::l3_1:: assert(x == 13) - - --- long labels -do - local prog = [[ - do - local a = 1 - goto l%sa; a = a + 1 - ::l%sa:: a = a + 10 - goto l%sb; a = a + 2 - ::l%sb:: a = a + 20 - return a - end - ]] - local label = string.rep("0123456789", 40) - prog = string.format(prog, label, label, label, label) - assert(assert(load(prog))() == 31) -end - --- goto to correct label when nested -do goto l3; ::l3:: end -- does not loop jumping to previous label 'l3' - --- ok to jump over local dec. to end of block -do - goto l1 - local a = 23 - x = a - ::l1::; -end - -while true do - goto l4 - goto l1 -- ok to jump over local dec. to end of block - goto l1 -- multiple uses of same label - local x = 45 - ::l1:: ;;; -end -::l4:: assert(x == 13) - -if print then - goto l1 -- ok to jump over local dec. to end of block - error("should not be here") - goto l2 -- ok to jump over local dec. to end of block - local x - ::l1:: ; ::l2:: ;; -else end - --- to repeat a label in a different function is OK -local function foo () - local a = {} - goto l3 - ::l1:: a[#a + 1] = 1; goto l2; - ::l2:: a[#a + 1] = 2; goto l5; - ::l3:: - ::l3a:: a[#a + 1] = 3; goto l1; - ::l4:: a[#a + 1] = 4; goto l6; - ::l5:: a[#a + 1] = 5; goto l4; - ::l6:: assert(a[1] == 3 and a[2] == 1 and a[3] == 2 and - a[4] == 5 and a[5] == 4) - if not a[6] then a[6] = true; goto l3a end -- do it twice -end - -::l6:: foo() - - - --------------------------------------------------------------------------------- --- testing closing of upvalues - -local function foo () - local a = {} - do - local i = 1 - local k = 0 - a[0] = function (y) k = y end - ::l1:: do - local x - if i > 2 then goto l2 end - a[i] = function (y) if y then x = y else return x + k end end - i = i + 1 - goto l1 - end - end - ::l2:: return a -end - -local a = foo() -a[1](10); a[2](20) -assert(a[1]() == 10 and a[2]() == 20 and a[3] == nil) -a[0](13) -assert(a[1]() == 23 and a[2]() == 33) - --------------------------------------------------------------------------------- --- testing if x goto optimizations - -local function testG (a) - if a == 1 then - goto l1 - error("should never be here!") - elseif a == 2 then goto l2 - elseif a == 3 then goto l3 - elseif a == 4 then - goto l1 -- go to inside the block - error("should never be here!") - ::l1:: a = a + 1 -- must go to 'if' end - else - goto l4 - ::l4a:: a = a * 2; goto l4b - error("should never be here!") - ::l4:: goto l4a - error("should never be here!") - ::l4b:: - end - do return a end - ::l2:: do return "2" end - ::l3:: do return "3" end - ::l1:: return "1" -end - -assert(testG(1) == "1") -assert(testG(2) == "2") -assert(testG(3) == "3") -assert(testG(4) == 5) -assert(testG(5) == 10) --------------------------------------------------------------------------------- - - -print'OK' diff --git a/utils/lua_tests/libs/lib1.c b/utils/lua_tests/libs/lib1.c deleted file mode 100644 index 0cac7c981..000000000 --- a/utils/lua_tests/libs/lib1.c +++ /dev/null @@ -1,49 +0,0 @@ -/* -** compile with -** Linux: gcc -Wall -O2 -I.. -ansi -shared -o lib1.so lib1.c -** Mac OS X: export MACOSX_DEPLOYMENT_TARGET=10.3 -** gcc -bundle -undefined dynamic_lookup -Wall -O2 -o lib1.so lib1.c -*/ - - -#include "lua.h" -#include "lauxlib.h" - -static int id (lua_State *L) { - return lua_gettop(L); -} - - -static const struct luaL_Reg funcs[] = { - {"id", id}, - {NULL, NULL} -}; - - -/* function used by lib11.c */ -int lib1_export (lua_State *L) { - lua_pushstring(L, "exported"); - return 1; -} - - -int onefunction (lua_State *L) { - lua_settop(L, 2); - lua_pushvalue(L, 1); - return 2; -} - - -int anotherfunc (lua_State *L) { - lua_pushfstring(L, "%f%f\n", lua_tonumber(L, 1), lua_tonumber(L, 2)); - return 1; -} - - -int luaopen_lib1_sub (lua_State *L) { - lua_setglobal(L, "y"); - lua_setglobal(L, "x"); - luaL_newlib(L, funcs); - return 1; -} - diff --git a/utils/lua_tests/libs/lib11.c b/utils/lua_tests/libs/lib11.c deleted file mode 100644 index 835a00c69..000000000 --- a/utils/lua_tests/libs/lib11.c +++ /dev/null @@ -1,18 +0,0 @@ -/* -** compile with -** Linux: gcc -Wall -O2 -I.. -ansi -shared -o lib1.so lib1.c -** Mac OS X: export MACOSX_DEPLOYMENT_TARGET=10.3 -** gcc -bundle -undefined dynamic_lookup -Wall -O2 -o lib1.so lib1.c -*/ - - -#include "lua.h" - -/* function from lib1.c */ -int lib1_export (lua_State *L); - -int luaopen_lib11 (lua_State *L) { - return lib1_export(L); -} - - diff --git a/utils/lua_tests/libs/lib2.c b/utils/lua_tests/libs/lib2.c deleted file mode 100644 index e48d41aad..000000000 --- a/utils/lua_tests/libs/lib2.c +++ /dev/null @@ -1,29 +0,0 @@ -/* -** compile with -** gcc -Wall -O2 -I.. -ansi -shared -o lib1.so lib1.c -*/ - - -#include "lua.h" -#include "lauxlib.h" - -static int id (lua_State *L) { - return lua_gettop(L); -} - - -static const struct luaL_Reg funcs[] = { - {"id", id}, - {NULL, NULL} -}; - - -int luaopen_lib2 (lua_State *L) { - lua_settop(L, 2); - lua_setglobal(L, "y"); /* y gets 2nd parameter */ - lua_setglobal(L, "x"); /* x gets 1st parameter */ - luaL_newlib(L, funcs); - return 1; -} - - diff --git a/utils/lua_tests/libs/lib21.c b/utils/lua_tests/libs/lib21.c deleted file mode 100644 index 167507f99..000000000 --- a/utils/lua_tests/libs/lib21.c +++ /dev/null @@ -1,18 +0,0 @@ -/* -** compile with -** Linux: gcc -Wall -O2 -I.. -ansi -shared -o lib1.so lib1.c -** Mac OS X: export MACOSX_DEPLOYMENT_TARGET=10.3 -** gcc -bundle -undefined dynamic_lookup -Wall -O2 -o lib1.so lib1.c -*/ - - -#include "lua.h" - - -int luaopen_lib2 (lua_State *L); - -int luaopen_lib21 (lua_State *L) { - return luaopen_lib2(L); -} - - diff --git a/utils/lua_tests/libs/makefile b/utils/lua_tests/libs/makefile deleted file mode 100644 index 1f9eeada5..000000000 --- a/utils/lua_tests/libs/makefile +++ /dev/null @@ -1,26 +0,0 @@ -# change this variable to point to the directory with Lua headers -# of the version being tested -LUA_DIR = ../.. - -CC = gcc - -# compilation should generate Dynamic-Link Libraries -CFLAGS = -Wall -O2 -I$(LUA_DIR) -ansi -fpic -shared - -# libraries used by the tests -all: lib1.so lib11.so lib2.so lib21.so v-lib2.so - -lib1.so: lib1.c - $(CC) $(CFLAGS) -o lib1.so lib1.c - -lib11.so: lib11.c - $(CC) $(CFLAGS) -o lib11.so lib11.c - -lib2.so: lib2.c - $(CC) $(CFLAGS) -o lib2.so lib2.c - -lib21.so: lib21.c - $(CC) $(CFLAGS) -o lib21.so lib21.c - -v-lib2.so: lib2.so - mv lib2.so ./v-lib2.so diff --git a/utils/lua_tests/literals.lua b/utils/lua_tests/literals.lua deleted file mode 100644 index 36e2fcf4e..000000000 --- a/utils/lua_tests/literals.lua +++ /dev/null @@ -1,258 +0,0 @@ -print('testing scanner') - -debug = require "debug" - - -local function dostring (x) return assert(load(x))() end - -dostring("x \v\f = \t\r 'a\0a' \v\f\f") -assert(x == 'a\0a' and string.len(x) == 3) - --- escape sequences -assert('\n\"\'\\' == [[ - -"'\]]) - -assert(string.find("\a\b\f\n\r\t\v", "^%c%c%c%c%c%c%c$")) - --- assume ASCII just for tests: -assert("\09912" == 'c12') -assert("\99ab" == 'cab') -assert("\099" == '\99') -assert("\099\n" == 'c\10') -assert('\0\0\0alo' == '\0' .. '\0\0' .. 'alo') - -assert(010 .. 020 .. -030 == "1020-30") - --- hexadecimal escapes -assert("\x00\x05\x10\x1f\x3C\xfF\xe8" == "\0\5\16\31\60\255\232") - -local function lexstring (x, y, n) - local f = assert(load('return '..x..', debug.getinfo(1).currentline')) - local s, l = f() - assert(s == y and l == n) -end - -lexstring("'abc\\z \n efg'", "abcefg", 2) -lexstring("'abc\\z \n\n\n'", "abc", 4) -lexstring("'\\z \n\t\f\v\n'", "", 3) -lexstring("[[\nalo\nalo\n\n]]", "alo\nalo\n\n", 5) -lexstring("[[\nalo\ralo\n\n]]", "alo\nalo\n\n", 5) -lexstring("[[\nalo\ralo\r\n]]", "alo\nalo\n", 4) -lexstring("[[\ralo\n\ralo\r\n]]", "alo\nalo\n", 4) -lexstring("[[alo]\n]alo]]", "alo]\n]alo", 2) - -assert("abc\z - def\z - ghi\z - " == 'abcdefghi') - --- Error in escape sequences -local function lexerror (s, err) - local st, msg = load('return '..s) - if err ~= '' then err = "'"..err.."'" end - assert(not st and string.find(msg, "near "..err, 1, true)) -end -lexerror([["abc\x"]], [[\x"]]) -lexerror([["abc\x]], [[\x]]) -lexerror([["\x]], [[\x]]) -lexerror([["\x5"]], [[\x5"]]) -lexerror([["\x5]], [[\x5]]) -lexerror([["\xr"]], [[\xr]]) -lexerror([["\xr]], [[\xr]]) -lexerror([["\x.]], [[\x.]]) -lexerror([["\x8%"]], [[\x8%]]) -lexerror([["\xAG]], [[\xAG]]) -lexerror([["\g"]], [[\g]]) -lexerror([["\g]], [[\g]]) -lexerror([["\."]], [[\.]]) - -lexerror([["\999"]], [[\999]]) -lexerror([["xyz\300"]], [[\300]]) -lexerror([[" \256"]], [[\256]]) - - --- unfinished strings -lexerror("[=[alo]]", "") -lexerror("[=[alo]=", "") -lexerror("[=[alo]", "") -lexerror("'alo", "") -lexerror("'alo \\z \n\n", "") -lexerror("'alo \\z", "") -lexerror([['alo \98]], "") - --- valid characters in variable names -for i = 0, 255 do - local s = string.char(i) - assert(not string.find(s, "[a-zA-Z_]") == not load(s .. "=1")) - assert(not string.find(s, "[a-zA-Z_0-9]") == - not load("a" .. s .. "1 = 1")) -end - - --- long variable names - -var = string.rep('a', 15000) -prog = string.format("%s = 5", var) -dostring(prog) -assert(_G[var] == 5) -var = nil -print('+') - --- escapes -- -assert("\n\t" == [[ - - ]]) -assert([[ - - $debug]] == "\n $debug") -assert([[ [ ]] ~= [[ ] ]]) --- long strings -- -b = "001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789" -assert(string.len(b) == 960) -prog = [=[ -print('+') - -a1 = [["isto e' um string com várias 'aspas'"]] -a2 = "'aspas'" - -assert(string.find(a1, a2) == 31) -print('+') - -a1 = [==[temp = [[um valor qualquer]]; ]==] -assert(load(a1))() -assert(temp == 'um valor qualquer') --- long strings -- -b = "001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789" -assert(string.len(b) == 960) -print('+') - -a = [[00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -00123456789012345678901234567890123456789123456789012345678901234567890123456789 -]] -assert(string.len(a) == 1863) -assert(string.sub(a, 1, 40) == string.sub(b, 1, 40)) -x = 1 -]=] - -print('+') -x = nil -dostring(prog) -assert(x) - -prog = nil -a = nil -b = nil - - --- testing line ends -prog = [[ -a = 1 -- a comment -b = 2 - - -x = [=[ -hi -]=] -y = "\ -hello\r\n\ -" -return debug.getinfo(1).currentline -]] - -for _, n in pairs{"\n", "\r", "\n\r", "\r\n"} do - local prog, nn = string.gsub(prog, "\n", n) - assert(dostring(prog) == nn) - assert(_G.x == "hi\n" and _G.y == "\nhello\r\n\n") -end - - --- testing comments and strings with long brackets -a = [==[]=]==] -assert(a == "]=") - -a = [==[[===[[=[]]=][====[]]===]===]==] -assert(a == "[===[[=[]]=][====[]]===]===") - -a = [====[[===[[=[]]=][====[]]===]===]====] -assert(a == "[===[[=[]]=][====[]]===]===") - -a = [=[]]]]]]]]]=] -assert(a == "]]]]]]]]") - - ---[===[ -x y z [==[ blu foo -]== -] -]=]==] -error error]=]===] - --- generate all strings of four of these chars -local x = {"=", "[", "]", "\n"} -local len = 4 -local function gen (c, n) - if n==0 then coroutine.yield(c) - else - for _, a in pairs(x) do - gen(c..a, n-1) - end - end -end - -for s in coroutine.wrap(function () gen("", len) end) do - assert(s == load("return [====[\n"..s.."]====]")()) -end - - --- testing decimal point locale -if os.setlocale("pt_BR") or os.setlocale("ptb") then - assert(not load("á = 3")) -- parser still works with C locale - assert(not load("a = (3,4)")) - assert(tonumber("3,4") == 3.4 and tonumber"3.4" == nil) - assert(assert(load("return 3.4"))() == 3.4) - assert(assert(load("return .4,3"))() == .4) - assert(assert(load("return 4."))() == 4.) - assert(assert(load("return 4.+.5"))() == 4.5) - local a,b = load("return 4.5.") - assert(string.find(b, "'4%.5%.'")) - assert(os.setlocale("C")) -else - (Message or print)( - '\a\n >>> pt_BR locale not available: skipping decimal point tests <<<\n\a') -end - - --- testing %q x line ends -local s = "a string with \r and \n and \r\n and \n\r" -local c = string.format("return %q", s) -assert(assert(load(c))() == s) - --- testing errors -assert(not load"a = 'non-ending string") -assert(not load"a = 'non-ending string\n'") -assert(not load"a = '\\345'") -assert(not load"a = [=x]") - -print('OK') diff --git a/utils/lua_tests/locals.lua b/utils/lua_tests/locals.lua deleted file mode 100644 index a290e5bc0..000000000 --- a/utils/lua_tests/locals.lua +++ /dev/null @@ -1,157 +0,0 @@ -print('testing local variables and environments') - -local debug = require"debug" - - --- bug in 5.1: - -local function f(x) x = nil; return x end -assert(f(10) == nil) - -local function f() local x; return x end -assert(f(10) == nil) - -local function f(x) x = nil; local y; return x, y end -assert(f(10) == nil and select(2, f(20)) == nil) - -do - local i = 10 - do local i = 100; assert(i==100) end - do local i = 1000; assert(i==1000) end - assert(i == 10) - if i ~= 10 then - local i = 20 - else - local i = 30 - assert(i == 30) - end -end - - - -f = nil - -local f -x = 1 - -a = nil -load('local a = {}')() -assert(a == nil) - -function f (a) - local _1, _2, _3, _4, _5 - local _6, _7, _8, _9, _10 - local x = 3 - local b = a - local c,d = a,b - if (d == b) then - local x = 'q' - x = b - assert(x == 2) - else - assert(nil) - end - assert(x == 3) - local f = 10 -end - -local b=10 -local a; repeat local b; a,b=1,2; assert(a+1==b); until a+b==3 - - -assert(x == 1) - -f(2) -assert(type(f) == 'function') - - -local function getenv (f) - local a,b = debug.getupvalue(f, 1) - assert(a == '_ENV') - return b -end - --- test for global table of loaded chunks -assert(getenv(load"a=3") == _G) -local c = {}; local f = load("a = 3", nil, nil, c) -assert(getenv(f) == c) -assert(c.a == nil) -f() -assert(c.a == 3) - --- testing limits for special instructions - -if not _soft then - local a - local p = 4 - for i=2,31 do - for j=-3,3 do - assert(load(string.format([[local a=%s; - a=a+%s; - assert(a ==2^%s)]], j, p-j, i))) () - assert(load(string.format([[local a=%s; - a=a-%s; - assert(a==-2^%s)]], -j, p-j, i))) () - assert(load(string.format([[local a,b=0,%s; - a=b-%s; - assert(a==-2^%s)]], -j, p-j, i))) () - end - p =2*p - end -end - -print'+' - - -if rawget(_G, "querytab") then - -- testing clearing of dead elements from tables - collectgarbage("stop") -- stop GC - local a = {[{}] = 4, [3] = 0, alo = 1, - a1234567890123456789012345678901234567890 = 10} - - local t = querytab(a) - - for k,_ in pairs(a) do a[k] = nil end - collectgarbage() -- restore GC and collect dead fiels in `a' - for i=0,t-1 do - local k = querytab(a, i) - assert(k == nil or type(k) == 'number' or k == 'alo') - end -end - - --- testing lexical environments - -assert(_ENV == _G) - -do local _ENV = (function (...) return ... end)(_G, dummy) - -do local _ENV = {assert=assert}; assert(true) end -mt = {_G = _G} -local foo,x -do local _ENV = mt - function foo (x) - A = x - do local _ENV = _G; A = 1000 end - return function (x) return A .. x end - end -end -assert(getenv(foo) == mt) -x = foo('hi'); assert(mt.A == 'hi' and A == 1000) -assert(x('*') == mt.A .. '*') - -do local _ENV = {assert=assert, A=10}; - do local _ENV = {assert=assert, A=20}; - assert(A==20);x=A - end - assert(A==10 and x==20) -end -assert(x==20) - - -print('OK') - -return 5,f - -end - diff --git a/utils/lua_tests/ltests/ltests.c b/utils/lua_tests/ltests/ltests.c deleted file mode 100644 index 8d76f5af5..000000000 --- a/utils/lua_tests/ltests/ltests.c +++ /dev/null @@ -1,1506 +0,0 @@ -/* -** $Id: ltests.c,v 2.134 2012/10/03 12:36:46 roberto Exp $ -** Internal Module for Debugging of the Lua Implementation -** See Copyright Notice in lua.h -*/ - - -#include -#include -#include -#include - -#define ltests_c -#define LUA_CORE - -#include "lua.h" - -#include "lapi.h" -#include "lauxlib.h" -#include "lcode.h" -#include "lctype.h" -#include "ldebug.h" -#include "ldo.h" -#include "lfunc.h" -#include "lmem.h" -#include "lopcodes.h" -#include "lstate.h" -#include "lstring.h" -#include "ltable.h" -#include "lualib.h" - - - -/* -** The whole module only makes sense with LUA_DEBUG on -*/ -#if defined(LUA_DEBUG) - - -void *l_Trick = 0; - - -int islocked = 0; - - -#define obj_at(L,k) (L->ci->func + (k)) - - -static void setnameval (lua_State *L, const char *name, int val) { - lua_pushstring(L, name); - lua_pushinteger(L, val); - lua_settable(L, -3); -} - - -static void pushobject (lua_State *L, const TValue *o) { - setobj2s(L, L->top, o); - api_incr_top(L); -} - - -static int tpanic (lua_State *L) { - fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n", - lua_tostring(L, -1)); - return (exit(EXIT_FAILURE), 0); /* do not return to Lua */ -} - - -/* -** {====================================================================== -** Controlled version for realloc. -** ======================================================================= -*/ - -#define MARK 0x55 /* 01010101 (a nice pattern) */ - -typedef union Header { - L_Umaxalign a; /* ensures maximum alignment for Header */ - struct { - size_t size; - int type; - } d; -} Header; - - -#if !defined(EXTERNMEMCHECK) - -/* full memory check */ -#define MARKSIZE 16 /* size of marks after each block */ -#define fillmem(mem,size) memset(mem, -MARK, size) - -#else - -/* external memory check: don't do it twice */ -#define MARKSIZE 0 -#define fillmem(mem,size) /* empty */ - -#endif - - -Memcontrol l_memcontrol = - {0L, 0L, 0L, 0L, {0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L}}; - - -static void freeblock (Memcontrol *mc, Header *block) { - if (block) { - size_t size = block->d.size; - int i; - for (i = 0; i < MARKSIZE; i++) /* check marks after block */ - lua_assert(*(cast(char *, block + 1) + size + i) == MARK); - mc->objcount[block->d.type]--; - fillmem(block, sizeof(Header) + size + MARKSIZE); /* erase block */ - free(block); /* actually free block */ - mc->numblocks--; /* update counts */ - mc->total -= size; - } -} - - -void *debug_realloc (void *ud, void *b, size_t oldsize, size_t size) { - Memcontrol *mc = cast(Memcontrol *, ud); - Header *block = cast(Header *, b); - int type; - if (mc->memlimit == 0) { /* first time? */ - char *limit = getenv("MEMLIMIT"); /* initialize memory limit */ - mc->memlimit = limit ? strtoul(limit, NULL, 10) : ULONG_MAX; - } - if (block == NULL) { - type = (oldsize < LUA_NUMTAGS) ? oldsize : 0; - oldsize = 0; - } - else { - block--; /* go to real header */ - type = block->d.type; - lua_assert(oldsize == block->d.size); - } - if (size == 0) { - freeblock(mc, block); - return NULL; - } - else if (size > oldsize && mc->total+size-oldsize > mc->memlimit) - return NULL; /* fake a memory allocation error */ - else { - Header *newblock; - int i; - size_t commonsize = (oldsize < size) ? oldsize : size; - size_t realsize = sizeof(Header) + size + MARKSIZE; - if (realsize < size) return NULL; /* arithmetic overflow! */ - newblock = cast(Header *, malloc(realsize)); /* alloc a new block */ - if (newblock == NULL) return NULL; /* really out of memory? */ - if (block) { - memcpy(newblock + 1, block + 1, commonsize); /* copy old contents */ - freeblock(mc, block); /* erase (and check) old copy */ - } - /* initialize new part of the block with something `weird' */ - fillmem(cast(char *, newblock + 1) + commonsize, size - commonsize); - /* initialize marks after block */ - for (i = 0; i < MARKSIZE; i++) - *(cast(char *, newblock + 1) + size + i) = MARK; - newblock->d.size = size; - newblock->d.type = type; - mc->total += size; - if (mc->total > mc->maxmem) - mc->maxmem = mc->total; - mc->numblocks++; - mc->objcount[type]++; - return newblock + 1; - } -} - - -/* }====================================================================== */ - - - -/* -** {====================================================== -** Functions to check memory consistency -** ======================================================= -*/ - - -static int testobjref1 (global_State *g, GCObject *f, GCObject *t) { - if (isdead(g,t)) return 0; - if (!issweepphase(g)) - return !(isblack(f) && iswhite(t)); - else return 1; -} - - -static void printobj (global_State *g, GCObject *o) { - int i = 1; - GCObject *p; - for (p = g->allgc; p != o && p != NULL; p = gch(p)->next) i++; - if (p == NULL) { - i = 1; - for (p = g->finobj; p != o && p != NULL; p = gch(p)->next) i++; - if (p == NULL) i = 0; /* zero means 'not found' */ - else i = -i; /* negative means 'found in findobj list */ - } - printf("||%d:%s(%p)-%c(%02X)||", i, ttypename(gch(o)->tt), (void *)o, - isdead(g,o)?'d':isblack(o)?'b':iswhite(o)?'w':'g', gch(o)->marked); -} - - -static int testobjref (global_State *g, GCObject *f, GCObject *t) { - int r = testobjref1(g,f,t); - if (!r) { - printf("%d(%02X) - ", g->gcstate, g->currentwhite); - printobj(g, f); - printf("\t-> "); - printobj(g, t); - printf("\n"); - } - return r; -} - -#define checkobjref(g,f,t) lua_assert(testobjref(g,f,obj2gco(t))) - - -static void checkvalref (global_State *g, GCObject *f, const TValue *t) { - if (iscollectable(t)) { - lua_assert(righttt(t)); - lua_assert(testobjref(g, f, gcvalue(t))); - } -} - - -static void checktable (global_State *g, Table *h) { - int i; - Node *n, *limit = gnode(h, sizenode(h)); - GCObject *hgc = obj2gco(h); - if (h->metatable) - checkobjref(g, hgc, h->metatable); - for (i = 0; i < h->sizearray; i++) - checkvalref(g, hgc, &h->array[i]); - for (n = gnode(h, 0); n < limit; n++) { - if (!ttisnil(gval(n))) { - lua_assert(!ttisnil(gkey(n))); - checkvalref(g, hgc, gkey(n)); - checkvalref(g, hgc, gval(n)); - } - } -} - - -/* -** All marks are conditional because a GC may happen while the -** prototype is still being created -*/ -static void checkproto (global_State *g, Proto *f) { - int i; - GCObject *fgc = obj2gco(f); - if (f->source) checkobjref(g, fgc, f->source); - for (i=0; isizek; i++) { - if (ttisstring(f->k+i)) - checkobjref(g, fgc, rawtsvalue(f->k+i)); - } - for (i=0; isizeupvalues; i++) { - if (f->upvalues[i].name) - checkobjref(g, fgc, f->upvalues[i].name); - } - for (i=0; isizep; i++) { - if (f->p[i]) - checkobjref(g, fgc, f->p[i]); - } - for (i=0; isizelocvars; i++) { - if (f->locvars[i].varname) - checkobjref(g, fgc, f->locvars[i].varname); - } -} - - - -static void checkCclosure (global_State *g, CClosure *cl) { - GCObject *clgc = obj2gco(cl); - int i; - for (i = 0; i < cl->nupvalues; i++) - checkvalref(g, clgc, &cl->upvalue[i]); -} - - -static void checkLclosure (global_State *g, LClosure *cl) { - GCObject *clgc = obj2gco(cl); - int i; - if (cl->p) checkobjref(g, clgc, cl->p); - for (i=0; inupvalues; i++) { - if (cl->upvals[i]) { - lua_assert(cl->upvals[i]->tt == LUA_TUPVAL); - checkobjref(g, clgc, cl->upvals[i]); - } - } -} - - -static int lua_checkpc (pCallInfo ci) { - if (!isLua(ci)) return 1; - else { - Proto *p = ci_func(ci)->p; - return p->code <= ci->u.l.savedpc && - ci->u.l.savedpc <= p->code + p->sizecode; - } -} - - -static void checkstack (global_State *g, lua_State *L1) { - StkId o; - CallInfo *ci; - GCObject *uvo; - lua_assert(!isdead(g, obj2gco(L1))); - for (uvo = L1->openupval; uvo != NULL; uvo = gch(uvo)->next) { - UpVal *uv = gco2uv(uvo); - lua_assert(uv->v != &uv->u.value); /* must be open */ - lua_assert(!isblack(uvo)); /* open upvalues cannot be black */ - } - for (ci = L1->ci; ci != NULL; ci = ci->previous) { - lua_assert(ci->top <= L1->stack_last); - lua_assert(lua_checkpc(ci)); - } - if (L1->stack) { - for (o = L1->stack; o < L1->top; o++) - checkliveness(g, o); - } - else lua_assert(L1->stacksize == 0); -} - - -static void checkobject (global_State *g, GCObject *o, int maybedead) { - if (isdead(g, o)) - lua_assert(maybedead); - else { - if (g->gcstate == GCSpause) - lua_assert(iswhite(o)); - switch (gch(o)->tt) { - case LUA_TUPVAL: { - UpVal *uv = gco2uv(o); - lua_assert(uv->v == &uv->u.value); /* must be closed */ - lua_assert(!isgray(o)); /* closed upvalues are never gray */ - checkvalref(g, o, uv->v); - break; - } - case LUA_TUSERDATA: { - Table *mt = gco2u(o)->metatable; - if (mt) checkobjref(g, o, mt); - break; - } - case LUA_TTABLE: { - checktable(g, gco2t(o)); - break; - } - case LUA_TTHREAD: { - checkstack(g, gco2th(o)); - break; - } - case LUA_TLCL: { - checkLclosure(g, gco2lcl(o)); - break; - } - case LUA_TCCL: { - checkCclosure(g, gco2ccl(o)); - break; - } - case LUA_TPROTO: { - checkproto(g, gco2p(o)); - break; - } - case LUA_TSHRSTR: - case LUA_TLNGSTR: break; - default: lua_assert(0); - } - } -} - - -#define TESTGRAYBIT 7 - -static void checkgraylist (GCObject *l) { - while (l) { - lua_assert(isgray(l)); - lua_assert(!testbit(l->gch.marked, TESTGRAYBIT)); - l_setbit(l->gch.marked, TESTGRAYBIT); - switch (gch(l)->tt) { - case LUA_TTABLE: l = gco2t(l)->gclist; break; - case LUA_TLCL: l = gco2lcl(l)->gclist; break; - case LUA_TCCL: l = gco2ccl(l)->gclist; break; - case LUA_TTHREAD: l = gco2th(l)->gclist; break; - case LUA_TPROTO: l = gco2p(l)->gclist; break; - default: lua_assert(0); /* other objects cannot be gray */ - } - } -} - - -/* -** mark all objects in gray lists with the TESTGRAYBIT, so that -** 'checkmemory' can check that all gray objects are in a gray list -*/ -static void markgrays (global_State *g) { - if (!keepinvariant(g)) return; - checkgraylist(g->gray); - checkgraylist(g->grayagain); - checkgraylist(g->weak); - checkgraylist(g->ephemeron); - checkgraylist(g->allweak); -} - - -static void checkold (global_State *g, GCObject *o) { - int isold = 0; - for (; o != NULL; o = gch(o)->next) { - if (isold(o)) { /* old generation? */ - lua_assert(isgenerational(g)); - if (!issweepphase(g)) - isold = 1; - } - else lua_assert(!isold); /* non-old object cannot be after an old one */ - if (isgray(o)) { - lua_assert(!keepinvariant(g) || testbit(o->gch.marked, TESTGRAYBIT)); - resetbit(o->gch.marked, TESTGRAYBIT); - } - lua_assert(!testbit(o->gch.marked, TESTGRAYBIT)); - } -} - - -int lua_checkmemory (lua_State *L) { - global_State *g = G(L); - GCObject *o; - UpVal *uv; - int maybedead; - if (keepinvariant(g)) { - lua_assert(!iswhite(obj2gco(g->mainthread))); - lua_assert(!iswhite(gcvalue(&g->l_registry))); - } - else /* generational mode keeps collector in 'propagate' state */ - lua_assert(!isgenerational(g)); - lua_assert(!isdead(g, gcvalue(&g->l_registry))); - checkstack(g, g->mainthread); - resetbit(g->mainthread->marked, TESTGRAYBIT); - /* check 'allgc' list */ - markgrays(g); - checkold(g, g->allgc); - lua_assert(g->sweepgc == NULL || issweepphase(g)); - maybedead = 0; - for (o = g->allgc; o != NULL; o = gch(o)->next) { - if (g->sweepgc && o == *g->sweepgc) - maybedead = 1; /* part of the list not yet sweeped */ - checkobject(g, o, maybedead); - lua_assert(!testbit(o->gch.marked, SEPARATED)); - } - /* check 'finobj' list */ - checkold(g, g->finobj); - for (o = g->finobj; o != NULL; o = gch(o)->next) { - lua_assert(testbit(o->gch.marked, SEPARATED)); - lua_assert(gch(o)->tt == LUA_TUSERDATA || - gch(o)->tt == LUA_TTABLE); - checkobject(g, o, 0); - } - /* check 'tobefnz' list */ - checkold(g, g->tobefnz); - for (o = g->tobefnz; o != NULL; o = gch(o)->next) { - lua_assert(!iswhite(o) || g->gcstate == GCSpause); - lua_assert(!isdead(g, o) && testbit(o->gch.marked, SEPARATED)); - lua_assert(gch(o)->tt == LUA_TUSERDATA || - gch(o)->tt == LUA_TTABLE); - } - /* check 'uvhead' list */ - for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) { - lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv); - lua_assert(uv->v != &uv->u.value); /* must be open */ - lua_assert(!isblack(obj2gco(uv))); /* open upvalues are never black */ - if (!isdead(g, obj2gco(uv))) - checkvalref(g, obj2gco(uv), uv->v); - } - return 0; -} - -/* }====================================================== */ - - - -/* -** {====================================================== -** Disassembler -** ======================================================= -*/ - - -static char *buildop (Proto *p, int pc, char *buff) { - Instruction i = p->code[pc]; - OpCode o = GET_OPCODE(i); - const char *name = luaP_opnames[o]; - int line = getfuncline(p, pc); - sprintf(buff, "(%4d) %4d - ", line, pc); - switch (getOpMode(o)) { - case iABC: - sprintf(buff+strlen(buff), "%-12s%4d %4d %4d", name, - GETARG_A(i), GETARG_B(i), GETARG_C(i)); - break; - case iABx: - sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_Bx(i)); - break; - case iAsBx: - sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_sBx(i)); - break; - case iAx: - sprintf(buff+strlen(buff), "%-12s%4d", name, GETARG_Ax(i)); - break; - } - return buff; -} - - -#if 0 -void luaI_printcode (Proto *pt, int size) { - int pc; - for (pc=0; pcmaxstacksize); - setnameval(L, "numparams", p->numparams); - for (pc=0; pcsizecode; pc++) { - char buff[100]; - lua_pushinteger(L, pc+1); - lua_pushstring(L, buildop(p, pc, buff)); - lua_settable(L, -3); - } - return 1; -} - - -static int listk (lua_State *L) { - Proto *p; - int i; - luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), - 1, "Lua function expected"); - p = getproto(obj_at(L, 1)); - lua_createtable(L, p->sizek, 0); - for (i=0; isizek; i++) { - pushobject(L, p->k+i); - lua_rawseti(L, -2, i+1); - } - return 1; -} - - -static int listlocals (lua_State *L) { - Proto *p; - int pc = luaL_checkint(L, 2) - 1; - int i = 0; - const char *name; - luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), - 1, "Lua function expected"); - p = getproto(obj_at(L, 1)); - while ((name = luaF_getlocalname(p, ++i, pc)) != NULL) - lua_pushstring(L, name); - return i-1; -} - -/* }====================================================== */ - - - - -static int get_limits (lua_State *L) { - lua_createtable(L, 0, 5); - setnameval(L, "BITS_INT", LUAI_BITSINT); - setnameval(L, "LFPF", LFIELDS_PER_FLUSH); - setnameval(L, "MAXSTACK", MAXSTACK); - setnameval(L, "NUM_OPCODES", NUM_OPCODES); - return 1; -} - - -static int mem_query (lua_State *L) { - if (lua_isnone(L, 1)) { - lua_pushinteger(L, l_memcontrol.total); - lua_pushinteger(L, l_memcontrol.numblocks); - lua_pushinteger(L, l_memcontrol.maxmem); - return 3; - } - else if (lua_isnumber(L, 1)) { - l_memcontrol.memlimit = luaL_checkint(L, 1); - return 0; - } - else { - const char *t = luaL_checkstring(L, 1); - int i; - for (i = LUA_NUMTAGS - 1; i >= 0; i--) { - if (strcmp(t, ttypename(i)) == 0) { - lua_pushinteger(L, l_memcontrol.objcount[i]); - return 1; - } - } - return luaL_error(L, "unkown type '%s'", t); - } -} - - -static int settrick (lua_State *L) { - if (ttisnil(obj_at(L, 1))) - l_Trick = NULL; - else - l_Trick = gcvalue(obj_at(L, 1)); - return 0; -} - - -static int get_gccolor (lua_State *L) { - TValue *o; - luaL_checkany(L, 1); - o = obj_at(L, 1); - if (!iscollectable(o)) - lua_pushstring(L, "no collectable"); - else { - int marked = gcvalue(o)->gch.marked; - int n = 1; - lua_pushstring(L, iswhite(gcvalue(o)) ? "white" : - isblack(gcvalue(o)) ? "black" : "grey"); - if (testbit(marked, FINALIZEDBIT)) { - lua_pushliteral(L, "/finalized"); n++; - } - if (testbit(marked, SEPARATED)) { - lua_pushliteral(L, "/separated"); n++; - } - if (testbit(marked, FIXEDBIT)) { - lua_pushliteral(L, "/fixed"); n++; - } - if (testbit(marked, OLDBIT)) { - lua_pushliteral(L, "/old"); n++; - } - lua_concat(L, n); - } - return 1; -} - - -static int gc_state (lua_State *L) { - static const char *statenames[] = {"propagate", "atomic", - "sweepstring", "sweepudata", "sweep", "pause", ""}; - int option = luaL_checkoption(L, 1, "", statenames); - if (option == GCSpause + 1) { - lua_pushstring(L, statenames[G(L)->gcstate]); - return 1; - } - else { - global_State *g = G(L); - if (g->gckind == KGC_GEN && option == GCSpause) - luaL_error(L, "cannot go to 'pause' state in generational mode"); - lua_lock(L); - if (option < g->gcstate) { /* must cross 'pause'? */ - luaC_runtilstate(L, bitmask(GCSpause)); /* run until pause */ - if (g->gckind == KGC_GEN) - g->gcstate = GCSpropagate; /* skip pause in gen. mode */ - } - luaC_runtilstate(L, bitmask(option)); - lua_assert(G(L)->gcstate == option); - lua_unlock(L); - return 0; - } -} - - -static int hash_query (lua_State *L) { - if (lua_isnone(L, 2)) { - luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "string expected"); - lua_pushinteger(L, tsvalue(obj_at(L, 1))->hash); - } - else { - TValue *o = obj_at(L, 1); - Table *t; - luaL_checktype(L, 2, LUA_TTABLE); - t = hvalue(obj_at(L, 2)); - lua_pushinteger(L, luaH_mainposition(t, o) - t->node); - } - return 1; -} - - -static int stacklevel (lua_State *L) { - unsigned long a = 0; - lua_pushinteger(L, (L->top - L->stack)); - lua_pushinteger(L, (L->stack_last - L->stack)); - lua_pushinteger(L, (unsigned long)&a); - return 5; -} - - -static int table_query (lua_State *L) { - const Table *t; - int i = luaL_optint(L, 2, -1); - luaL_checktype(L, 1, LUA_TTABLE); - t = hvalue(obj_at(L, 1)); - if (i == -1) { - lua_pushinteger(L, t->sizearray); - lua_pushinteger(L, luaH_isdummy(t->node) ? 0 : sizenode(t)); - lua_pushinteger(L, t->lastfree - t->node); - } - else if (i < t->sizearray) { - lua_pushinteger(L, i); - pushobject(L, &t->array[i]); - lua_pushnil(L); - } - else if ((i -= t->sizearray) < sizenode(t)) { - if (!ttisnil(gval(gnode(t, i))) || - ttisnil(gkey(gnode(t, i))) || - ttisnumber(gkey(gnode(t, i)))) { - pushobject(L, gkey(gnode(t, i))); - } - else - lua_pushliteral(L, ""); - pushobject(L, gval(gnode(t, i))); - if (gnext(&t->node[i])) - lua_pushinteger(L, gnext(&t->node[i]) - t->node); - else - lua_pushnil(L); - } - return 3; -} - - -static int string_query (lua_State *L) { - stringtable *tb = &G(L)->strt; - int s = luaL_optint(L, 2, 0) - 1; - if (s==-1) { - lua_pushinteger(L ,tb->nuse); - lua_pushinteger(L ,tb->size); - return 2; - } - else if (s < tb->size) { - GCObject *ts; - int n = 0; - for (ts = tb->hash[s]; ts; ts = gch(ts)->next) { - setsvalue2s(L, L->top, rawgco2ts(ts)); - api_incr_top(L); - n++; - } - return n; - } - return 0; -} - - -static int tref (lua_State *L) { - int level = lua_gettop(L); - luaL_checkany(L, 1); - lua_pushvalue(L, 1); - lua_pushinteger(L, luaL_ref(L, LUA_REGISTRYINDEX)); - lua_assert(lua_gettop(L) == level+1); /* +1 for result */ - return 1; -} - -static int getref (lua_State *L) { - int level = lua_gettop(L); - lua_rawgeti(L, LUA_REGISTRYINDEX, luaL_checkint(L, 1)); - lua_assert(lua_gettop(L) == level+1); - return 1; -} - -static int unref (lua_State *L) { - int level = lua_gettop(L); - luaL_unref(L, LUA_REGISTRYINDEX, luaL_checkint(L, 1)); - lua_assert(lua_gettop(L) == level); - return 0; -} - - -static int upvalue (lua_State *L) { - int n = luaL_checkint(L, 2); - luaL_checktype(L, 1, LUA_TFUNCTION); - if (lua_isnone(L, 3)) { - const char *name = lua_getupvalue(L, 1, n); - if (name == NULL) return 0; - lua_pushstring(L, name); - return 2; - } - else { - const char *name = lua_setupvalue(L, 1, n); - lua_pushstring(L, name); - return 1; - } -} - - -static int newuserdata (lua_State *L) { - size_t size = luaL_checkint(L, 1); - char *p = cast(char *, lua_newuserdata(L, size)); - while (size--) *p++ = '\0'; - return 1; -} - - -static int pushuserdata (lua_State *L) { - lua_pushlightuserdata(L, cast(void *, luaL_checkinteger(L, 1))); - return 1; -} - - -static int udataval (lua_State *L) { - lua_pushinteger(L, cast(long, lua_touserdata(L, 1))); - return 1; -} - - -static int doonnewstack (lua_State *L) { - lua_State *L1 = lua_newthread(L); - size_t l; - const char *s = luaL_checklstring(L, 1, &l); - int status = luaL_loadbuffer(L1, s, l, s); - if (status == LUA_OK) - status = lua_pcall(L1, 0, 0, 0); - lua_pushinteger(L, status); - return 1; -} - - -static int s2d (lua_State *L) { - lua_pushnumber(L, *cast(const double *, luaL_checkstring(L, 1))); - return 1; -} - - -static int d2s (lua_State *L) { - double d = luaL_checknumber(L, 1); - lua_pushlstring(L, cast(char *, &d), sizeof(d)); - return 1; -} - - -static int num2int (lua_State *L) { - lua_pushinteger(L, lua_tointeger(L, 1)); - return 1; -} - - -static int newstate (lua_State *L) { - void *ud; - lua_Alloc f = lua_getallocf(L, &ud); - lua_State *L1 = lua_newstate(f, ud); - if (L1) { - lua_atpanic(L1, tpanic); - lua_pushlightuserdata(L, L1); - } - else - lua_pushnil(L); - return 1; -} - - -static lua_State *getstate (lua_State *L) { - lua_State *L1 = cast(lua_State *, lua_touserdata(L, 1)); - luaL_argcheck(L, L1 != NULL, 1, "state expected"); - return L1; -} - - -static int loadlib (lua_State *L) { - static const luaL_Reg libs[] = { - {"_G", luaopen_base}, - {"coroutine", luaopen_coroutine}, - {"debug", luaopen_debug}, - {"io", luaopen_io}, - {"os", luaopen_os}, - {"math", luaopen_math}, - {"string", luaopen_string}, - {"table", luaopen_table}, - {NULL, NULL} - }; - lua_State *L1 = getstate(L); - int i; - luaL_requiref(L1, "package", luaopen_package, 1); - luaL_getsubtable(L1, LUA_REGISTRYINDEX, "_PRELOAD"); - for (i = 0; libs[i].name; i++) { - lua_pushcfunction(L1, libs[i].func); - lua_setfield(L1, -2, libs[i].name); - } - return 0; -} - -static int closestate (lua_State *L) { - lua_State *L1 = getstate(L); - lua_close(L1); - return 0; -} - -static int doremote (lua_State *L) { - lua_State *L1 = getstate(L); - size_t lcode; - const char *code = luaL_checklstring(L, 2, &lcode); - int status; - lua_settop(L1, 0); - status = luaL_loadbuffer(L1, code, lcode, code); - if (status == LUA_OK) - status = lua_pcall(L1, 0, LUA_MULTRET, 0); - if (status != LUA_OK) { - lua_pushnil(L); - lua_pushstring(L, lua_tostring(L1, -1)); - lua_pushinteger(L, status); - return 3; - } - else { - int i = 0; - while (!lua_isnone(L1, ++i)) - lua_pushstring(L, lua_tostring(L1, i)); - lua_pop(L1, i-1); - return i-1; - } -} - - -static int int2fb_aux (lua_State *L) { - int b = luaO_int2fb(luaL_checkint(L, 1)); - lua_pushinteger(L, b); - lua_pushinteger(L, luaO_fb2int(b)); - return 2; -} - - - -/* -** {====================================================== -** function to test the API with C. It interprets a kind of assembler -** language with calls to the API, so the test can be driven by Lua code -** ======================================================= -*/ - - -static void sethookaux (lua_State *L, int mask, int count, const char *code); - -static const char *const delimits = " \t\n,;"; - -static void skip (const char **pc) { - for (;;) { - if (**pc != '\0' && strchr(delimits, **pc)) (*pc)++; - else if (**pc == '#') { - while (**pc != '\n' && **pc != '\0') (*pc)++; - } - else break; - } -} - -static int getnum_aux (lua_State *L, lua_State *L1, const char **pc) { - int res = 0; - int sig = 1; - skip(pc); - if (**pc == '.') { - res = lua_tointeger(L1, -1); - lua_pop(L1, 1); - (*pc)++; - return res; - } - else if (**pc == '-') { - sig = -1; - (*pc)++; - } - if (!lisdigit(cast_uchar(**pc))) - luaL_error(L, "number expected (%s)", *pc); - while (lisdigit(cast_uchar(**pc))) res = res*10 + (*(*pc)++) - '0'; - return sig*res; -} - -static const char *getstring_aux (lua_State *L, char *buff, const char **pc) { - int i = 0; - skip(pc); - if (**pc == '"' || **pc == '\'') { /* quoted string? */ - int quote = *(*pc)++; - while (**pc != quote) { - if (**pc == '\0') luaL_error(L, "unfinished string in C script"); - buff[i++] = *(*pc)++; - } - (*pc)++; - } - else { - while (**pc != '\0' && !strchr(delimits, **pc)) - buff[i++] = *(*pc)++; - } - buff[i] = '\0'; - return buff; -} - - -static int getindex_aux (lua_State *L, lua_State *L1, const char **pc) { - skip(pc); - switch (*(*pc)++) { - case 'R': return LUA_REGISTRYINDEX; - case 'G': return luaL_error(L, "deprecated index 'G'"); - case 'U': return lua_upvalueindex(getnum_aux(L, L1, pc)); - default: (*pc)--; return getnum_aux(L, L1, pc); - } -} - - -static void pushcode (lua_State *L, int code) { - static const char *const codes[] = {"OK", "YIELD", "ERRRUN", - "ERRSYNTAX", "ERRMEM", "ERRGCMM", "ERRERR"}; - lua_pushstring(L, codes[code]); -} - - -#define EQ(s1) (strcmp(s1, inst) == 0) - -#define getnum (getnum_aux(L, L1, &pc)) -#define getstring (getstring_aux(L, buff, &pc)) -#define getindex (getindex_aux(L, L1, &pc)) - - -static int testC (lua_State *L); -static int Cfunck (lua_State *L); - -static int runC (lua_State *L, lua_State *L1, const char *pc) { - char buff[300]; - int status = 0; - if (pc == NULL) return luaL_error(L, "attempt to runC null script"); - for (;;) { - const char *inst = getstring; - if EQ("") return 0; - else if EQ("absindex") { - lua_pushnumber(L1, lua_absindex(L1, getindex)); - } - else if EQ("isnumber") { - lua_pushboolean(L1, lua_isnumber(L1, getindex)); - } - else if EQ("isstring") { - lua_pushboolean(L1, lua_isstring(L1, getindex)); - } - else if EQ("istable") { - lua_pushboolean(L1, lua_istable(L1, getindex)); - } - else if EQ("iscfunction") { - lua_pushboolean(L1, lua_iscfunction(L1, getindex)); - } - else if EQ("isfunction") { - lua_pushboolean(L1, lua_isfunction(L1, getindex)); - } - else if EQ("isuserdata") { - lua_pushboolean(L1, lua_isuserdata(L1, getindex)); - } - else if EQ("isudataval") { - lua_pushboolean(L1, lua_islightuserdata(L1, getindex)); - } - else if EQ("isnil") { - lua_pushboolean(L1, lua_isnil(L1, getindex)); - } - else if EQ("isnull") { - lua_pushboolean(L1, lua_isnone(L1, getindex)); - } - else if EQ("tonumber") { - lua_pushnumber(L1, lua_tonumber(L1, getindex)); - } - else if EQ("topointer") { - lua_pushnumber(L1, cast(size_t, lua_topointer(L1, getindex))); - } - else if EQ("tostring") { - const char *s = lua_tostring(L1, getindex); - const char *s1 = lua_pushstring(L1, s); - lua_assert((s == NULL && s1 == NULL) || (strcmp)(s, s1) == 0); - } - else if EQ("objsize") { - lua_pushinteger(L1, lua_rawlen(L1, getindex)); - } - else if EQ("len") { - lua_len(L1, getindex); - } - else if EQ("Llen") { - lua_pushinteger(L1, luaL_len(L1, getindex)); - } - else if EQ("tocfunction") { - lua_pushcfunction(L1, lua_tocfunction(L1, getindex)); - } - else if EQ("func2num") { - lua_CFunction func = lua_tocfunction(L1, getindex); - lua_pushnumber(L1, cast(size_t, func)); - } - else if EQ("return") { - int n = getnum; - if (L1 != L) { - int i; - for (i = 0; i < n; i++) - lua_pushstring(L, lua_tostring(L1, -(n - i))); - } - return n; - } - else if EQ("gettop") { - lua_pushinteger(L1, lua_gettop(L1)); - } - else if EQ("settop") { - lua_settop(L1, getnum); - } - else if EQ("pop") { - lua_pop(L1, getnum); - } - else if EQ("pushnum") { - lua_pushinteger(L1, getnum); - } - else if EQ("pushstring") { - lua_pushstring(L1, getstring); - } - else if EQ("pushnil") { - lua_pushnil(L1); - } - else if EQ("pushbool") { - lua_pushboolean(L1, getnum); - } - else if EQ("newtable") { - lua_newtable(L1); - } - else if EQ("newuserdata") { - lua_newuserdata(L1, getnum); - } - else if EQ("tobool") { - lua_pushboolean(L1, lua_toboolean(L1, getindex)); - } - else if EQ("pushvalue") { - lua_pushvalue(L1, getindex); - } - else if EQ("pushcclosure") { - lua_pushcclosure(L1, testC, getnum); - } - else if EQ("pushupvalueindex") { - lua_pushinteger(L1, lua_upvalueindex(getnum)); - } - else if EQ("remove") { - lua_remove(L1, getnum); - } - else if EQ("insert") { - lua_insert(L1, getnum); - } - else if EQ("replace") { - lua_replace(L1, getindex); - } - else if EQ("copy") { - int f = getindex; - lua_copy(L1, f, getindex); - } - else if EQ("gettable") { - lua_gettable(L1, getindex); - } - else if EQ("getglobal") { - lua_getglobal(L1, getstring); - } - else if EQ("getfield") { - int t = getindex; - lua_getfield(L1, t, getstring); - } - else if EQ("setfield") { - int t = getindex; - lua_setfield(L1, t, getstring); - } - else if EQ("rawgeti") { - int t = getindex; - lua_rawgeti(L1, t, getnum); - } - else if EQ("settable") { - lua_settable(L1, getindex); - } - else if EQ("setglobal") { - lua_setglobal(L1, getstring); - } - else if EQ("next") { - lua_next(L1, -2); - } - else if EQ("concat") { - lua_concat(L1, getnum); - } - else if EQ("print") { - int n = getnum; - if (n != 0) { - printf("%s\n", luaL_tolstring(L1, n, NULL)); - lua_pop(L1, 1); - } - else { - int i; - n = lua_gettop(L1); - for (i = 1; i <= n; i++) { - printf("%s ", luaL_tolstring(L1, i, NULL)); - lua_pop(L1, 1); - } - printf("\n"); - } - } - else if EQ("arith") { - static char ops[] = "+-*/%^_"; - int op; - skip(&pc); - op = strchr(ops, *pc++) - ops; - lua_arith(L1, op); - } - else if EQ("compare") { - int a = getindex; - int b = getindex; - lua_pushboolean(L1, lua_compare(L1, a, b, getnum)); - } - else if EQ("call") { - int narg = getnum; - int nres = getnum; - lua_call(L1, narg, nres); - } - else if EQ("pcall") { - int narg = getnum; - int nres = getnum; - status = lua_pcall(L1, narg, nres, 0); - } - else if EQ("pcallk") { - int narg = getnum; - int nres = getnum; - int i = getindex; - status = lua_pcallk(L1, narg, nres, 0, i, Cfunck); - } - else if EQ("callk") { - int narg = getnum; - int nres = getnum; - int i = getindex; - lua_callk(L1, narg, nres, i, Cfunck); - } - else if EQ("yield") { - return lua_yield(L1, getnum); - } - else if EQ("yieldk") { - int nres = getnum; - int i = getindex; - return lua_yieldk(L1, nres, i, Cfunck); - } - else if EQ("newthread") { - lua_newthread(L1); - } - else if EQ("resume") { - int i = getindex; - status = lua_resume(lua_tothread(L1, i), L, getnum); - } - else if EQ("pushstatus") { - pushcode(L1, status); - } - else if EQ("xmove") { - int f = getindex; - int t = getindex; - lua_State *fs = (f == 0) ? L1 : lua_tothread(L1, f); - lua_State *ts = (t == 0) ? L1 : lua_tothread(L1, t); - int n = getnum; - if (n == 0) n = lua_gettop(fs); - lua_xmove(fs, ts, n); - } - else if EQ("loadstring") { - size_t sl; - const char *s = luaL_checklstring(L1, getnum, &sl); - luaL_loadbuffer(L1, s, sl, s); - } - else if EQ("loadfile") { - luaL_loadfile(L1, luaL_checkstring(L1, getnum)); - } - else if EQ("setmetatable") { - lua_setmetatable(L1, getindex); - } - else if EQ("getmetatable") { - if (lua_getmetatable(L1, getindex) == 0) - lua_pushnil(L1); - } - else if EQ("type") { - lua_pushstring(L1, luaL_typename(L1, getnum)); - } - else if EQ("append") { - int t = getindex; - int i = lua_rawlen(L1, t); - lua_rawseti(L1, t, i + 1); - } - else if EQ("getctx") { - int i = 0; - int s = lua_getctx(L1, &i); - pushcode(L1, s); - lua_pushinteger(L1, i); - } - else if EQ("checkstack") { - int sz = getnum; - luaL_checkstack(L1, sz, getstring); - } - else if EQ("newmetatable") { - lua_pushboolean(L1, luaL_newmetatable(L1, getstring)); - } - else if EQ("testudata") { - int i = getindex; - lua_pushboolean(L1, luaL_testudata(L1, i, getstring) != NULL); - } - else if EQ("gsub") { - int a = getnum; int b = getnum; int c = getnum; - luaL_gsub(L1, lua_tostring(L1, a), - lua_tostring(L1, b), - lua_tostring(L1, c)); - } - else if EQ("sethook") { - int mask = getnum; - int count = getnum; - sethookaux(L1, mask, count, getstring); - } - else if EQ("throw") { -#if defined(__cplusplus) -static struct X { int x; } x; - throw x; -#else - luaL_error(L1, "C++"); -#endif - break; - } - else luaL_error(L, "unknown instruction %s", buff); - } - return 0; -} - - -static int testC (lua_State *L) { - lua_State *L1; - const char *pc; - if (lua_isuserdata(L, 1)) { - L1 = getstate(L); - pc = luaL_checkstring(L, 2); - } - else if (lua_isthread(L, 1)) { - L1 = lua_tothread(L, 1); - pc = luaL_checkstring(L, 2); - } - else { - L1 = L; - pc = luaL_checkstring(L, 1); - } - return runC(L, L1, pc); -} - - -static int Cfunc (lua_State *L) { - return runC(L, L, lua_tostring(L, lua_upvalueindex(1))); -} - - -static int Cfunck (lua_State *L) { - int i = 0; - lua_getctx(L, &i); - return runC(L, L, lua_tostring(L, i)); -} - - -static int makeCfunc (lua_State *L) { - luaL_checkstring(L, 1); - lua_pushcclosure(L, Cfunc, lua_gettop(L)); - return 1; -} - - -/* }====================================================== */ - - -/* -** {====================================================== -** tests for C hooks -** ======================================================= -*/ - -/* -** C hook that runs the C script stored in registry.C_HOOK[L] -*/ -static void Chook (lua_State *L, lua_Debug *ar) { - const char *scpt; - const char *const events [] = {"call", "ret", "line", "count", "tailcall"}; - lua_getfield(L, LUA_REGISTRYINDEX, "C_HOOK"); - lua_pushlightuserdata(L, L); - lua_gettable(L, -2); /* get C_HOOK[L] (script saved by sethookaux) */ - scpt = lua_tostring(L, -1); /* not very religious (string will be popped) */ - lua_pop(L, 2); /* remove C_HOOK and script */ - lua_pushstring(L, events[ar->event]); /* may be used by script */ - lua_pushinteger(L, ar->currentline); /* may be used by script */ - runC(L, L, scpt); /* run script from C_HOOK[L] */ -} - - -/* -** sets registry.C_HOOK[L] = scpt and sets Chook as a hook -*/ -static void sethookaux (lua_State *L, int mask, int count, const char *scpt) { - if (*scpt == '\0') { /* no script? */ - lua_sethook(L, NULL, 0, 0); /* turn off hooks */ - return; - } - lua_getfield(L, LUA_REGISTRYINDEX, "C_HOOK"); /* get C_HOOK table */ - if (!lua_istable(L, -1)) { /* no hook table? */ - lua_pop(L, 1); /* remove previous value */ - lua_newtable(L); /* create new C_HOOK table */ - lua_pushvalue(L, -1); - lua_setfield(L, LUA_REGISTRYINDEX, "C_HOOK"); /* register it */ - } - lua_pushlightuserdata(L, L); - lua_pushstring(L, scpt); - lua_settable(L, -3); /* C_HOOK[L] = script */ - lua_sethook(L, Chook, mask, count); -} - - -static int sethook (lua_State *L) { - if (lua_isnoneornil(L, 1)) - lua_sethook(L, NULL, 0, 0); /* turn off hooks */ - else { - const char *scpt = luaL_checkstring(L, 1); - const char *smask = luaL_checkstring(L, 2); - int count = luaL_optint(L, 3, 0); - int mask = 0; - if (strchr(smask, 'c')) mask |= LUA_MASKCALL; - if (strchr(smask, 'r')) mask |= LUA_MASKRET; - if (strchr(smask, 'l')) mask |= LUA_MASKLINE; - if (count > 0) mask |= LUA_MASKCOUNT; - sethookaux(L, mask, count, scpt); - } - return 0; -} - - -static int coresume (lua_State *L) { - int status; - lua_State *co = lua_tothread(L, 1); - luaL_argcheck(L, co, 1, "coroutine expected"); - status = lua_resume(co, L, 0); - if (status != LUA_OK && status != LUA_YIELD) { - lua_pushboolean(L, 0); - lua_insert(L, -2); - return 2; /* return false + error message */ - } - else { - lua_pushboolean(L, 1); - return 1; - } -} - -/* }====================================================== */ - - - -static const struct luaL_Reg tests_funcs[] = { - {"checkmemory", lua_checkmemory}, - {"closestate", closestate}, - {"d2s", d2s}, - {"doonnewstack", doonnewstack}, - {"doremote", doremote}, - {"gccolor", get_gccolor}, - {"gcstate", gc_state}, - {"getref", getref}, - {"hash", hash_query}, - {"int2fb", int2fb_aux}, - {"limits", get_limits}, - {"listcode", listcode}, - {"listk", listk}, - {"listlocals", listlocals}, - {"loadlib", loadlib}, - {"newstate", newstate}, - {"newuserdata", newuserdata}, - {"num2int", num2int}, - {"pushuserdata", pushuserdata}, - {"querystr", string_query}, - {"querytab", table_query}, - {"ref", tref}, - {"resume", coresume}, - {"s2d", s2d}, - {"sethook", sethook}, - {"stacklevel", stacklevel}, - {"testC", testC}, - {"makeCfunc", makeCfunc}, - {"totalmem", mem_query}, - {"trick", settrick}, - {"udataval", udataval}, - {"unref", unref}, - {"upvalue", upvalue}, - {NULL, NULL} -}; - - -static void checkfinalmem (void) { - lua_assert(l_memcontrol.numblocks == 0); - lua_assert(l_memcontrol.total == 0); -} - - -int luaB_opentests (lua_State *L) { - void *ud; - lua_atpanic(L, &tpanic); - atexit(checkfinalmem); - lua_assert(lua_getallocf(L, &ud) == debug_realloc); - lua_assert(ud == cast(void *, &l_memcontrol)); - lua_setallocf(L, lua_getallocf(L, NULL), ud); - luaL_newlib(L, tests_funcs); - return 1; -} - -#endif diff --git a/utils/lua_tests/ltests/ltests.h b/utils/lua_tests/ltests/ltests.h deleted file mode 100644 index 7a9d329df..000000000 --- a/utils/lua_tests/ltests/ltests.h +++ /dev/null @@ -1,93 +0,0 @@ -/* -** $Id: ltests.h,v 2.33 2010/07/28 15:51:59 roberto Exp $ -** Internal Header for Debugging of the Lua Implementation -** See Copyright Notice in lua.h -*/ - -#ifndef ltests_h -#define ltests_h - - -#include - -/* do not use compatibility macros in Lua code */ -#undef LUA_COMPAT_API - -#define LUA_DEBUG - -#undef NDEBUG -#include -#define lua_assert(c) assert(c) - - -/* to avoid warnings, and to make sure value is really unused */ -#define UNUSED(x) (x=0, (void)(x)) - - -/* memory allocator control variables */ -typedef struct Memcontrol { - unsigned long numblocks; - unsigned long total; - unsigned long maxmem; - unsigned long memlimit; - unsigned long objcount[LUA_NUMTAGS]; -} Memcontrol; - -extern Memcontrol l_memcontrol; - - -/* -** generic variable for debug tricks -*/ -extern void *l_Trick; - - -void *debug_realloc (void *ud, void *block, size_t osize, size_t nsize); - - -typedef struct CallInfo *pCallInfo; - -int lua_checkmemory (lua_State *L); - - -/* test for lock/unlock */ -#undef luai_userstateopen -#undef luai_userstatethread -#undef lua_lock -#undef lua_unlock - -struct L_EXTRA { int lock; int *plock; }; -#define LUAI_EXTRASPACE sizeof(struct L_EXTRA) -#define getlock(l) (cast(struct L_EXTRA *, l) - 1) -#define luai_userstateopen(l) \ - (getlock(l)->lock = 0, getlock(l)->plock = &(getlock(l)->lock)) -#define luai_userstatethread(l,l1) (getlock(l1)->plock = getlock(l)->plock) -#define luai_userstatefree(l,l1) \ - lua_assert(getlock(l)->plock == getlock(l1)->plock) -#define lua_lock(l) lua_assert((*getlock(l)->plock)++ == 0) -#define lua_unlock(l) lua_assert(--(*getlock(l)->plock) == 0) - - -int luaB_opentests (lua_State *L); - - -#if defined(lua_c) -#define luaL_newstate() lua_newstate(debug_realloc, &l_memcontrol) -#define luaL_openlibs(L) \ - { (luaL_openlibs)(L); luaL_requiref(L, "T", luaB_opentests, 1); } -#endif - - - -/* change some sizes to give some bugs a chance */ - -#undef LUAL_BUFFERSIZE -#define LUAL_BUFFERSIZE 23 -#define MINSTRTABSIZE 2 - - -#undef LUAI_USER_ALIGNMENT_T -#define LUAI_USER_ALIGNMENT_T union { char b[32]; } - - -#endif diff --git a/utils/lua_tests/main.lua b/utils/lua_tests/main.lua deleted file mode 100644 index fa6bf0e2d..000000000 --- a/utils/lua_tests/main.lua +++ /dev/null @@ -1,260 +0,0 @@ -# testing special comment on first line - --- most (all?) tests here assume a reasonable "Unix-like" shell -if _port then return end - -print ("testing lua.c options") - -assert(os.execute()) -- machine has a system command - -prog = os.tmpname() -otherprog = os.tmpname() -out = os.tmpname() - -do - local i = 0 - while arg[i] do i=i-1 end - progname = arg[i+1] -end -print("progname: "..progname) - -local prepfile = function (s, p) - p = p or prog - io.output(p) - io.write(s) - assert(io.close()) -end - -function getoutput () - io.input(out) - local t = io.read("*a") - io.input():close() - assert(os.remove(out)) - return t -end - -function checkprogout (s) - local t = getoutput() - for line in string.gmatch(s, ".-\n") do - assert(string.find(t, line, 1, true)) - end -end - -function checkout (s) - local t = getoutput() - if s ~= t then print(string.format("'%s' - '%s'\n", s, t)) end - assert(s == t) - return t -end - -function auxrun (...) - local s = string.format(...) - s = string.gsub(s, "lua", '"'..progname..'"', 1) - return os.execute(s) -end - -function RUN (...) - assert(auxrun(...)) -end - -function NoRun (...) - assert(not auxrun(...)) -end - -function NoRunMsg (...) - print("\n(the next error is expected by the test)") - return NoRun(...) -end - --- test environment variables used by Lua -prepfile("print(package.path)") - -RUN("env LUA_INIT= LUA_PATH=x lua %s > %s", prog, out) -checkout("x\n") - -RUN("env LUA_INIT= LUA_PATH_5_2=y LUA_PATH=x lua %s > %s", prog, out) -checkout("y\n") - -prepfile("print(package.cpath)") - -RUN("env LUA_INIT= LUA_CPATH=xuxu lua %s > %s", prog, out) -checkout("xuxu\n") - -RUN("env LUA_INIT= LUA_CPATH_5_2=yacc LUA_CPATH=x lua %s > %s", prog, out) -checkout("yacc\n") - -prepfile("print(X)") -RUN('env LUA_INIT="X=3" lua %s > %s', prog, out) -checkout("3\n") - -prepfile("print(X)") -RUN('env LUA_INIT_5_2="X=10" LUA_INIT="X=3" lua %s > %s', prog, out) -checkout("10\n") - --- test option '-E' -prepfile("print(package.path, package.cpath)") -RUN('env LUA_INIT="error(10)" LUA_PATH=xxx LUA_CPATH=xxx lua -E %s > %s', - prog, out) -local defaultpath = getoutput() -defaultpath = string.match(defaultpath, "^(.-)\t") -- remove tab -assert(not string.find(defaultpath, "xxx") and string.find(defaultpath, "lua")) - - --- test replacement of ';;' to default path -local function convert (p) - prepfile("print(package.path)") - RUN('env LUA_PATH="%s" lua %s > %s', p, prog, out) - local expected = getoutput() - expected = string.sub(expected, 1, -2) -- cut final end of line - assert(string.gsub(p, ";;", ";"..defaultpath..";") == expected) -end - -convert(";") -convert(";;") -convert(";;;") -convert(";;;;") -convert(";;;;;") -convert(";;a;;;bc") - - --- test 2 files -prepfile("print(1); a=2; return {x=15}") -prepfile(("print(a); print(_G['%s'].x)"):format(prog), otherprog) -RUN('env LUA_PATH="?;;" lua -l %s -l%s -lstring -l io %s > %s', prog, otherprog, otherprog, out) -checkout("1\n2\n15\n2\n15\n") - -local a = [[ - assert(#arg == 3 and arg[1] == 'a' and - arg[2] == 'b' and arg[3] == 'c') - assert(arg[-1] == '--' and arg[-2] == "-e " and arg[-3] == '%s') - assert(arg[4] == nil and arg[-4] == nil) - local a, b, c = ... - assert(... == 'a' and a == 'a' and b == 'b' and c == 'c') -]] -a = string.format(a, progname) -prepfile(a) -RUN('lua "-e " -- %s a b c', prog) - -prepfile"assert(arg==nil)" -prepfile("assert(arg)", otherprog) -RUN('env LUA_PATH="?;;" lua -l%s - < %s', prog, otherprog) - -prepfile"" -RUN("lua - < %s > %s", prog, out) -checkout("") - --- test many arguments -prepfile[[print(({...})[30])]] -RUN("lua %s %s > %s", prog, string.rep(" a", 30), out) -checkout("a\n") - -RUN([[lua "-eprint(1)" -ea=3 -e "print(a)" > %s]], out) -checkout("1\n3\n") - -prepfile[[ - print( -1, a -) -]] -RUN("lua - < %s > %s", prog, out) -checkout("1\tnil\n") - -prepfile[[ -= (6*2-6) -- === -a -= 10 -print(a) -= a]] -RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out) -checkprogout("6\n10\n10\n\n") - -prepfile("a = [[b\nc\nd\ne]]\n=a") -print("temporary program file: "..prog) -RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out) -checkprogout("b\nc\nd\ne\n\n") - -prompt = "alo" -prepfile[[ -- -a = 2 -]] -RUN([[lua "-e_PROMPT='%s'" -i < %s > %s]], prompt, prog, out) -local t = getoutput() -assert(string.find(t, prompt .. ".*" .. prompt .. ".*" .. prompt)) - --- test for error objects -prepfile[[ -debug = require "debug" -m = {x=0} -setmetatable(m, {__tostring = function(x) - return debug.getinfo(4).currentline + x.x -end}) -error(m) -]] -NoRun([[lua %s 2> %s]], prog, out) -- no message -checkout(progname..": 6\n") - - -s = [=[ -- -function f ( x ) - local a = [[ -xuxu -]] - local b = "\ -xuxu\n" - if x == 11 then return 1 , 2 end --[[ test multiple returns ]] - return x + 1 - --\\ -end -=( f( 10 ) ) -assert( a == b ) -=f( 11 ) ]=] -s = string.gsub(s, ' ', '\n\n') -prepfile(s) -RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out) -checkprogout("11\n1\t2\n\n") - -prepfile[[#comment in 1st line without \n at the end]] -RUN("lua %s", prog) - -prepfile[[#test line number when file starts with comment line -debug = require"debug" -print(debug.getinfo(1).currentline) -]] -RUN("lua %s > %s", prog, out) -checkprogout('3') - --- close Lua with an open file -prepfile(string.format([[io.output(%q); io.write('alo')]], out)) -RUN("lua %s", prog) -checkout('alo') - --- bug in 5.2 beta (extra \0 after version line) -RUN([[lua -v -e'print"hello"' > %s]], out) -t = getoutput() -assert(string.find(t, "PUC%-Rio\nhello")) - - --- testing os.exit -prepfile("os.exit(nil, true)") -RUN("lua %s", prog) -prepfile("os.exit(0, true)") -RUN("lua %s", prog) -prepfile("os.exit(true, true)") -RUN("lua %s", prog) -prepfile("os.exit(1, true)") -NoRun("lua %s", prog) -- no message -prepfile("os.exit(false, true)") -NoRun("lua %s", prog) -- no message - -assert(os.remove(prog)) -assert(os.remove(otherprog)) -assert(not os.remove(out)) - -RUN("lua -v") - -NoRunMsg("lua -h") -NoRunMsg("lua -e") -NoRunMsg("lua -e a") -NoRunMsg("lua -f") - -print("OK") diff --git a/utils/lua_tests/math.lua b/utils/lua_tests/math.lua deleted file mode 100644 index 9dbeca646..000000000 --- a/utils/lua_tests/math.lua +++ /dev/null @@ -1,287 +0,0 @@ -print("testing numbers and math lib") - - --- basic float notation -assert(0e12 == 0 and .0 == 0 and 0. == 0 and .2e2 == 20 and 2.E-1 == 0.2) - -do - local a,b,c = "2", " 3e0 ", " 10 " - assert(a+b == 5 and -b == -3 and b+"2" == 5 and "10"-c == 0) - assert(type(a) == 'string' and type(b) == 'string' and type(c) == 'string') - assert(a == "2" and b == " 3e0 " and c == " 10 " and -c == -" 10 ") - assert(c%a == 0 and a^b == 08) - a = 0 - assert(a == -a and 0 == -0) -end - -do - local x = -1 - local mz = 0/x -- minus zero - t = {[0] = 10, 20, 30, 40, 50} - assert(t[mz] == t[0] and t[-0] == t[0]) -end - -do - local a,b = math.modf(3.5) - assert(a == 3 and b == 0.5) - assert(math.huge > 10e30) - assert(-math.huge < -10e30) -end - -function f(...) - if select('#', ...) == 1 then - return (...) - else - return "***" - end -end - - --- testing numeric strings - -assert("2" + 1 == 3) -assert("2 " + 1 == 3) -assert(" -2 " + 1 == -1) -assert(" -0xa " + 1 == -9) - - --- testing 'tonumber' -assert(tonumber{} == nil) -assert(tonumber'+0.01' == 1/100 and tonumber'+.01' == 0.01 and - tonumber'.01' == 0.01 and tonumber'-1.' == -1 and - tonumber'+1.' == 1) -assert(tonumber'+ 0.01' == nil and tonumber'+.e1' == nil and - tonumber'1e' == nil and tonumber'1.0e+' == nil and - tonumber'.' == nil) -assert(tonumber('-012') == -010-2) -assert(tonumber('-1.2e2') == - - -120) - -assert(tonumber("0xffffffffffff") == 2^(4*12) - 1) -assert(tonumber("0x"..string.rep("f", 150)) == 2^(4*150) - 1) -assert(tonumber('0x3.' .. string.rep('0', 100)) == 3) -assert(tonumber('0x0.' .. string.rep('0', 150).."1") == 2^(-4*151)) - --- testing 'tonumber' with base -assert(tonumber(' 001010 ', 2) == 10) -assert(tonumber(' 001010 ', 10) == 001010) -assert(tonumber(' -1010 ', 2) == -10) -assert(tonumber('10', 36) == 36) -assert(tonumber(' -10 ', 36) == -36) -assert(tonumber(' +1Z ', 36) == 36 + 35) -assert(tonumber(' -1z ', 36) == -36 + -35) -assert(tonumber('-fFfa', 16) == -(10+(16*(15+(16*(15+(16*15))))))) -assert(tonumber(string.rep('1', 42), 2) + 1 == 2^42) -assert(tonumber(string.rep('1', 34), 2) + 1 == 2^34) -assert(tonumber('ffffFFFF', 16)+1 == 2^32) -assert(tonumber('0ffffFFFF', 16)+1 == 2^32) -assert(tonumber('-0ffffffFFFF', 16) - 1 == -2^40) -for i = 2,36 do - assert(tonumber('\t10000000000\t', i) == i^10) -end - --- testing 'tonumber' fo invalid formats -assert(f(tonumber('fFfa', 15)) == nil) -assert(f(tonumber('099', 8)) == nil) -assert(f(tonumber('1\0', 2)) == nil) -assert(f(tonumber('', 8)) == nil) -assert(f(tonumber(' ', 9)) == nil) -assert(f(tonumber(' ', 9)) == nil) -assert(f(tonumber('0xf', 10)) == nil) - -assert(f(tonumber('inf')) == nil) -assert(f(tonumber(' INF ')) == nil) -assert(f(tonumber('Nan')) == nil) -assert(f(tonumber('nan')) == nil) - -assert(f(tonumber(' ')) == nil) -assert(f(tonumber('')) == nil) -assert(f(tonumber('1 a')) == nil) -assert(f(tonumber('1\0')) == nil) -assert(f(tonumber('1 \0')) == nil) -assert(f(tonumber('1\0 ')) == nil) -assert(f(tonumber('e1')) == nil) -assert(f(tonumber('e 1')) == nil) -assert(f(tonumber(' 3.4.5 ')) == nil) - - --- testing 'tonumber' for invalid hexadecimal formats - -assert(tonumber('0x') == nil) -assert(tonumber('x') == nil) -assert(tonumber('x3') == nil) -assert(tonumber('00x2') == nil) -assert(tonumber('0x 2') == nil) -assert(tonumber('0 x2') == nil) -assert(tonumber('23x') == nil) -assert(tonumber('- 0xaa') == nil) - - --- testing hexadecimal numerals - -assert(0x10 == 16 and 0xfff == 2^12 - 1 and 0XFB == 251) -assert(0x0p12 == 0 and 0x.0p-3 == 0) -assert(0xFFFFFFFF == 2^32 - 1) -assert(tonumber('+0x2') == 2) -assert(tonumber('-0xaA') == -170) -assert(tonumber('-0xffFFFfff') == -2^32 + 1) - --- possible confusion with decimal exponent -assert(0E+1 == 0 and 0xE+1 == 15 and 0xe-1 == 13) - - --- floating hexas - -assert(tonumber(' 0x2.5 ') == 0x25/16) -assert(tonumber(' -0x2.5 ') == -0x25/16) -assert(tonumber(' +0x0.51p+8 ') == 0x51) -assert(tonumber('0x0.51p') == nil) -assert(tonumber('0x5p+-2') == nil) -assert(0x.FfffFFFF == 1 - '0x.00000001') -assert('0xA.a' + 0 == 10 + 10/16) -assert(0xa.aP4 == 0XAA) -assert(0x4P-2 == 1) -assert(0x1.1 == '0x1.' + '+0x.1') - - -assert(1.1 == 1.+.1) -assert(100.0 == 1E2 and .01 == 1e-2) -assert(1111111111111111-1111111111111110== 1000.00e-03) --- 1234567890123456 -assert(1.1 == '1.'+'.1') -assert('1111111111111111'-'1111111111111110' == tonumber" +0.001e+3 \n\t") - -function eq (a,b,limit) - if not limit then limit = 10E-10 end - return math.abs(a-b) <= limit -end - -assert(0.1e-30 > 0.9E-31 and 0.9E30 < 0.1e31) - -assert(0.123456 > 0.123455) - -assert(tonumber('+1.23E18') == 1.23*10^18) - --- testing order operators -assert(not(1<1) and (1<2) and not(2<1)) -assert(not('a'<'a') and ('a'<'b') and not('b'<'a')) -assert((1<=1) and (1<=2) and not(2<=1)) -assert(('a'<='a') and ('a'<='b') and not('b'<='a')) -assert(not(1>1) and not(1>2) and (2>1)) -assert(not('a'>'a') and not('a'>'b') and ('b'>'a')) -assert((1>=1) and not(1>=2) and (2>=1)) -assert(('a'>='a') and not('a'>='b') and ('b'>='a')) - --- testing mod operator -assert(-4%3 == 2) -assert(4%-3 == -2) -assert(math.pi - math.pi % 1 == 3) -assert(math.pi - math.pi % 0.001 == 3.141) - -local function testbit(a, n) - return a/2^n % 2 >= 1 -end - -assert(eq(math.sin(-9.8)^2 + math.cos(-9.8)^2, 1)) -assert(eq(math.tan(math.pi/4), 1)) -assert(eq(math.sin(math.pi/2), 1) and eq(math.cos(math.pi/2), 0)) -assert(eq(math.atan(1), math.pi/4) and eq(math.acos(0), math.pi/2) and - eq(math.asin(1), math.pi/2)) -assert(eq(math.deg(math.pi/2), 90) and eq(math.rad(90), math.pi/2)) -assert(math.abs(-10) == 10) -assert(eq(math.atan2(1,0), math.pi/2)) -assert(math.ceil(4.5) == 5.0) -assert(math.floor(4.5) == 4.0) -assert(math.fmod(10,3) == 1) -assert(eq(math.sqrt(10)^2, 10)) -assert(eq(math.log(2, 10), math.log(2)/math.log(10))) -assert(eq(math.log(2, 2), 1)) -assert(eq(math.log(9, 3), 2)) -assert(eq(math.exp(0), 1)) -assert(eq(math.sin(10), math.sin(10%(2*math.pi)))) -local v,e = math.frexp(math.pi) -assert(eq(math.ldexp(v,e), math.pi)) - -assert(eq(math.tanh(3.5), math.sinh(3.5)/math.cosh(3.5))) - -assert(tonumber(' 1.3e-2 ') == 1.3e-2) -assert(tonumber(' -1.00000000000001 ') == -1.00000000000001) - --- testing constant limits --- 2^23 = 8388608 -assert(8388609 + -8388609 == 0) -assert(8388608 + -8388608 == 0) -assert(8388607 + -8388607 == 0) - --- testing implicit convertions - -local a,b = '10', '20' -assert(a*b == 200 and a+b == 30 and a-b == -10 and a/b == 0.5 and -b == -20) -assert(a == '10' and b == '20') - - -if not _port then - print("testing -0 and NaN") - local mz, z = -0, 0 - assert(mz == z) - assert(1/mz < 0 and 0 < 1/z) - local a = {[mz] = 1} - assert(a[z] == 1 and a[mz] == 1) - local inf = math.huge * 2 + 1 - mz, z = -1/inf, 1/inf - assert(mz == z) - assert(1/mz < 0 and 0 < 1/z) - local NaN = inf - inf - assert(NaN ~= NaN) - assert(not (NaN < NaN)) - assert(not (NaN <= NaN)) - assert(not (NaN > NaN)) - assert(not (NaN >= NaN)) - assert(not (0 < NaN) and not (NaN < 0)) - local NaN1 = 0/0 - assert(NaN ~= NaN1 and not (NaN <= NaN1) and not (NaN1 <= NaN)) - local a = {} - assert(not pcall(function () a[NaN] = 1 end)) - assert(a[NaN] == nil) - a[1] = 1 - assert(not pcall(function () a[NaN] = 1 end)) - assert(a[NaN] == nil) - -- 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) -end - - -if not _port then - print("testing 'math.random'") - math.randomseed(0) - - local function aux (x1, x2, p) - local Max = -math.huge - local Min = math.huge - for i = 0, 20000 do - local t = math.random(table.unpack(p)) - Max = math.max(Max, t) - Min = math.min(Min, t) - if eq(Max, x2, 0.001) and eq(Min, x1, 0.001) then - goto ok - end - end - -- loop ended without satisfing condition - assert(false) - ::ok:: - assert(x1 <= Min and Max<=x2) - end - - aux(0, 1, {}) - aux(-10, 0, {-10,0}) -end - -for i=1,10 do - local t = math.random(5) - assert(1 <= t and t <= 5) -end - - -print('OK') diff --git a/utils/lua_tests/nextvar.lua b/utils/lua_tests/nextvar.lua deleted file mode 100644 index 65fa79090..000000000 --- a/utils/lua_tests/nextvar.lua +++ /dev/null @@ -1,461 +0,0 @@ -print('testing tables, next, and for') - -local a = {} - --- make sure table has lots of space in hash part -for i=1,100 do a[i.."+"] = true end -for i=1,100 do a[i.."+"] = nil end --- fill hash part with numeric indices testing size operator -for i=1,100 do - a[i] = true - assert(#a == i) -end - --- testing ipairs -local x = 0 -for k,v in ipairs{10,20,30;x=12} do - x = x + 1 - assert(k == x and v == x * 10) -end - -for _ in ipairs{x=12, y=24} do assert(nil) end - --- test for 'false' x ipair -x = false -local i = 0 -for k,v in ipairs{true,false,true,false} do - i = i + 1 - x = not x - assert(x == v) -end -assert(i == 4) - --- iterator function is always the same -assert(type(ipairs{}) == 'function' and ipairs{} == ipairs{}) - -if T then --[ --- testing table sizes - -local function log2 (x) return math.log(x, 2) end - -local function mp2 (n) -- minimum power of 2 >= n - local mp = 2^math.ceil(log2(n)) - assert(n == 0 or (mp/2 < n and n <= mp)) - return mp -end - -local function fb (n) - local r, nn = T.int2fb(n) - assert(r < 256) - return nn -end - --- test fb function -local a = 1 -local lim = 2^30 -while a < lim do - local n = fb(a) - assert(a <= n and n <= a*1.125) - a = math.ceil(a*1.3) -end - - -local function check (t, na, nh) - local a, h = T.querytab(t) - if a ~= na or h ~= nh then - print(na, nh, a, h) - assert(nil) - end -end - - --- testing C library sizes -do - local s = 0 - for _ in pairs(math) do s = s + 1 end - check(math, 0, mp2(s)) -end - - --- testing constructor sizes -local lim = 40 -local s = 'return {' -for i=1,lim do - s = s..i..',' - local s = s - for k=0,lim do - local t = load(s..'}')() - assert(#t == i) - check(t, fb(i), mp2(k)) - s = string.format('%sa%d=%d,', s, k, k) - end -end - - --- tests with unknown number of elements -local a = {} -for i=1,lim do a[i] = i end -- build auxiliary table -for k=0,lim do - local a = {table.unpack(a,1,k)} - assert(#a == k) - check(a, k, 0) - a = {1,2,3,table.unpack(a,1,k)} - check(a, k+3, 0) - assert(#a == k + 3) -end - - --- testing tables dynamically built -local lim = 130 -local a = {}; a[2] = 1; check(a, 0, 1) -a = {}; a[0] = 1; check(a, 0, 1); a[2] = 1; check(a, 0, 2) -a = {}; a[0] = 1; a[1] = 1; check(a, 1, 1) -a = {} -for i = 1,lim do - a[i] = 1 - assert(#a == i) - check(a, mp2(i), 0) -end - -a = {} -for i = 1,lim do - a['a'..i] = 1 - assert(#a == 0) - check(a, 0, mp2(i)) -end - -a = {} -for i=1,16 do a[i] = i end -check(a, 16, 0) -if not _port then - for i=1,11 do a[i] = nil end - for i=30,50 do a[i] = nil end -- force a rehash (?) - check(a, 0, 8) -- only 5 elements in the table - a[10] = 1 - for i=30,50 do a[i] = nil end -- force a rehash (?) - check(a, 0, 8) -- only 6 elements in the table - for i=1,14 do a[i] = nil end - for i=18,50 do a[i] = nil end -- force a rehash (?) - check(a, 0, 4) -- only 2 elements ([15] and [16]) -end - --- reverse filling -for i=1,lim do - local a = {} - for i=i,1,-1 do a[i] = i end -- fill in reverse - check(a, mp2(i), 0) -end - --- size tests for vararg -lim = 35 -function foo (n, ...) - local arg = {...} - check(arg, n, 0) - assert(select('#', ...) == n) - arg[n+1] = true - check(arg, mp2(n+1), 0) - arg.x = true - check(arg, mp2(n+1), 1) -end -local a = {} -for i=1,lim do a[i] = true; foo(i, table.unpack(a)) end - -end --] - - --- test size operation on empty tables -assert(#{} == 0) -assert(#{nil} == 0) -assert(#{nil, nil} == 0) -assert(#{nil, nil, nil} == 0) -assert(#{nil, nil, nil, nil} == 0) -print'+' - - -local nofind = {} - -a,b,c = 1,2,3 -a,b,c = nil - - --- next uses always the same iteraction function -assert(next{} == next{}) - -local function find (name) - local n,v - while 1 do - n,v = next(_G, n) - if not n then return nofind end - assert(v ~= nil) - if n == name then return v end - end -end - -local function find1 (name) - for n,v in pairs(_G) do - if n==name then return v end - end - return nil -- not found -end - - -assert(print==find("print") and print == find1("print")) -assert(_G["print"]==find("print")) -assert(assert==find1("assert")) -assert(nofind==find("return")) -assert(not find1("return")) -_G["ret" .. "urn"] = nil -assert(nofind==find("return")) -_G["xxx"] = 1 -assert(xxx==find("xxx")) - -print('+') - -a = {} -for i=0,10000 do - if math.fmod(i,10) ~= 0 then - a['x'..i] = i - end -end - -n = {n=0} -for i,v in pairs(a) do - n.n = n.n+1 - assert(i and v and a[i] == v) -end -assert(n.n == 9000) -a = nil - -do -- clear global table - local a = {} - for n,v in pairs(_G) do a[n]=v end - for n,v in pairs(a) do - if not package.loaded[n] and type(v) ~= "function" and - not string.find(n, "^[%u_]") then - _G[n] = nil - end - collectgarbage() - end -end - - --- - -local function checknext (a) - local b = {} - do local k,v = next(a); while k do b[k] = v; k,v = next(a,k) end end - for k,v in pairs(b) do assert(a[k] == v) end - for k,v in pairs(a) do assert(b[k] == v) end -end - -checknext{1,x=1,y=2,z=3} -checknext{1,2,x=1,y=2,z=3} -checknext{1,2,3,x=1,y=2,z=3} -checknext{1,2,3,4,x=1,y=2,z=3} -checknext{1,2,3,4,5,x=1,y=2,z=3} - -assert(#{} == 0) -assert(#{[-1] = 2} == 0) -assert(#{1,2,3,nil,nil} == 3) -for i=0,40 do - local a = {} - for j=1,i do a[j]=j end - assert(#a == i) -end - --- 'maxn' is now deprecated, but it is easily defined in Lua -function table.maxn (t) - local max = 0 - for k in pairs(t) do - max = (type(k) == 'number') and math.max(max, k) or max - end - return max -end - -assert(table.maxn{} == 0) -assert(table.maxn{["1000"] = true} == 0) -assert(table.maxn{["1000"] = true, [24.5] = 3} == 24.5) -assert(table.maxn{[1000] = true} == 1000) -assert(table.maxn{[10] = true, [100*math.pi] = print} == 100*math.pi) - -table.maxn = nil - --- int overflow -a = {} -for i=0,50 do a[math.pow(2,i)] = true end -assert(a[#a]) - -print('+') - - --- erasing values -local t = {[{1}] = 1, [{2}] = 2, [string.rep("x ", 4)] = 3, - [100.3] = 4, [4] = 5} - -local n = 0 -for k, v in pairs( t ) do - n = n+1 - assert(t[k] == v) - t[k] = nil - collectgarbage() - assert(t[k] == nil) -end -assert(n == 5) - - -local function test (a) - assert(not pcall(table.insert, a, 2, 20)); - table.insert(a, 10); table.insert(a, 2, 20); - table.insert(a, 1, -1); table.insert(a, 40); - table.insert(a, #a+1, 50) - table.insert(a, 2, -2) - assert(not pcall(table.insert, a, 0, 20)); - assert(not pcall(table.insert, a, #a + 2, 20)); - assert(table.remove(a,1) == -1) - assert(table.remove(a,1) == -2) - assert(table.remove(a,1) == 10) - assert(table.remove(a,1) == 20) - assert(table.remove(a,1) == 40) - assert(table.remove(a,1) == 50) - assert(table.remove(a,1) == nil) - assert(table.remove(a) == nil) - assert(table.remove(a, #a) == nil) -end - -a = {n=0, [-7] = "ban"} -test(a) -assert(a.n == 0 and a[-7] == "ban") - -a = {[-7] = "ban"}; -test(a) -assert(a.n == nil and #a == 0 and a[-7] == "ban") - -a = {[-1] = "ban"} -test(a) -assert(#a == 0 and table.remove(a) == nil and a[-1] == "ban") - -a = {[0] = "ban"} -assert(#a == 0 and table.remove(a) == "ban" and a[0] == nil) - -table.insert(a, 1, 10); table.insert(a, 1, 20); table.insert(a, 1, -1) -assert(table.remove(a) == 10) -assert(table.remove(a) == 20) -assert(table.remove(a) == -1) -assert(table.remove(a) == nil) - -a = {'c', 'd'} -table.insert(a, 3, 'a') -table.insert(a, 'b') -assert(table.remove(a, 1) == 'c') -assert(table.remove(a, 1) == 'd') -assert(table.remove(a, 1) == 'a') -assert(table.remove(a, 1) == 'b') -assert(table.remove(a, 1) == nil) -assert(#a == 0 and a.n == nil) - -a = {10,20,30,40} -assert(table.remove(a, #a + 1) == nil) -assert(not pcall(table.remove, a, 0)) -assert(a[#a] == 40) -assert(table.remove(a, #a) == 40) -assert(a[#a] == 30) -assert(table.remove(a, 2) == 20) -assert(a[#a] == 30 and #a == 2) -print('+') - -a = {} -for i=1,1000 do - a[i] = i; a[i-1] = nil -end -assert(next(a,nil) == 1000 and next(a,1000) == nil) - -assert(next({}) == nil) -assert(next({}, nil) == nil) - -for a,b in pairs{} do error"not here" end -for i=1,0 do error'not here' end -for i=0,1,-1 do error'not here' end -a = nil; for i=1,1 do assert(not a); a=1 end; assert(a) -a = nil; for i=1,1,-1 do assert(not a); a=1 end; assert(a) - -if not _port then - print("testing precision in numeric for") - local a = 0; for i=0, 1, 0.1 do a=a+1 end; assert(a==11) - a = 0; for i=0, 0.999999999, 0.1 do a=a+1 end; assert(a==10) - a = 0; for i=1, 1, 1 do a=a+1 end; assert(a==1) - a = 0; for i=1e10, 1e10, -1 do a=a+1 end; assert(a==1) - a = 0; for i=1, 0.99999, 1 do a=a+1 end; assert(a==0) - a = 0; for i=99999, 1e5, -1 do a=a+1 end; assert(a==0) - a = 0; for i=1, 0.99999, -1 do a=a+1 end; assert(a==1) -end - --- conversion -a = 0; for i="10","1","-2" do a=a+1 end; assert(a==5) - - -collectgarbage() - - --- testing generic 'for' - -local function f (n, p) - local t = {}; for i=1,p do t[i] = i*10 end - return function (_,n) - if n > 0 then - n = n-1 - return n, table.unpack(t) - end - end, nil, n -end - -local x = 0 -for n,a,b,c,d in f(5,3) do - x = x+1 - assert(a == 10 and b == 20 and c == 30 and d == nil) -end -assert(x == 5) - - - --- testing __pairs and __ipairs metamethod -a = {} -do - local x,y,z = pairs(a) - assert(type(x) == 'function' and y == a and z == nil) -end - -local function foo (e,i) - assert(e == a) - if i <= 10 then return i+1, i+2 end -end - -local function foo1 (e,i) - i = i + 1 - assert(e == a) - if i <= e.n then return i,a[i] end -end - -setmetatable(a, {__pairs = function (x) return foo, x, 0 end}) - -local i = 0 -for k,v in pairs(a) do - i = i + 1 - assert(k == i and v == k+1) -end - -a.n = 5 -a[3] = 30 - -a = {n=10} -setmetatable(a, {__len = function (x) return x.n end, - __ipairs = function (x) return function (e,i) - if i < #e then return i+1 end - end, x, 0 end}) -i = 0 -for k,v in ipairs(a) do - i = i + 1 - assert(k == i and v == nil) -end -assert(i == a.n) - -print"OK" diff --git a/utils/lua_tests/pm.lua b/utils/lua_tests/pm.lua deleted file mode 100644 index 8e402948f..000000000 --- a/utils/lua_tests/pm.lua +++ /dev/null @@ -1,344 +0,0 @@ -print('testing pattern matching') - -function f(s, p) - local i,e = string.find(s, p) - if i then return string.sub(s, i, e) end -end - -function f1(s, p) - p = string.gsub(p, "%%([0-9])", function (s) return "%" .. (s+1) end) - p = string.gsub(p, "^(^?)", "%1()", 1) - p = string.gsub(p, "($?)$", "()%1", 1) - local t = {string.match(s, p)} - return string.sub(s, t[1], t[#t] - 1) -end - -a,b = string.find('', '') -- empty patterns are tricky -assert(a == 1 and b == 0); -a,b = string.find('alo', '') -assert(a == 1 and b == 0) -a,b = string.find('a\0o a\0o a\0o', 'a', 1) -- first position -assert(a == 1 and b == 1) -a,b = string.find('a\0o a\0o a\0o', 'a\0o', 2) -- starts in the midle -assert(a == 5 and b == 7) -a,b = string.find('a\0o a\0o a\0o', 'a\0o', 9) -- starts in the midle -assert(a == 9 and b == 11) -a,b = string.find('a\0a\0a\0a\0\0ab', '\0ab', 2); -- finds at the end -assert(a == 9 and b == 11); -a,b = string.find('a\0a\0a\0a\0\0ab', 'b') -- last position -assert(a == 11 and b == 11) -assert(string.find('a\0a\0a\0a\0\0ab', 'b\0') == nil) -- check ending -assert(string.find('', '\0') == nil) -assert(string.find('alo123alo', '12') == 4) -assert(string.find('alo123alo', '^12') == nil) - -assert(string.match("aaab", ".*b") == "aaab") -assert(string.match("aaa", ".*a") == "aaa") -assert(string.match("b", ".*b") == "b") - -assert(string.match("aaab", ".+b") == "aaab") -assert(string.match("aaa", ".+a") == "aaa") -assert(not string.match("b", ".+b")) - -assert(string.match("aaab", ".?b") == "ab") -assert(string.match("aaa", ".?a") == "aa") -assert(string.match("b", ".?b") == "b") - -assert(f('aloALO', '%l*') == 'alo') -assert(f('aLo_ALO', '%a*') == 'aLo') - -assert(f(" \n\r*&\n\r xuxu \n\n", "%g%g%g+") == "xuxu") - -assert(f('aaab', 'a*') == 'aaa'); -assert(f('aaa', '^.*$') == 'aaa'); -assert(f('aaa', 'b*') == ''); -assert(f('aaa', 'ab*a') == 'aa') -assert(f('aba', 'ab*a') == 'aba') -assert(f('aaab', 'a+') == 'aaa') -assert(f('aaa', '^.+$') == 'aaa') -assert(f('aaa', 'b+') == nil) -assert(f('aaa', 'ab+a') == nil) -assert(f('aba', 'ab+a') == 'aba') -assert(f('a$a', '.$') == 'a') -assert(f('a$a', '.%$') == 'a$') -assert(f('a$a', '.$.') == 'a$a') -assert(f('a$a', '$$') == nil) -assert(f('a$b', 'a$') == nil) -assert(f('a$a', '$') == '') -assert(f('', 'b*') == '') -assert(f('aaa', 'bb*') == nil) -assert(f('aaab', 'a-') == '') -assert(f('aaa', '^.-$') == 'aaa') -assert(f('aabaaabaaabaaaba', 'b.*b') == 'baaabaaabaaab') -assert(f('aabaaabaaabaaaba', 'b.-b') == 'baaab') -assert(f('alo xo', '.o$') == 'xo') -assert(f(' \n isto é assim', '%S%S*') == 'isto') -assert(f(' \n isto é assim', '%S*$') == 'assim') -assert(f(' \n isto é assim', '[a-z]*$') == 'assim') -assert(f('um caracter ? extra', '[^%sa-z]') == '?') -assert(f('', 'a?') == '') -assert(f('á', 'á?') == 'á') -assert(f('ábl', 'á?b?l?') == 'ábl') -assert(f(' ábl', 'á?b?l?') == '') -assert(f('aa', '^aa?a?a') == 'aa') -assert(f(']]]áb', '[^]]') == 'á') -assert(f("0alo alo", "%x*") == "0a") -assert(f("alo alo", "%C+") == "alo alo") -print('+') - -assert(f1('alo alx 123 b\0o b\0o', '(..*) %1') == "b\0o b\0o") -assert(f1('axz123= 4= 4 34', '(.+)=(.*)=%2 %1') == '3= 4= 4 3') -assert(f1('=======', '^(=*)=%1$') == '=======') -assert(string.match('==========', '^([=]*)=%1$') == nil) - -local function range (i, j) - if i <= j then - return i, range(i+1, j) - end -end - -local abc = string.char(range(0, 255)); - -assert(string.len(abc) == 256) - -function strset (p) - local res = {s=''} - string.gsub(abc, p, function (c) res.s = res.s .. c end) - return res.s -end; - -assert(string.len(strset('[\200-\210]')) == 11) - -assert(strset('[a-z]') == "abcdefghijklmnopqrstuvwxyz") -assert(strset('[a-z%d]') == strset('[%da-uu-z]')) -assert(strset('[a-]') == "-a") -assert(strset('[^%W]') == strset('[%w]')) -assert(strset('[]%%]') == '%]') -assert(strset('[a%-z]') == '-az') -assert(strset('[%^%[%-a%]%-b]') == '-[]^ab') -assert(strset('%Z') == strset('[\1-\255]')) -assert(strset('.') == strset('[\1-\255%z]')) -print('+'); - -assert(string.match("alo xyzK", "(%w+)K") == "xyz") -assert(string.match("254 K", "(%d*)K") == "") -assert(string.match("alo ", "(%w*)$") == "") -assert(string.match("alo ", "(%w+)$") == nil) -assert(string.find("(álo)", "%(á") == 1) -local a, b, c, d, e = string.match("âlo alo", "^(((.).).* (%w*))$") -assert(a == 'âlo alo' and b == 'âl' and c == 'â' and d == 'alo' and e == nil) -a, b, c, d = string.match('0123456789', '(.+(.?)())') -assert(a == '0123456789' and b == '' and c == 11 and d == nil) -print('+') - -assert(string.gsub('ülo ülo', 'ü', 'x') == 'xlo xlo') -assert(string.gsub('alo úlo ', ' +$', '') == 'alo úlo') -- trim -assert(string.gsub(' alo alo ', '^%s*(.-)%s*$', '%1') == 'alo alo') -- double trim -assert(string.gsub('alo alo \n 123\n ', '%s+', ' ') == 'alo alo 123 ') -t = "abç d" -a, b = string.gsub(t, '(.)', '%1@') -assert('@'..a == string.gsub(t, '', '@') and b == 5) -a, b = string.gsub('abçd', '(.)', '%0@', 2) -assert(a == 'a@b@çd' and b == 2) -assert(string.gsub('alo alo', '()[al]', '%1') == '12o 56o') -assert(string.gsub("abc=xyz", "(%w*)(%p)(%w+)", "%3%2%1-%0") == - "xyz=abc-abc=xyz") -assert(string.gsub("abc", "%w", "%1%0") == "aabbcc") -assert(string.gsub("abc", "%w+", "%0%1") == "abcabc") -assert(string.gsub('áéí', '$', '\0óú') == 'áéí\0óú') -assert(string.gsub('', '^', 'r') == 'r') -assert(string.gsub('', '$', 'r') == 'r') -print('+') - -assert(string.gsub("um (dois) tres (quatro)", "(%(%w+%))", string.upper) == - "um (DOIS) tres (QUATRO)") - -do - local function setglobal (n,v) rawset(_G, n, v) end - string.gsub("a=roberto,roberto=a", "(%w+)=(%w%w*)", setglobal) - assert(_G.a=="roberto" and _G.roberto=="a") -end - -function f(a,b) return string.gsub(a,'.',b) end -assert(string.gsub("trocar tudo em |teste|b| é |beleza|al|", "|([^|]*)|([^|]*)|", f) == - "trocar tudo em bbbbb é alalalalalal") - -local function dostring (s) return load(s)() or "" end -assert(string.gsub("alo $a=1$ novamente $return a$", "$([^$]*)%$", dostring) == - "alo novamente 1") - -x = string.gsub("$x=string.gsub('alo', '.', string.upper)$ assim vai para $return x$", - "$([^$]*)%$", dostring) -assert(x == ' assim vai para ALO') - -t = {} -s = 'a alo jose joao' -r = string.gsub(s, '()(%w+)()', function (a,w,b) - assert(string.len(w) == b-a); - t[a] = b-a; - end) -assert(s == r and t[1] == 1 and t[3] == 3 and t[7] == 4 and t[13] == 4) - - -function isbalanced (s) - return string.find(string.gsub(s, "%b()", ""), "[()]") == nil -end - -assert(isbalanced("(9 ((8))(\0) 7) \0\0 a b ()(c)() a")) -assert(not isbalanced("(9 ((8) 7) a b (\0 c) a")) -assert(string.gsub("alo 'oi' alo", "%b''", '"') == 'alo " alo') - - -local t = {"apple", "orange", "lime"; n=0} -assert(string.gsub("x and x and x", "x", function () t.n=t.n+1; return t[t.n] end) - == "apple and orange and lime") - -t = {n=0} -string.gsub("first second word", "%w%w*", function (w) t.n=t.n+1; t[t.n] = w end) -assert(t[1] == "first" and t[2] == "second" and t[3] == "word" and t.n == 3) - -t = {n=0} -assert(string.gsub("first second word", "%w+", - function (w) t.n=t.n+1; t[t.n] = w end, 2) == "first second word") -assert(t[1] == "first" and t[2] == "second" and t[3] == nil) - -assert(not pcall(string.gsub, "alo", "(.", print)) -assert(not pcall(string.gsub, "alo", ".)", print)) -assert(not pcall(string.gsub, "alo", "(.", {})) -assert(not pcall(string.gsub, "alo", "(.)", "%2")) -assert(not pcall(string.gsub, "alo", "(%1)", "a")) -assert(not pcall(string.gsub, "alo", "(%0)", "a")) - --- bug since 2.5 (C-stack overflow) -do - local function f (size) - local s = string.rep("a", size) - local p = string.rep(".?", size) - return pcall(string.match, s, p) - end - local r, m = f(80) - assert(r and #m == 80) - r, m = f(200000) - assert(not r and string.find(m, "too complex")) -end - -if not _soft then - -- big strings - local a = string.rep('a', 300000) - assert(string.find(a, '^a*.?$')) - assert(not string.find(a, '^a*.?b$')) - assert(string.find(a, '^a-.?$')) - - -- bug in 5.1.2 - a = string.rep('a', 10000) .. string.rep('b', 10000) - assert(not pcall(string.gsub, a, 'b')) -end - --- recursive nest of gsubs -function rev (s) - return string.gsub(s, "(.)(.+)", function (c,s1) return rev(s1)..c end) -end - -local x = "abcdef" -assert(rev(rev(x)) == x) - - --- gsub with tables -assert(string.gsub("alo alo", ".", {}) == "alo alo") -assert(string.gsub("alo alo", "(.)", {a="AA", l=""}) == "AAo AAo") -assert(string.gsub("alo alo", "(.).", {a="AA", l="K"}) == "AAo AAo") -assert(string.gsub("alo alo", "((.)(.?))", {al="AA", o=false}) == "AAo AAo") - -assert(string.gsub("alo alo", "().", {2,5,6}) == "256 alo") - -t = {}; setmetatable(t, {__index = function (t,s) return string.upper(s) end}) -assert(string.gsub("a alo b hi", "%w%w+", t) == "a ALO b HI") - - --- tests for gmatch -local a = 0 -for i in string.gmatch('abcde', '()') do assert(i == a+1); a=i end -assert(a==6) - -t = {n=0} -for w in string.gmatch("first second word", "%w+") do - t.n=t.n+1; t[t.n] = w -end -assert(t[1] == "first" and t[2] == "second" and t[3] == "word") - -t = {3, 6, 9} -for i in string.gmatch ("xuxx uu ppar r", "()(.)%2") do - assert(i == table.remove(t, 1)) -end -assert(#t == 0) - -t = {} -for i,j in string.gmatch("13 14 10 = 11, 15= 16, 22=23", "(%d+)%s*=%s*(%d+)") do - t[i] = j -end -a = 0 -for k,v in pairs(t) do assert(k+1 == v+0); a=a+1 end -assert(a == 3) - - --- tests for `%f' (`frontiers') - -assert(string.gsub("aaa aa a aaa a", "%f[%w]a", "x") == "xaa xa x xaa x") -assert(string.gsub("[[]] [][] [[[[", "%f[[].", "x") == "x[]] x]x] x[[[") -assert(string.gsub("01abc45de3", "%f[%d]", ".") == ".01abc.45de.3") -assert(string.gsub("01abc45 de3x", "%f[%D]%w", ".") == "01.bc45 de3.") -assert(string.gsub("function", "%f[\1-\255]%w", ".") == ".unction") -assert(string.gsub("function", "%f[^\1-\255]", ".") == "function.") - -assert(string.find("a", "%f[a]") == 1) -assert(string.find("a", "%f[^%z]") == 1) -assert(string.find("a", "%f[^%l]") == 2) -assert(string.find("aba", "%f[a%z]") == 3) -assert(string.find("aba", "%f[%z]") == 4) -assert(not string.find("aba", "%f[%l%z]")) -assert(not string.find("aba", "%f[^%l%z]")) - -local i, e = string.find(" alo aalo allo", "%f[%S].-%f[%s].-%f[%S]") -assert(i == 2 and e == 5) -local k = string.match(" alo aalo allo", "%f[%S](.-%f[%s].-%f[%S])") -assert(k == 'alo ') - -local a = {1, 5, 9, 14, 17,} -for k in string.gmatch("alo alo th02 is 1hat", "()%f[%w%d]") do - assert(table.remove(a, 1) == k) -end -assert(#a == 0) - - --- malformed patterns -local function malform (p, m) - m = m or "malformed" - local r, msg = pcall(string.find, "a", p) - assert(not r and string.find(msg, m)) -end - -malform("[a") -malform("[]") -malform("[^]") -malform("[a%]") -malform("[a%") -malform("%b") -malform("%ba") -malform("%") -malform("%f", "missing") - --- \0 in patterns -assert(string.match("ab\0\1\2c", "[\0-\2]+") == "\0\1\2") -assert(string.match("ab\0\1\2c", "[\0-\0]+") == "\0") -assert(string.find("b$a", "$\0?") == 2) -assert(string.find("abc\0efg", "%\0") == 4) -assert(string.match("abc\0efg\0\1e\1g", "%b\0\1") == "\0efg\0\1e\1") -assert(string.match("abc\0\0\0", "%\0+") == "\0\0\0") -assert(string.match("abc\0\0\0", "%\0%\0?") == "\0\0") - --- magic char after \0 -assert(string.find("abc\0\0","\0.") == 4) -assert(string.find("abcx\0\0abc\0abc","x\0\0abc\0a.") == 4) - -print('OK') - diff --git a/utils/lua_tests/sort.lua b/utils/lua_tests/sort.lua deleted file mode 100644 index 41b865c57..000000000 --- a/utils/lua_tests/sort.lua +++ /dev/null @@ -1,167 +0,0 @@ -print "testing (parts of) table library" - -print "testing unpack" - -local unpack = table.unpack - -local x,y,z,a,n -a = {}; lim = 2000 -for i=1, lim do a[i]=i end -assert(select(lim, unpack(a)) == lim and select('#', unpack(a)) == lim) -x = unpack(a) -assert(x == 1) -x = {unpack(a)} -assert(#x == lim and x[1] == 1 and x[lim] == lim) -x = {unpack(a, lim-2)} -assert(#x == 3 and x[1] == lim-2 and x[3] == lim) -x = {unpack(a, 10, 6)} -assert(next(x) == nil) -- no elements -x = {unpack(a, 11, 10)} -assert(next(x) == nil) -- no elements -x,y = unpack(a, 10, 10) -assert(x == 10 and y == nil) -x,y,z = unpack(a, 10, 11) -assert(x == 10 and y == 11 and z == nil) -a,x = unpack{1} -assert(a==1 and x==nil) -a,x = unpack({1,2}, 1, 1) -assert(a==1 and x==nil) - -if not _no32 then - assert(not pcall(unpack, {}, 0, 2^31-1)) - assert(not pcall(unpack, {}, 1, 2^31-1)) - assert(not pcall(unpack, {}, -(2^31), 2^31-1)) - assert(not pcall(unpack, {}, -(2^31 - 1), 2^31-1)) - assert(pcall(unpack, {}, 2^31-1, 0)) - assert(pcall(unpack, {}, 2^31-1, 1)) - pcall(unpack, {}, 1, 2^31) - a, b = unpack({[2^31-1] = 20}, 2^31-1, 2^31-1) - assert(a == 20 and b == nil) - a, b = unpack({[2^31-1] = 20}, 2^31-2, 2^31-1) - assert(a == nil and b == 20) -end - -print "testing pack" - -a = table.pack() -assert(a[1] == nil and a.n == 0) - -a = table.pack(table) -assert(a[1] == table and a.n == 1) - -a = table.pack(nil, nil, nil, nil) -assert(a[1] == nil and a.n == 4) - - -print"testing sort" - - --- test checks for invalid order functions -local function check (t) - local function f(a, b) assert(a and b); return true end - local s, e = pcall(table.sort, t, f) - assert(not s and e:find("invalid order function")) -end - -check{1,2,3,4} -check{1,2,3,4,5} -check{1,2,3,4,5,6} - - -function check (a, f) - f = f or function (x,y) return x 'alo\0alo\0') -assert('alo' < 'alo\0') -assert('alo\0' > 'alo') -assert('\0' < '\1') -assert('\0\0' < '\0\1') -assert('\1\0a\0a' <= '\1\0a\0a') -assert(not ('\1\0a\0b' <= '\1\0a\0a')) -assert('\0\0\0' < '\0\0\0\0') -assert(not('\0\0\0\0' < '\0\0\0')) -assert('\0\0\0' <= '\0\0\0\0') -assert(not('\0\0\0\0' <= '\0\0\0')) -assert('\0\0\0' <= '\0\0\0') -assert('\0\0\0' >= '\0\0\0') -assert(not ('\0\0b' < '\0\0a\0')) -print('+') - -assert(string.sub("123456789",2,4) == "234") -assert(string.sub("123456789",7) == "789") -assert(string.sub("123456789",7,6) == "") -assert(string.sub("123456789",7,7) == "7") -assert(string.sub("123456789",0,0) == "") -assert(string.sub("123456789",-10,10) == "123456789") -assert(string.sub("123456789",1,9) == "123456789") -assert(string.sub("123456789",-10,-20) == "") -assert(string.sub("123456789",-1) == "9") -assert(string.sub("123456789",-4) == "6789") -assert(string.sub("123456789",-6, -4) == "456") -if not _no32 then - assert(string.sub("123456789",-2^31, -4) == "123456") - assert(string.sub("123456789",-2^31, 2^31 - 1) == "123456789") - assert(string.sub("123456789",-2^31, -2^31) == "") -end -assert(string.sub("\000123456789",3,5) == "234") -assert(("\000123456789"):sub(8) == "789") -print('+') - -assert(string.find("123456789", "345") == 3) -a,b = string.find("123456789", "345") -assert(string.sub("123456789", a, b) == "345") -assert(string.find("1234567890123456789", "345", 3) == 3) -assert(string.find("1234567890123456789", "345", 4) == 13) -assert(string.find("1234567890123456789", "346", 4) == nil) -assert(string.find("1234567890123456789", ".45", -9) == 13) -assert(string.find("abcdefg", "\0", 5, 1) == nil) -assert(string.find("", "") == 1) -assert(string.find("", "", 1) == 1) -assert(not string.find("", "", 2)) -assert(string.find('', 'aaa', 1) == nil) -assert(('alo(.)alo'):find('(.)', 1, 1) == 4) -print('+') - -assert(string.len("") == 0) -assert(string.len("\0\0\0") == 3) -assert(string.len("1234567890") == 10) - -assert(#"" == 0) -assert(#"\0\0\0" == 3) -assert(#"1234567890" == 10) - -assert(string.byte("a") == 97) -assert(string.byte("\xe4") > 127) -assert(string.byte(string.char(255)) == 255) -assert(string.byte(string.char(0)) == 0) -assert(string.byte("\0") == 0) -assert(string.byte("\0\0alo\0x", -1) == string.byte('x')) -assert(string.byte("ba", 2) == 97) -assert(string.byte("\n\n", 2, -1) == 10) -assert(string.byte("\n\n", 2, 2) == 10) -assert(string.byte("") == nil) -assert(string.byte("hi", -3) == nil) -assert(string.byte("hi", 3) == nil) -assert(string.byte("hi", 9, 10) == nil) -assert(string.byte("hi", 2, 1) == nil) -assert(string.char() == "") -assert(string.char(0, 255, 0) == "\0\255\0") -assert(string.char(0, string.byte("\xe4"), 0) == "\0\xe4\0") -assert(string.char(string.byte("\xe4l\0óu", 1, -1)) == "\xe4l\0óu") -assert(string.char(string.byte("\xe4l\0óu", 1, 0)) == "") -assert(string.char(string.byte("\xe4l\0óu", -10, 100)) == "\xe4l\0óu") -print('+') - -assert(string.upper("ab\0c") == "AB\0C") -assert(string.lower("\0ABCc%$") == "\0abcc%$") -assert(string.rep('teste', 0) == '') -assert(string.rep('tés\00tê', 2) == 'tés\0têtés\000tê') -assert(string.rep('', 10) == '') - --- repetitions with separator -assert(string.rep('teste', 0, 'xuxu') == '') -assert(string.rep('teste', 1, 'xuxu') == 'teste') -assert(string.rep('\1\0\1', 2, '\0\0') == '\1\0\1\0\0\1\0\1') -assert(string.rep('', 10, '.') == string.rep('.', 9)) -if not _no32 then - assert(not pcall(string.rep, "aa", 2^30)) - assert(not pcall(string.rep, "", 2^30, "aa")) -end - -assert(string.reverse"" == "") -assert(string.reverse"\0\1\2\3" == "\3\2\1\0") -assert(string.reverse"\0001234" == "4321\0") - -for i=0,30 do assert(string.len(string.rep('a', i)) == i) end - -assert(type(tostring(nil)) == 'string') -assert(type(tostring(12)) == 'string') -assert(''..12 == '12' and type(12 .. '') == 'string') -assert(string.find(tostring{}, 'table:')) -assert(string.find(tostring(print), 'function:')) -assert(tostring(1234567890123) == '1234567890123') -assert(#tostring('\0') == 1) -assert(tostring(true) == "true") -assert(tostring(false) == "false") -print('+') - -x = '"ílo"\n\\' -assert(string.format('%q%s', x, x) == '"\\"ílo\\"\\\n\\\\""ílo"\n\\') -assert(string.format('%q', "\0") == [["\0"]]) -assert(load(string.format('return %q', x))() == x) -x = "\0\1\0023\5\0009" -assert(load(string.format('return %q', x))() == x) -assert(string.format("\0%c\0%c%x\0", string.byte("\xe4"), string.byte("b"), 140) == - "\0\xe4\0b8c\0") -assert(string.format('') == "") -assert(string.format("%c",34)..string.format("%c",48)..string.format("%c",90)..string.format("%c",100) == - string.format("%c%c%c%c", 34, 48, 90, 100)) -assert(string.format("%s\0 is not \0%s", 'not be', 'be') == 'not be\0 is not \0be') -assert(string.format("%%%d %010d", 10, 23) == "%10 0000000023") -assert(tonumber(string.format("%f", 10.3)) == 10.3) -x = string.format('"%-50s"', 'a') -assert(#x == 52) -assert(string.sub(x, 1, 4) == '"a ') - -assert(string.format("-%.20s.20s", string.rep("%", 2000)) == - "-"..string.rep("%", 20)..".20s") -assert(string.format('"-%20s.20s"', string.rep("%", 2000)) == - string.format("%q", "-"..string.rep("%", 2000)..".20s")) - --- format x tostring -assert(string.format("%s %s", nil, true) == "nil true") -assert(string.format("%s %.4s", false, true) == "false true") -assert(string.format("%.3s %.3s", false, true) == "fal tru") -local m = setmetatable({}, {__tostring = function () return "hello" end}) -assert(string.format("%s %.10s", m, m) == "hello hello") - - -assert(string.format("%x", 0.3) == "0") -assert(string.format("%02x", 0.1) == "00") -assert(string.format("%08X", 2^32 - 1) == "FFFFFFFF") -assert(string.format("%+08d", 2^31 - 1) == "+2147483647") -assert(string.format("%+08d", -2^31) == "-2147483648") - - --- longest number that can be formated -assert(string.len(string.format('%99.99f', -1e308)) >= 100) - - - -if not _nolonglong then - print("testing large numbers for format") - assert(string.format("%8x", 2^52 - 1) == "fffffffffffff") - assert(string.format("%d", -1) == "-1") - assert(tonumber(string.format("%u", 2^62)) == 2^62) - assert(string.format("%8x", 0xffffffff) == "ffffffff") - assert(string.format("%8x", 0x7fffffff) == "7fffffff") - assert(string.format("%d", 2^53) == "9007199254740992") - assert(string.format("%d", -2^53) == "-9007199254740992") - assert(string.format("0x%8X", 0x8f000003) == "0x8F000003") - -- maximum integer that fits both in 64-int and (exact) double - local x = 2^64 - 2^(64-53) - assert(x == 0xfffffffffffff800) - assert(tonumber(string.format("%u", x)) == x) - assert(tonumber(string.format("0X%x", x)) == x) - assert(string.format("%x", x) == "fffffffffffff800") - assert(string.format("%d", x/2) == "9223372036854774784") - assert(string.format("%d", -x/2) == "-9223372036854774784") - assert(string.format("%d", -2^63) == "-9223372036854775808") - assert(string.format("%x", 2^63) == "8000000000000000") -end - -if not _noformatA then - print("testing 'format %a %A'") - assert(string.format("%.2a", 0.5) == "0x1.00p-1") - assert(string.format("%A", 0x1fffffffffffff) == "0X1.FFFFFFFFFFFFFP+52") - assert(string.format("%.4a", -3) == "-0x1.8000p+1") - assert(tonumber(string.format("%a", -0.1)) == -0.1) -end - --- errors in format - -local function check (fmt, msg) - local s, err = pcall(string.format, fmt, 10) - assert(not s and string.find(err, msg)) -end - -local aux = string.rep('0', 600) -check("%100.3d", "too long") -check("%1"..aux..".3d", "too long") -check("%1.100d", "too long") -check("%10.1"..aux.."004d", "too long") -check("%t", "invalid option") -check("%"..aux.."d", "repeated flags") -check("%d %d", "no value") - - --- integers out of range -assert(not pcall(string.format, "%d", 2^63)) -assert(not pcall(string.format, "%x", 2^64)) -assert(not pcall(string.format, "%x", -2^64)) -assert(not pcall(string.format, "%x", -1)) - - -assert(load("return 1\n--comentário sem EOL no final")() == 1) - - -assert(table.concat{} == "") -assert(table.concat({}, 'x') == "") -assert(table.concat({'\0', '\0\1', '\0\1\2'}, '.\0.') == "\0.\0.\0\1.\0.\0\1\2") -local a = {}; for i=1,3000 do a[i] = "xuxu" end -assert(table.concat(a, "123").."123" == string.rep("xuxu123", 3000)) -assert(table.concat(a, "b", 20, 20) == "xuxu") -assert(table.concat(a, "", 20, 21) == "xuxuxuxu") -assert(table.concat(a, "x", 22, 21) == "") -assert(table.concat(a, "3", 2999) == "xuxu3xuxu") -if not _no32 then - assert(table.concat({}, "x", 2^31-1, 2^31-2) == "") - assert(table.concat({}, "x", -2^31+1, -2^31) == "") - assert(table.concat({}, "x", 2^31-1, -2^31) == "") - assert(table.concat({[2^31-1] = "alo"}, "x", 2^31-1, 2^31-1) == "alo") -end - -assert(not pcall(table.concat, {"a", "b", {}})) - -a = {"a","b","c"} -assert(table.concat(a, ",", 1, 0) == "") -assert(table.concat(a, ",", 1, 1) == "a") -assert(table.concat(a, ",", 1, 2) == "a,b") -assert(table.concat(a, ",", 2) == "b,c") -assert(table.concat(a, ",", 3) == "c") -assert(table.concat(a, ",", 4) == "") - -if not _port then - -local locales = { "ptb", "ISO-8859-1", "pt_BR" } -local function trylocale (w) - for i = 1, #locales do - if os.setlocale(locales[i], w) then return true end - end - return false -end - -if not trylocale("collate") then - print("locale not supported") -else - assert("alo" < "álo" and "álo" < "amo") -end - -if not trylocale("ctype") then - print("locale not supported") -else - assert(load("a = 3.4")); -- parser should not change outside locale - assert(not load("á = 3.4")); -- even with errors - assert(string.gsub("áéíóú", "%a", "x") == "xxxxx") - assert(string.gsub("áÁéÉ", "%l", "x") == "xÁxÉ") - assert(string.gsub("áÁéÉ", "%u", "x") == "áxéx") - assert(string.upper"áÁé{xuxu}ção" == "ÁÁÉ{XUXU}ÇÃO") -end - -os.setlocale("C") -assert(os.setlocale() == 'C') -assert(os.setlocale(nil, "numeric") == 'C') - -end - -print('OK') - - diff --git a/utils/lua_tests/vararg.lua b/utils/lua_tests/vararg.lua deleted file mode 100644 index a98652079..000000000 --- a/utils/lua_tests/vararg.lua +++ /dev/null @@ -1,125 +0,0 @@ -print('testing vararg') - -_G.arg = nil - -function f(a, ...) - local arg = {n = select('#', ...), ...} - for i=1,arg.n do assert(a[i]==arg[i]) end - return arg.n -end - -function c12 (...) - assert(arg == nil) - local x = {...}; x.n = #x - local res = (x.n==2 and x[1] == 1 and x[2] == 2) - if res then res = 55 end - return res, 2 -end - -function vararg (...) return {n = select('#', ...), ...} end - -local call = function (f, args) return f(table.unpack(args, 1, args.n)) end - -assert(f() == 0) -assert(f({1,2,3}, 1, 2, 3) == 3) -assert(f({"alo", nil, 45, f, nil}, "alo", nil, 45, f, nil) == 5) - -assert(c12(1,2)==55) -a,b = assert(call(c12, {1,2})) -assert(a == 55 and b == 2) -a = call(c12, {1,2;n=2}) -assert(a == 55 and b == 2) -a = call(c12, {1,2;n=1}) -assert(not a) -assert(c12(1,2,3) == false) -local a = vararg(call(next, {_G,nil;n=2})) -local b,c = next(_G) -assert(a[1] == b and a[2] == c and a.n == 2) -a = vararg(call(call, {c12, {1,2}})) -assert(a.n == 2 and a[1] == 55 and a[2] == 2) -a = call(print, {'+'}) -assert(a == nil) - -local t = {1, 10} -function t:f (...) local arg = {...}; return self[...]+#arg end -assert(t:f(1,4) == 3 and t:f(2) == 11) -print('+') - -lim = 20 -local i, a = 1, {} -while i <= lim do a[i] = i+0.3; i=i+1 end - -function f(a, b, c, d, ...) - local more = {...} - assert(a == 1.3 and more[1] == 5.3 and - more[lim-4] == lim+0.3 and not more[lim-3]) -end - -function g(a,b,c) - assert(a == 1.3 and b == 2.3 and c == 3.3) -end - -call(f, a) -call(g, a) - -a = {} -i = 1 -while i <= lim do a[i] = i; i=i+1 end -assert(call(math.max, a) == lim) - -print("+") - - --- new-style varargs - -function oneless (a, ...) return ... end - -function f (n, a, ...) - local b - assert(arg == nil) - if n == 0 then - local b, c, d = ... - return a, b, c, d, oneless(oneless(oneless(...))) - else - n, b, a = n-1, ..., a - assert(b == ...) - return f(n, a, ...) - end -end - -a,b,c,d,e = assert(f(10,5,4,3,2,1)) -assert(a==5 and b==4 and c==3 and d==2 and e==1) - -a,b,c,d,e = f(4) -assert(a==nil and b==nil and c==nil and d==nil and e==nil) - - --- varargs for main chunks -f = load[[ return {...} ]] -x = f(2,3) -assert(x[1] == 2 and x[2] == 3 and x[3] == nil) - - -f = load[[ - local x = {...} - for i=1,select('#', ...) do assert(x[i] == select(i, ...)) end - assert(x[select('#', ...)+1] == nil) - return true -]] - -assert(f("a", "b", nil, {}, assert)) -assert(f()) - -a = {select(3, table.unpack{10,20,30,40})} -assert(#a == 2 and a[1] == 30 and a[2] == 40) -a = {select(1)} -assert(next(a) == nil) -a = {select(-1, 3, 5, 7)} -assert(a[1] == 7 and a[2] == nil) -a = {select(-2, 3, 5, 7)} -assert(a[1] == 5 and a[2] == 7 and a[3] == nil) -pcall(select, 10000) -pcall(select, -10000) - -print('OK') - diff --git a/utils/lua_tests/verybig.lua b/utils/lua_tests/verybig.lua deleted file mode 100644 index 69007482c..000000000 --- a/utils/lua_tests/verybig.lua +++ /dev/null @@ -1,144 +0,0 @@ -print "testing RK" - --- testing opcodes with RK arguments larger than K limit -local function foo () - local dummy = { - -- fill first 256 entries in table of constants - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, - } - assert(24.5 + 0.6 == 25.1) - local t = {foo = function (self, x) return x + self.x end, x = 10} - t.t = t - assert(t:foo(1.5) == 11.5) - assert(t.t:foo(0.5) == 10.5) -- bug in 5.2 alpha - assert(24.3 == 24.3) - assert((function () return t.x end)() == 10) -end - - -foo() -foo = nil - -if _soft then return 10 end - -print "testing large programs (>64k)" - --- template to create a very big test file -prog = [[$ - -local a,b - -b = {$1$ - b30009 = 65534, - b30010 = 65535, - b30011 = 65536, - b30012 = 65537, - b30013 = 16777214, - b30014 = 16777215, - b30015 = 16777216, - b30016 = 16777217, - b30017 = 4294967294, - b30018 = 4294967295, - b30019 = 4294967296, - b30020 = 4294967297, - b30021 = -65534, - b30022 = -65535, - b30023 = -65536, - b30024 = -4294967297, - b30025 = 15012.5, - $2$ -}; - -assert(b.a50008 == 25004 and b["a11"] == 5.5) -assert(b.a33007 == 16503.5 and b.a50009 == 25004.5) -assert(b["b"..30024] == -4294967297) - -function b:xxx (a,b) return a+b end -assert(b:xxx(10, 12) == 22) -- pushself with non-constant index -b.xxx = nil - -s = 0; n=0 -for a,b in pairs(b) do s=s+b; n=n+1 end -assert(s==13977183656.5 and n==70001) - - -a = nil; b = nil -print'+' - -function f(x) b=x end - -a = f{$3$} or 10 - -assert(a==10) -assert(b[1] == "a10" and b[2] == 5 and b[#b-1] == "a50009") - - -function xxxx (x) return b[x] end - -assert(xxxx(3) == "a11") - -a = nil; b=nil -xxxx = nil - -return 10 - -]] - --- functions to fill in the $n$ -F = { -function () -- $1$ - for i=10,50009 do - io.write('a', i, ' = ', 5+((i-10)/2), ',\n') - end -end, - -function () -- $2$ - for i=30026,50009 do - io.write('b', i, ' = ', 15013+((i-30026)/2), ',\n') - end -end, - -function () -- $3$ - for i=10,50009 do - io.write('"a', i, '", ', 5+((i-10)/2), ',\n') - end -end, -} - -file = os.tmpname() -io.output(file) -for s in string.gmatch(prog, "$([^$]+)") do - local n = tonumber(s) - if not n then io.write(s) else F[n]() end -end -io.close() -result = dofile(file) -assert(os.remove(file)) -print'OK' -return result -