| -- $Id: api.lua,v 1.147 2016/11/07 13:06:25 roberto Exp $ | |
| -- See Copyright Notice in file all.lua | |
| if T==nil then | |
| (Message or print)('\n >>> testC not active: skipping API tests <<<\n') | |
| 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 | |
| local function checkerr (msg, f, ...) | |
| local stat, err = pcall(f, ...) | |
| assert(not stat and string.find(err, msg)) | |
| 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 alignment | |
| a = T.d2s(12458954321123.0) | |
| assert(a == string.pack("d", 12458954321123.0)) | |
| assert(T.s2d(a) == 12458954321123.0) | |
| 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; 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; return *", 2, 3, 4)) | |
| tcheck(t, {n=2,2,4}) | |
| t = pack(T.testC("insert -1; return *", 2, 3)) | |
| tcheck(t, {n=2,2,3}) | |
| t = pack(T.testC("insert 3; return *", 2, 3, 4, 5)) | |
| tcheck(t, {n=4,2,5,3,4}) | |
| t = pack(T.testC("replace 2; return *", 2, 3, 4, 5)) | |
| tcheck(t, {n=3,5,3,4}) | |
| t = pack(T.testC("replace -2; return *", 2, 3, 4, 5)) | |
| tcheck(t, {n=3,2,3,5}) | |
| t = pack(T.testC("remove 3; return *", 2, 3, 4, 5)) | |
| tcheck(t, {n=3,2,4,5}) | |
| t = pack(T.testC("copy 3 4; return *", 2, 3, 4, 5)) | |
| tcheck(t, {n=4,2,3,3,5}) | |
| t = pack(T.testC("copy -3 -1; return *", 2, 3, 4, 5)) | |
| tcheck(t, {n=4,2,3,4,3}) | |
| do -- testing 'rotate' | |
| local t = {10, 20, 30, 40, 50, 60} | |
| for i = -6, 6 do | |
| local s = string.format("rotate 2 %d; return 7", i) | |
| local t1 = pack(T.testC(s, 10, 20, 30, 40, 50, 60)) | |
| tcheck(t1, t) | |
| table.insert(t, 1, table.remove(t)) | |
| end | |
| t = pack(T.testC("rotate -2 1; return *", 10, 20, 30, 40)) | |
| tcheck(t, {10, 20, 40, 30}) | |
| t = pack(T.testC("rotate -2 -1; return *", 10, 20, 30, 40)) | |
| tcheck(t, {10, 20, 40, 30}) | |
| -- some corner cases | |
| t = pack(T.testC("rotate -1 0; return *", 10, 20, 30, 40)) | |
| tcheck(t, {10, 20, 30, 40}) | |
| t = pack(T.testC("rotate -1 1; return *", 10, 20, 30, 40)) | |
| tcheck(t, {10, 20, 30, 40}) | |
| t = pack(T.testC("rotate 5 -1; return *", 10, 20, 30, 40)) | |
| tcheck(t, {10, 20, 30, 40}) | |
| end | |
| -- testing non-function message handlers | |
| do | |
| local f = T.makeCfunc[[ | |
| getglobal error | |
| pushstring bola | |
| pcall 1 1 1 # call 'error' with given handler | |
| pushstatus | |
| return 2 # return error message and status | |
| ]] | |
| local msg, st = f({}) -- invalid handler | |
| assert(st == "ERRERR" and string.find(msg, "error handling")) | |
| local msg, st = f(nil) -- invalid handler | |
| assert(st == "ERRERR" and string.find(msg, "error handling")) | |
| local a = setmetatable({}, {__call = function (_, x) return x:upper() end}) | |
| local msg, st = f(a) -- callable handler | |
| assert(st == "ERRRUN" and msg == "BOLA") | |
| end | |
| 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; 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; return *", "alo", 2, 3, "joao", 12)) | |
| tcheck(t, {n=1,"alo23joao12"}) | |
| -- testing MULTRET | |
| t = pack(T.testC("call 2,-1; 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 0; 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; | |
| 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) | |
| assert(T.testC("arith /; return 1", 2, 0) == 10.0/0) | |
| a = T.testC("pushnum 10; pushint 3; arith \\; return 1") | |
| assert(a == 3.0 and math.type(a) == "float") | |
| a = T.testC("pushint 10; pushint 3; arith \\; return 1") | |
| assert(a == 3 and math.type(a) == "integer") | |
| a = assert(T.testC("pushint 10; pushint 3; arith +; return 1")) | |
| assert(a == 13 and math.type(a) == "integer") | |
| a = assert(T.testC("pushnum 10; pushint 3; arith +; return 1")) | |
| assert(a == 13 and math.type(a) == "float") | |
| 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)) | |
| -- errors in arithmetic | |
| checkerr("divide by zero", T.testC, "arith \\", 10, 0) | |
| checkerr("%%0", T.testC, "arith %", 10, 0) | |
| -- testing lessthan and lessequal | |
| assert(T.testC("compare LT 2 5, return 1", 3, 2, 2, 4, 2, 2)) | |
| assert(T.testC("compare LE 2 5, return 1", 3, 2, 2, 4, 2, 2)) | |
| assert(not T.testC("compare LT 3 4, return 1", 3, 2, 2, 4, 2, 2)) | |
| assert(T.testC("compare LE 3 4, return 1", 3, 2, 2, 4, 2, 2)) | |
| assert(T.testC("compare LT 5 2, return 1", 4, 2, 2, 3, 2, 2)) | |
| assert(not T.testC("compare LT 2 -3, return 1", "4", "2", "2", "3", "2", "2")) | |
| assert(not T.testC("compare LT -3 2, return 1", "3", "2", "2", "4", "2", "2")) | |
| -- non-valid indices produce false | |
| assert(not T.testC("compare LT 1 4, return 1")) | |
| assert(not T.testC("compare LE 9 1, return 1")) | |
| assert(not T.testC("compare EQ 9 9, 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 LT 2 5, return 1", a3, 2, 2, a4, 2, 2)) | |
| assert(T.testC("compare LE 2 5, return 1", a3, 2, 2, a4, 2, 2)) | |
| assert(T.testC("compare LT 5 -6, return 1", a4, 2, 2, a3, 2, 2)) | |
| a,b = T.testC("compare LT 5 -6, return 2", a1, 2, 2, a3, 2, 20) | |
| assert(a == 20 and b == false) | |
| a,b = T.testC("compare LE 5 -6, return 2", a1, 2, 2, a3, 2, 20) | |
| assert(a == 20 and b == false) | |
| a,b = T.testC("compare LE 5 -6, 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 | |
| local hfunc = string.gmatch("", "") -- a "heavy C function" (with upvalues) | |
| assert(debug.getupvalue(hfunc, 1)) | |
| 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) -- light C function | |
| assert(to("topointer", hfunc) ~= 0) -- "heavy" C function | |
| assert(to("topointer", function () end) ~= 0) -- Lua function | |
| assert(to("topointer", io.stdin) ~= 0) -- full userdata | |
| assert(to("func2num", 20) == 0) | |
| assert(to("func2num", T.pushuserdata(10)) == 0) | |
| assert(to("func2num", io.read) ~= 0) -- light C function | |
| assert(to("func2num", hfunc) ~= 0) -- "heavy" C function (with upvalue) | |
| a = to("tocfunction", math.deg) | |
| assert(a(3) == math.deg(3) and a == math.deg) | |
| print("testing panic function") | |
| do | |
| -- trivial error | |
| assert(T.checkpanic("pushstring hi; error") == "hi") | |
| -- using the stack inside panic | |
| assert(T.checkpanic("pushstring hi; error;", | |
| [[checkstack 5 XX | |
| pushstring ' alo' | |
| pushstring ' mundo' | |
| concat 3]]) == "hi alo mundo") | |
| -- "argerror" without frames | |
| assert(T.checkpanic("loadstring 4") == | |
| "bad argument #4 (string expected, got no value)") | |
| -- memory error | |
| T.totalmem(T.totalmem()+10000) -- set low memory limit (+10k) | |
| assert(T.checkpanic("newuserdata 20000") == "not enough memory") | |
| T.totalmem(0) -- restore high limit | |
| -- stack error | |
| if not _soft then | |
| local msg = T.checkpanic[[ | |
| pushstring "function f() f() end" | |
| loadstring -1; call 0 0 | |
| getglobal f; call 0 0 | |
| ]] | |
| assert(string.find(msg, "stack overflow")) | |
| end | |
| end | |
| -- testing deep C stack | |
| if not _soft then | |
| print("testing stack overflow") | |
| collectgarbage("stop") | |
| checkerr("XXXX", T.testC, "checkstack 1000023 XXXX") -- too deep | |
| -- too deep (with no message) | |
| checkerr("^stack overflow$", T.testC, "checkstack 1000023 ''") | |
| local s = string.rep("pushnil;checkstack 1 XX;", 1000000) | |
| checkerr("overflow", T.testC, s) | |
| collectgarbage("restart") | |
| print'+' | |
| end | |
| local lim = _soft and 500 or 12000 | |
| local prog = {"checkstack " .. (lim * 2 + 100) .. "msg", "newtable"} | |
| for i = 1,lim 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*lim + 2) | |
| for i = 1,lim do | |
| prog[#prog + 1] = "settable " .. -(2*(lim - 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,lim 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 0; | |
| pushvalue 3; insert -2; pcall 1 1 0; | |
| pcall 0 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; return *", "x=")) | |
| check3("%.", T.testC("loadfile 2; return *", ".")) | |
| check3("xxxx", T.testC("loadfile 2; return *", "xxxx")) | |
| -- test errors in non protected threads | |
| function checkerrnopro (code, msg) | |
| local th = coroutine.create(function () end) -- create new thread | |
| local stt, err = pcall(T.testC, th, code) -- run code there | |
| assert(not stt and string.find(err, msg)) | |
| end | |
| if not _soft then | |
| checkerrnopro("pushnum 3; call 0 0", "attempt to call") | |
| print"testing stack overflow in unprotected thread" | |
| function f () f() end | |
| checkerrnopro("getglobal 'f'; call 0 0;", "stack overflow") | |
| end | |
| print"+" | |
| -- testing table access | |
| do -- getp/setp | |
| local a = {} | |
| T.testC("rawsetp 2 1", a, 20) | |
| assert(a[T.pushuserdata(1)] == 20) | |
| assert(T.testC("rawgetp 2 1; return 1", a) == 20) | |
| end | |
| 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) | |
| k = T.testC("getfield 2 y, return 1", b) | |
| assert(k == 12) | |
| 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) | |
| -- | |
| do -- testing getfield/setfield with long keys | |
| local t = {_012345678901234567890123456789012345678901234567890123456789 = 32} | |
| local a = T.testC([[ | |
| getfield 2 _012345678901234567890123456789012345678901234567890123456789 | |
| return 1 | |
| ]], t) | |
| assert(a == 32) | |
| local a = T.testC([[ | |
| pushnum 33 | |
| setglobal _012345678901234567890123456789012345678901234567890123456789 | |
| ]]) | |
| assert(_012345678901234567890123456789012345678901234567890123456789 == 33) | |
| _012345678901234567890123456789012345678901234567890123456789 = nil | |
| end | |
| -- testing next | |
| a = {} | |
| t = pack(T.testC("next; return *", a, nil)) | |
| tcheck(t, {n=1,a}) | |
| a = {a=3} | |
| t = pack(T.testC("next; return *", a, nil)) | |
| tcheck(t, {n=3,a,'a',3}) | |
| t = pack(T.testC("next; pop 1; next; 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 | |
| -- testing get/setuservalue | |
| -- bug in 5.1.2 | |
| checkerr("got number", debug.setuservalue, 3, {}) | |
| checkerr("got nil", debug.setuservalue, nil, {}) | |
| checkerr("got light userdata", debug.setuservalue, T.pushuserdata(1), {}) | |
| local b = T.newuserdata(0) | |
| assert(debug.getuservalue(b) == nil) | |
| for _, v in pairs{true, false, 4.56, print, {}, b, "XYZ"} do | |
| assert(debug.setuservalue(b, v) == b) | |
| assert(debug.getuservalue(b) == v) | |
| end | |
| assert(debug.getuservalue(4) == nil) | |
| debug.setuservalue(b, function () return 10 end) | |
| collectgarbage() -- function should not be collected | |
| assert(debug.getuservalue(b)() == 10) | |
| debug.setuservalue(b, 134) | |
| collectgarbage() -- number should not be a problem for collector | |
| assert(debug.getuservalue(b) == 134) | |
| -- test barrier for uservalues | |
| T.gcstate("atomic") | |
| assert(T.gccolor(b) == "black") | |
| debug.setuservalue(b, {x = 100}) | |
| T.gcstate("pause") -- complete collection | |
| assert(debug.getuservalue(b).x == 100) -- uvalue should be there | |
| -- long chain of userdata | |
| for i = 1, 1000 do | |
| local bb = T.newuserdata(0) | |
| debug.setuservalue(bb, b) | |
| b = bb | |
| end | |
| collectgarbage() -- nothing should not be collected | |
| for i = 1, 1000 do | |
| b = debug.getuservalue(b) | |
| end | |
| assert(debug.getuservalue(b).x == 100) | |
| b = 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 | |
| collectgarbage() | |
| x = collectgarbage("count") | |
| 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) | |
| checkerr("FILE%* expected, got userdata", io.input, a) | |
| checkerr("FILE%* expected, got userdata", 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 EQ 2 4; return 1", print, 1, print, 20)) | |
| assert(T.testC("compare EQ 3 2; return 1", 'alo', "alo")) | |
| assert(T.testC("compare EQ 2 3; return 1", nil, nil)) | |
| assert(not T.testC("compare EQ 2 3; return 1", {}, {})) | |
| assert(not T.testC("compare EQ 2 3; return 1")) | |
| assert(not T.testC("compare EQ 2 3; 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 EQ 2 3; return 1", f(10), f(10))) | |
| assert(not T.testC("compare EQ 2 3; 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"; pushint 1; | |
| settable -3]]) | |
| assert(T.doremote(L1, "return a.x") == "1") | |
| T.closestate(L1) | |
| L1 = nil | |
| print('+') | |
| ------------------------------------------------------------------------- | |
| -- testing memory limits | |
| ------------------------------------------------------------------------- | |
| checkerr("block too big", T.newuserdata, math.maxinteger) | |
| collectgarbage() | |
| T.totalmem(T.totalmem()+5000) -- set low memory limit (+5k) | |
| checkerr("not enough memory", load"local a={}; for i=1,100000 do a[i]=i end") | |
| T.totalmem(0) -- 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(0) -- 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) | |
| do -- auxiliary buffer | |
| local lim = 100 | |
| local a = {}; for i = 1, lim do a[i] = "01234567890123456789" end | |
| testamem("auxiliary buffer", function () | |
| return (#table.concat(a, ",") == 20*lim + lim - 1) | |
| end) | |
| 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' | |