[test-suite] db.js

1 files changed, 1129 insertions, 0 deletions

diff --git a/tests/test-suite/inprogress/db.js b/tests/test-suite/inprogress/db.js
index af1d042..2481096 100644
--- a/tests/test-suite/inprogress/db.js
+++ b/tests/test-suite/inprogress/db.js
@@ -344,3 +344,1132 @@ test("[test-suite] db: parameter names", function (t) {
     }, "Lua program ran without error");
 
 });
+
+
+test("[test-suite] db: vararg", function (t) {
+    let luaCode = `
+        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, (_soft and 100 or 1000) do a[i] = i end
+        foo(table.unpack(a))
+        a = nil
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: access to vararg in non-vararg function", function (t) {
+    let luaCode = `
+        local function foo () return debug.getlocal(1, -1) end
+        assert(not foo(10))
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: test hook presence in debug info", function (t) {
+    let luaCode = `
+        do   -- test hook presence in debug info
+          assert(not debug.gethook())
+          local count = 0
+          local function f ()
+            assert(debug.getinfo(1).namewhat == "hook")
+            local sndline = string.match(debug.traceback(), "\\n(.-)\\n")
+            assert(string.find(sndline, "hook"))
+            count = count + 1
+          end
+          debug.sethook(f, "l")
+          local a = 0
+          _ENV.a = a
+          a = 1
+          debug.sethook()
+          assert(count == 4)
+        end
+
+        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)
+          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()
+
+        print(a[f], a[g], a[assert], a[debug.getlocal], a[print])
+        assert(a[f] and a[g] and a[assert] and a[debug.getlocal] and not a[print])
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: tests for manipulating non-registered locals (C and Lua temporaries)", function (t) {
+    let luaCode = `
+        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)
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing access to function arguments", function (t) {
+    let luaCode = `
+        local function collectlocals (level)
+          local tab = {}
+          for i = 1, math.huge do
+            local n, v = debug.getlocal(level + 1, i)
+            if not (n and string.find(n, "^[a-zA-Z0-9_]+$")) then
+               break   -- consider only real variables
+            end
+            tab[n] = v
+          end
+          return tab
+        end
+
+
+        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 = collectlocals(2)
+          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)
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing access to local variables in return hook (bug in 5.2)", function (t) {
+    let luaCode = `
+        local function collectlocals (level)
+          local tab = {}
+          for i = 1, math.huge do
+            local n, v = debug.getlocal(level + 1, i)
+            if not (n and string.find(n, "^[a-zA-Z0-9_]+$")) then
+               break   -- consider only real variables
+            end
+            tab[n] = v
+          end
+          return tab
+        end
+
+        do
+          local function foo (a, b)
+            do local x,y,z end
+            local c, d = 10, 20
+            return
+          end
+
+          local function aux ()
+            if debug.getinfo(2).name == "foo" then
+              foo = nil   -- to signal that it found 'foo'
+              local tab = {a = 100, b = 200, c = 10, d = 20}
+              for n, v in pairs(collectlocals(2)) do
+                assert(tab[n] == v)
+                tab[n] = nil
+              end
+              assert(next(tab) == nil)    -- 'tab' must be empty
+            end
+          end
+
+          debug.sethook(aux, "r"); foo(100, 200); debug.sethook()
+          assert(foo == nil)
+        end
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing upvalue access", function (t) {
+    let luaCode = `
+        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(not debug.getupvalue(foo1, 3))
+        assert(not debug.getupvalue(foo1, 0))
+        assert(not debug.setupvalue(foo1, 3, "xuxu"))
+        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) == "")  
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing count hooks", function (t) {
+    let luaCode = `
+        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)
+
+        do
+          debug.sethook(print, "", 2^24 - 1)   -- count upperbound
+          local f,m,c = debug.gethook()
+          assert(({debug.gethook()})[3] == 2^24 - 1)
+        end
+
+        debug.sethook()
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: tests for tail calls", function (t) {
+    let luaCode = `
+        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 = _soft and 3000 or 30000
+        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)
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing local function information", function (t) {
+    let luaCode = `
+        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
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing traceback", function (t) {
+    let luaCode = `
+        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"), "'debug.traceback'"))
+        assert(string.find(debug.traceback("hi", 0), "'debug.traceback'"))
+        assert(string.find(debug.traceback(), "^stack traceback:\\n"))
+
+        do  -- C-function names in traceback
+          local st, msg = (function () return pcall end)()(debug.traceback)
+          assert(st == true and string.find(msg, "pcall"))
+        end
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing nparams, nups e isvararg", function (t) {
+    let luaCode = `
+        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")
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing debugging of coroutines", function (t) {
+    let luaCode = `
+        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)
+        -- TODO: will fail because of filename not being db.lua
+        -- 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(not debug.getinfo(co, 2))
+        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(not debug.gethook())
+        checktraceback(co, {})
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: check get/setlocal in coroutines", function (t) {
+    let luaCode = `
+        co = coroutine.create(function (x)
+          local a, b = coroutine.yield(x)
+          assert(a == 100 and b == nil)
+          return x
+        end)
+        a, b = coroutine.resume(co, 10)
+        assert(a and b == 10)
+        a, b = debug.getlocal(co, 1, 1)
+        assert(a == "x" and b == 10)
+        assert(not debug.getlocal(co, 1, 5))
+        assert(debug.setlocal(co, 1, 1, 30) == "x")
+        assert(not debug.setlocal(co, 1, 5, 40))
+        a, b = coroutine.resume(co, 100)
+        assert(a and b == 30)
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: check traceback of suspended (or dead with error) coroutines", function (t) {
+    let luaCode = `
+        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
+
+        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 = {"'coroutine.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)
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: check test acessing line numbers of a coroutine from a resume inside a C function", function (t) {
+    let luaCode = `
+        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")
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: test tagmethod information", function (t) {
+    let luaCode = `
+        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;
+          __mul = f; __idiv = f; __unm = f; __len = f; __sub = f;
+          __shl = f; __shr = f; __bor = f; __bxor = f;
+          __eq = f; __le = f; __lt = f; __unm = f; __len = f; __band = f;
+          __bnot = 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+3 == "__add" and 3-a == "__sub" and a*3 == "__mul" and
+               -a == "__unm" and #a == "__len" and a&3 == "__band")
+        assert(a|3 == "__bor" and 3~a == "__bxor" and a<<3 == "__shl" and
+               a>>1 == "__shr")
+        assert (a==b and a.op == "__eq")
+        assert (a>=b and a.op == "__le")
+        assert (a>b and a.op == "__lt")
+        assert(~a == "__bnot")
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing for-iterator name", function (t) {
+    let luaCode = `
+        do
+          local function f()
+            assert(debug.getinfo(1).name == "for iterator")
+          end
+
+          for i in f do end
+        end
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing traceback sizes", function (t) {
+    let luaCode = `
+        do
+          local function countlines (s)
+            return select(2, string.gsub(s, "\n", ""))
+          end
+
+          local function deep (lvl, n)
+            if lvl == 0 then
+              return (debug.traceback("message", n))
+            else
+              return (deep(lvl-1, n))
+            end
+          end
+
+          local function checkdeep (total, start)
+            local s = deep(total, start)
+            local rest = string.match(s, "^message\nstack traceback:\n(.*)$")
+            local cl = countlines(rest)
+            -- at most 10 lines in first part, 11 in second, plus '...'
+            assert(cl <= 10 + 11 + 1)
+            local brk = string.find(rest, "%.%.%.")
+            if brk then   -- does message have '...'?
+              local rest1 = string.sub(rest, 1, brk)
+              local rest2 = string.sub(rest, brk, #rest)
+              assert(countlines(rest1) == 10 and countlines(rest2) == 11)
+            else
+              assert(cl == total - start + 2)
+            end
+          end
+
+          for d = 1, 51, 10 do
+            for l = 1, d do
+              -- use coroutines to ensure complete control of the stack
+              coroutine.wrap(checkdeep)(d, l)
+            end
+          end
+
+        end
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: testing debug functions on chunk without debug info", function (t) {
+    let luaCode = `
+        prog = [[-- program to be loaded without debug information
+        local debug = require'debug'
+        local a = 12  -- a local variable
+
+        local n, v = debug.getlocal(1, 1)
+        assert(n == "(*temporary)" and v == debug)   -- unkown name but known value
+        n, v = debug.getlocal(1, 2)
+        assert(n == "(*temporary)" and v == 12)   -- unkown name but known value
+
+        -- a function with an upvalue
+        local f = function () local x; return a end
+        n, v = debug.getupvalue(f, 1)
+        assert(n == "(*no name)" and v == 12)
+        assert(debug.setupvalue(f, 1, 13) == "(*no name)")
+        assert(a == 13)
+
+        local t = debug.getinfo(f)
+        assert(t.name == nil and t.linedefined > 0 and
+               t.lastlinedefined == t.linedefined and
+               t.short_src == "?")
+        assert(debug.getinfo(1).currentline == -1)
+
+        t = debug.getinfo(f, "L").activelines
+        assert(next(t) == nil)    -- active lines are empty
+
+        -- dump/load a function without debug info
+        f = load(string.dump(f))
+
+        t = debug.getinfo(f)
+        assert(t.name == nil and t.linedefined > 0 and
+               t.lastlinedefined == t.linedefined and
+               t.short_src == "?")
+        assert(debug.getinfo(1).currentline == -1)
+
+        return a
+        ]]
+
+
+        -- load 'prog' without debug info
+        local f = assert(load(string.dump(load(prog), true)))
+
+        assert(f() == 13)
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] db: tests for 'source' in binary dumps", function (t) {
+    let luaCode = `
+        do
+          local prog = [[
+            return function (x)
+              return function (y) 
+                return x + y
+              end
+            end
+          ]]
+          local name = string.rep("x", 1000)
+          local p = assert(load(prog, name))
+          -- load 'p' as a binary chunk with debug information
+          local c = string.dump(p)
+          assert(#c > 1000 and #c < 2000)   -- no repetition of 'source' in dump
+          local f = assert(load(c))
+          local g = f()
+          local h = g(3)
+          assert(h(5) == 8)
+          assert(debug.getinfo(f).source == name and   -- all functions have 'source'
+                 debug.getinfo(g).source == name and 
+                 debug.getinfo(h).source == name)
+          -- again, without debug info
+          local c = string.dump(p, true)
+          assert(#c < 500)   -- no 'source' in dump
+          local f = assert(load(c))
+          local g = f()
+          local h = g(30)
+          assert(h(50) == 80)
+          assert(debug.getinfo(f).source == '=?' and   -- no function has 'source'
+                 debug.getinfo(g).source == '=?' and 
+                 debug.getinfo(h).source == '=?')
+        end
+    `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(prefix + luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});